{-# OPTIONS_GHC -Wunused-imports #-}

{-| Pretty printing functions.
-}
module Agda.Syntax.Common.Pretty
    ( module Agda.Syntax.Common.Pretty
    , module Text.PrettyPrint.Annotated
    ) where

import Prelude hiding (null)

import Control.DeepSeq

import qualified Data.List as List
import qualified Data.Foldable as Fold
import qualified Data.IntSet as IntSet
import qualified Data.IntMap as IntMap
import qualified Data.Text as T
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.IntSet (IntSet)
import Data.IntMap (IntMap)
import Data.Word (Word64, Word32)
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Int (Int32)
import Data.Map (Map)
import Data.Set (Set)

import qualified Text.PrettyPrint.Annotated as P
import Text.PrettyPrint.Annotated hiding
  ( Doc, TextDetails(Str), empty, (<>), sep, fsep, hsep, hcat, vcat, punctuate

  , parens, brackets, braces, quotes, doubleQuotes

  , semi, comma, colon, space, equals, lparen, rparen, lbrack, rbrack
  , lbrace, rbrace
  , annotate
  )

import Agda.Syntax.Common.Aspect
import Agda.Syntax.Position

import Agda.Utils.DocTree qualified as DocTree
import Agda.Utils.FileName
import Agda.Utils.Float
import Agda.Utils.List1 (List1)
import qualified Agda.Utils.List1 as List1
import qualified Agda.Utils.Maybe.Strict as Strict
import Agda.Utils.Null
import Agda.Utils.Size

type DocTree = DocTree.DocTree Aspects

---------------------------------------------------------------------------
-- * Pretty class

-- | The type of documents. We use documents annotated by 'Aspects' to
-- record syntactic highlighting information that is generated during
-- pretty-printing.
type Doc = P.Doc Aspects

-- | While 'Show' is for rendering data in Haskell syntax,
--   'Pretty' is for displaying data to the world, i.e., the
--   user and the environment.
--
--   Atomic data has no inner document structure, so just
--   implement 'pretty' as @pretty a = text $ ... a ...@.

class Pretty a where
  pretty      :: a -> Doc
  prettyPrec  :: Int -> a -> Doc
  prettyList  :: [a] -> Doc

  pretty      = Int -> a -> Doc Aspects
forall a. Pretty a => Int -> a -> Doc Aspects
prettyPrec Int
0
  prettyPrec  = (a -> Doc Aspects) -> Int -> a -> Doc Aspects
forall a b. a -> b -> a
const a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty
  prettyList  = Doc Aspects -> Doc Aspects
brackets (Doc Aspects -> Doc Aspects)
-> ([a] -> Doc Aspects) -> [a] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Doc Aspects
forall a. Pretty a => [a] -> Doc Aspects
prettyList_

  {-# MINIMAL pretty | prettyPrec #-}

-- | Use instead of 'show' when printing to world.

prettyShow :: Pretty a => a -> String
prettyShow :: forall a. Pretty a => a -> [Char]
prettyShow = Doc Aspects -> [Char]
forall a. Doc a -> [Char]
render (Doc Aspects -> [Char]) -> (a -> Doc Aspects) -> a -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty

---------------------------------------------------------------------------
-- * Pretty instances

instance Pretty Bool    where pretty :: Bool -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects) -> (Bool -> [Char]) -> Bool -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> [Char]
forall a. Show a => a -> [Char]
show
instance Pretty Int     where pretty :: Int -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects) -> (Int -> [Char]) -> Int -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char]
forall a. Show a => a -> [Char]
show
instance Pretty Int32   where pretty :: Int32 -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects)
-> (Int32 -> [Char]) -> Int32 -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> [Char]
forall a. Show a => a -> [Char]
show
instance Pretty Integer where pretty :: Integer -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects)
-> (Integer -> [Char]) -> Integer -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> [Char]
forall a. Show a => a -> [Char]
show
instance Pretty Word32  where pretty :: Word32 -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects)
-> (Word32 -> [Char]) -> Word32 -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> [Char]
forall a. Show a => a -> [Char]
show
instance Pretty Word64  where pretty :: Word64 -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects)
-> (Word64 -> [Char]) -> Word64 -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> [Char]
forall a. Show a => a -> [Char]
show
instance Pretty Double  where pretty :: Double -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects)
-> (Double -> [Char]) -> Double -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> [Char]
toStringWithoutDotZero
instance Pretty Text    where pretty :: Text -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects) -> (Text -> [Char]) -> Text -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack

instance Pretty Char where
  pretty :: Char -> Doc Aspects
pretty Char
c = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text [Char
c]
  prettyList :: [Char] -> Doc Aspects
prettyList = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text


-- The equational constraint forces GHC to pick this instance and unify
-- the type variable, instead of deferring selection to when the type of
-- annotations is solved.
instance a ~ Aspects => Pretty (P.Doc a) where
  pretty :: Doc a -> Doc Aspects
pretty = Doc a -> Doc a
Doc a -> Doc Aspects
forall a. a -> a
id

instance a ~ Aspects => Pretty (DocTree.DocTree a) where
  pretty :: DocTree a -> Doc Aspects
pretty = DocTree a -> Doc a
DocTree a -> Doc Aspects
forall ann. DocTree ann -> Doc ann
DocTree.prettyDocTree

instance Pretty () where
  pretty :: () -> Doc Aspects
pretty ()
_ = Doc Aspects
forall a. Doc a
P.empty

instance (Pretty a, Pretty b) => Pretty (a, b) where
    pretty :: (a, b) -> Doc Aspects
pretty (a
a, b
b) = Doc Aspects -> Doc Aspects
parens (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ (a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty a
a Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
comma) Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> b -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty b
b

instance Pretty a => Pretty (Maybe a) where
  prettyPrec :: Int -> Maybe a -> Doc Aspects
prettyPrec Int
p Maybe a
Nothing  = Doc Aspects
forall a. Doc a
P.empty
  prettyPrec Int
p (Just a
x) = Int -> a -> Doc Aspects
forall a. Pretty a => Int -> a -> Doc Aspects
prettyPrec Int
p a
x

instance Pretty a => Pretty (Strict.Maybe a) where
  prettyPrec :: Int -> Maybe a -> Doc Aspects
prettyPrec Int
p Maybe a
Strict.Nothing  = Doc Aspects
forall a. Doc a
P.empty
  prettyPrec Int
p (Strict.Just a
x) = Int -> a -> Doc Aspects
forall a. Pretty a => Int -> a -> Doc Aspects
prettyPrec Int
p a
x

instance Pretty a => Pretty [a] where
  pretty :: [a] -> Doc Aspects
pretty = [a] -> Doc Aspects
forall a. Pretty a => [a] -> Doc Aspects
prettyList

instance Pretty a => Pretty (List1 a) where
  pretty :: List1 a -> Doc Aspects
pretty = [a] -> Doc Aspects
forall a. Pretty a => [a] -> Doc Aspects
prettyList ([a] -> Doc Aspects) -> (List1 a -> [a]) -> List1 a -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. List1 a -> [a]
List1 a -> [Item (List1 a)]
forall l. IsList l => l -> [Item l]
List1.toList

instance Pretty IntSet where
  pretty :: IntSet -> Doc Aspects
pretty = [Int] -> Doc Aspects
forall a. Pretty a => [a] -> Doc Aspects
prettySet ([Int] -> Doc Aspects)
-> (IntSet -> [Int]) -> IntSet -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntSet -> [Int]
IntSet.toList

instance Pretty a => Pretty (Set a) where
  pretty :: Set a -> Doc Aspects
pretty = [a] -> Doc Aspects
forall a. Pretty a => [a] -> Doc Aspects
prettySet ([a] -> Doc Aspects) -> (Set a -> [a]) -> Set a -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> [a]
forall a. Set a -> [a]
Set.toList

instance Pretty a => Pretty (IntMap a) where
  pretty :: IntMap a -> Doc Aspects
pretty = [(Int, a)] -> Doc Aspects
forall a b. (Pretty a, Pretty b) => [(a, b)] -> Doc Aspects
prettyMap ([(Int, a)] -> Doc Aspects)
-> (IntMap a -> [(Int, a)]) -> IntMap a -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntMap a -> [(Int, a)]
forall a. IntMap a -> [(Int, a)]
IntMap.toList

instance (Pretty k, Pretty v) => Pretty (Map k v) where
  pretty :: Map k v -> Doc Aspects
pretty = [(k, v)] -> Doc Aspects
forall a b. (Pretty a, Pretty b) => [(a, b)] -> Doc Aspects
prettyMap ([(k, v)] -> Doc Aspects)
-> (Map k v -> [(k, v)]) -> Map k v -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList

-- Pretty instances for dependencies of this module (to avoid dependency cycles)

instance Pretty AbsolutePath where
  pretty :: AbsolutePath -> Doc Aspects
pretty = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects)
-> (AbsolutePath -> [Char]) -> AbsolutePath -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbsolutePath -> [Char]
filePath

instance Pretty RangeFile where
  pretty :: RangeFile -> Doc Aspects
pretty = AbsolutePath -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty (AbsolutePath -> Doc Aspects)
-> (RangeFile -> AbsolutePath) -> RangeFile -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RangeFile -> AbsolutePath
rangeFilePath

prettyLineColumn :: Position' a -> Doc
prettyLineColumn :: forall a. Position' a -> Doc Aspects
prettyLineColumn (Pn a
_ Word32
_ Word32
l Word32
c) = Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
l Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
dot Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
c

instance Pretty a => Pretty (Position' (Strict.Maybe a)) where
  pretty :: Position' (Maybe a) -> Doc Aspects
pretty Position' (Maybe a)
p = case Position' (Maybe a) -> Maybe a
forall a. Position' a -> a
srcFile Position' (Maybe a)
p of
    Maybe a
Strict.Nothing -> Position' (Maybe a) -> Doc Aspects
forall a. Position' a -> Doc Aspects
prettyLineColumn Position' (Maybe a)
p
    Strict.Just a
f  -> a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty a
f Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
colon Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Position' (Maybe a) -> Doc Aspects
forall a. Position' a -> Doc Aspects
prettyLineColumn Position' (Maybe a)
p

instance Pretty PositionWithoutFile where
  pretty :: PositionWithoutFile -> Doc Aspects
pretty = PositionWithoutFile -> Doc Aspects
forall a. Position' a -> Doc Aspects
prettyLineColumn

prettyInterval :: Eq a => Position' a -> Position' a -> Doc
prettyInterval :: forall a. Eq a => Position' a -> Position' a -> Doc Aspects
prettyInterval Position' a
s Position' a
e
    | Position' a
s Position' a -> Position' a -> Bool
forall a. Eq a => a -> a -> Bool
== Position' a
e    = Doc Aspects
start
    | Bool
otherwise = Doc Aspects
start Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
"-" Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
end
    where
      sl :: Word32
sl = Position' a -> Word32
forall a. Position' a -> Word32
posLine Position' a
s
      el :: Word32
el = Position' a -> Word32
forall a. Position' a -> Word32
posLine Position' a
e
      sc :: Word32
sc = Position' a -> Word32
forall a. Position' a -> Word32
posCol Position' a
s
      ec :: Word32
ec = Position' a -> Word32
forall a. Position' a -> Word32
posCol Position' a
e

      start :: Doc
      start :: Doc Aspects
start = Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
sl Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
dot Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
sc

      Doc Aspects
end :: Doc
        | Word32
sl Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
el  = Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
ec
        | Bool
otherwise = Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
el Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
dot Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Word32 -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty Word32
ec

instance Pretty a => Pretty (Interval' a) where
  pretty :: Interval' a -> Doc
  pretty :: Interval' a -> Doc Aspects
pretty i :: Interval' a
i@(Interval a
f PositionWithoutFile
s PositionWithoutFile
e) = Doc Aspects
-> (Doc Aspects -> Doc Aspects -> Doc Aspects)
-> Doc Aspects
-> Doc Aspects
forall a b. Null a => a -> (a -> b -> b) -> b -> b
applyUnlessNull (a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty a
f) (\ Doc Aspects
d -> ((Doc Aspects
d Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
colon) Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<>)) (PositionWithoutFile -> PositionWithoutFile -> Doc Aspects
forall a. Eq a => Position' a -> Position' a -> Doc Aspects
prettyInterval PositionWithoutFile
s PositionWithoutFile
e)

instance Pretty a => Pretty (Range' a) where
  pretty :: Range' a -> Doc Aspects
pretty Range' a
r = Doc Aspects
-> (Interval' a -> Doc Aspects)
-> Maybe (Interval' a)
-> Doc Aspects
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc Aspects
forall a. Null a => a
empty Interval' a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty (Range' a -> Maybe (Interval' a)
forall a. Range' a -> Maybe (Interval' a)
rangeToIntervalWithFile Range' a
r)

instance (Pretty a, HasRange a) => Pretty (PrintRange a) where
  pretty :: PrintRange a -> Doc Aspects
pretty (PrintRange a
a) = a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty a
a Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> Doc Aspects -> Doc Aspects
parens (Doc Aspects
"at" Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> Range' SrcFile -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty (a -> Range' SrcFile
forall a. HasRange a => a -> Range' SrcFile
getRange a
a))


---------------------------------------------------------------------------
-- * Generalizing the original type from list to Foldable

sep, fsep, hsep, hcat, vcat :: Foldable t => t Doc -> Doc
sep :: forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
sep  = [Doc Aspects] -> Doc Aspects
forall a. [Doc a] -> Doc a
P.sep  ([Doc Aspects] -> Doc Aspects)
-> (t (Doc Aspects) -> [Doc Aspects])
-> t (Doc Aspects)
-> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t (Doc Aspects) -> [Doc Aspects]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList
fsep :: forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
fsep = [Doc Aspects] -> Doc Aspects
forall a. [Doc a] -> Doc a
P.fsep ([Doc Aspects] -> Doc Aspects)
-> (t (Doc Aspects) -> [Doc Aspects])
-> t (Doc Aspects)
-> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t (Doc Aspects) -> [Doc Aspects]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList
hsep :: forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
hsep = [Doc Aspects] -> Doc Aspects
forall a. [Doc a] -> Doc a
P.hsep ([Doc Aspects] -> Doc Aspects)
-> (t (Doc Aspects) -> [Doc Aspects])
-> t (Doc Aspects)
-> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t (Doc Aspects) -> [Doc Aspects]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList
hcat :: forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
hcat = [Doc Aspects] -> Doc Aspects
forall a. [Doc a] -> Doc a
P.hcat ([Doc Aspects] -> Doc Aspects)
-> (t (Doc Aspects) -> [Doc Aspects])
-> t (Doc Aspects)
-> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t (Doc Aspects) -> [Doc Aspects]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList
vcat :: forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
vcat = [Doc Aspects] -> Doc Aspects
forall a. [Doc a] -> Doc a
P.vcat ([Doc Aspects] -> Doc Aspects)
-> (t (Doc Aspects) -> [Doc Aspects])
-> t (Doc Aspects)
-> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t (Doc Aspects) -> [Doc Aspects]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList

punctuate :: Foldable t => Doc -> t Doc -> [Doc]
punctuate :: forall (t :: * -> *).
Foldable t =>
Doc Aspects -> t (Doc Aspects) -> [Doc Aspects]
punctuate Doc Aspects
d = Doc Aspects -> [Doc Aspects] -> [Doc Aspects]
forall a. Doc a -> [Doc a] -> [Doc a]
P.punctuate Doc Aspects
d ([Doc Aspects] -> [Doc Aspects])
-> (t (Doc Aspects) -> [Doc Aspects])
-> t (Doc Aspects)
-> [Doc Aspects]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t (Doc Aspects) -> [Doc Aspects]
forall a. t a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList

---------------------------------------------------------------------------
-- * 'Doc' utilities

vsep :: [Doc] -> Doc
vsep :: [Doc Aspects] -> Doc Aspects
vsep = [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
vcat ([Doc Aspects] -> Doc Aspects)
-> ([Doc Aspects] -> [Doc Aspects]) -> [Doc Aspects] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc Aspects -> [Doc Aspects] -> [Doc Aspects]
forall a. a -> [a] -> [a]
List.intersperse Doc Aspects
""

twords :: Text -> [Doc]
twords :: Text -> [Doc Aspects]
twords = (Text -> Doc Aspects) -> [Text] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty ([Text] -> [Doc Aspects])
-> (Text -> [Text]) -> Text -> [Doc Aspects]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
Text.words

pwords :: String -> [Doc]
pwords :: [Char] -> [Doc Aspects]
pwords = ([Char] -> Doc Aspects) -> [[Char]] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([[Char]] -> [Doc Aspects])
-> ([Char] -> [[Char]]) -> [Char] -> [Doc Aspects]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words

fwords :: String -> Doc
fwords :: [Char] -> Doc Aspects
fwords = [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
fsep ([Doc Aspects] -> Doc Aspects)
-> ([Char] -> [Doc Aspects]) -> [Char] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Doc Aspects]
pwords

-- | Separate, but only if both separees are not null.

hsepWith :: Doc -> Doc -> Doc -> Doc
hsepWith :: Doc Aspects -> Doc Aspects -> Doc Aspects -> Doc Aspects
hsepWith Doc Aspects
sep Doc Aspects
d1 Doc Aspects
d2
  | Doc Aspects -> Bool
forall a. Null a => a -> Bool
null Doc Aspects
d2   = Doc Aspects
d1
  | Doc Aspects -> Bool
forall a. Null a => a -> Bool
null Doc Aspects
d1   = Doc Aspects
d2
  | Bool
otherwise = Doc Aspects
d1 Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> Doc Aspects
sep Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> Doc Aspects
d2

-- | Comma separated list, without the brackets.
prettyList_ :: Pretty a => [a] -> Doc
prettyList_ :: forall a. Pretty a => [a] -> Doc Aspects
prettyList_ = [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
fsep ([Doc Aspects] -> Doc Aspects)
-> ([a] -> [Doc Aspects]) -> [a] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc Aspects -> [Doc Aspects] -> [Doc Aspects]
forall (t :: * -> *).
Foldable t =>
Doc Aspects -> t (Doc Aspects) -> [Doc Aspects]
punctuate Doc Aspects
comma ([Doc Aspects] -> [Doc Aspects])
-> ([a] -> [Doc Aspects]) -> [a] -> [Doc Aspects]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Doc Aspects) -> [a] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map a -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty

-- | Pretty print a set.
prettySet :: Pretty a => [a] -> Doc
prettySet :: forall a. Pretty a => [a] -> Doc Aspects
prettySet = Doc Aspects -> Doc Aspects
braces (Doc Aspects -> Doc Aspects)
-> ([a] -> Doc Aspects) -> [a] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Doc Aspects
forall a. Pretty a => [a] -> Doc Aspects
prettyList_

-- | Pretty print an association list.
prettyMap :: (Pretty k, Pretty v) => [(k,v)] -> Doc
prettyMap :: forall a b. (Pretty a, Pretty b) => [(a, b)] -> Doc Aspects
prettyMap = Doc Aspects -> Doc Aspects
braces (Doc Aspects -> Doc Aspects)
-> ([(k, v)] -> Doc Aspects) -> [(k, v)] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
fsep ([Doc Aspects] -> Doc Aspects)
-> ([(k, v)] -> [Doc Aspects]) -> [(k, v)] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc Aspects -> [Doc Aspects] -> [Doc Aspects]
forall (t :: * -> *).
Foldable t =>
Doc Aspects -> t (Doc Aspects) -> [Doc Aspects]
punctuate Doc Aspects
comma ([Doc Aspects] -> [Doc Aspects])
-> ([(k, v)] -> [Doc Aspects]) -> [(k, v)] -> [Doc Aspects]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, v) -> Doc Aspects) -> [(k, v)] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map (k, v) -> Doc Aspects
forall a b. (Pretty a, Pretty b) => (a, b) -> Doc Aspects
prettyAssign

-- | Pretty print a single association.
prettyAssign :: (Pretty k, Pretty v) => (k,v) -> Doc
prettyAssign :: forall a b. (Pretty a, Pretty b) => (a, b) -> Doc Aspects
prettyAssign (k
k, v
v) = [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
sep [ Int -> k -> Doc Aspects
forall a. Pretty a => Int -> a -> Doc Aspects
prettyPrec Int
1 k
k Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> Doc Aspects -> Doc Aspects
hlSymbol Doc Aspects
"->", Int -> Doc Aspects -> Doc Aspects
forall a. Int -> Doc a -> Doc a
nest Int
2 (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ v -> Doc Aspects
forall a. Pretty a => a -> Doc Aspects
pretty v
v ]

-- ASR (2016-12-13): In pretty >= 1.1.2.0 the below function 'mparens'
-- is called 'maybeParens'. I didn't use that name due to the issue
-- https://github.com/haskell/pretty/issues/40.

-- | Apply 'parens' to 'Doc' if boolean is true.
mparens :: Bool -> Doc -> Doc
mparens :: Bool -> Doc Aspects -> Doc Aspects
mparens Bool
True  = Doc Aspects -> Doc Aspects
parens
mparens Bool
False = Doc Aspects -> Doc Aspects
forall a. a -> a
id

-- | Only wrap in parens if not 'empty'
parensNonEmpty :: Doc -> Doc
parensNonEmpty :: Doc Aspects -> Doc Aspects
parensNonEmpty Doc Aspects
d = if Doc Aspects -> Bool
forall a. Null a => a -> Bool
null Doc Aspects
d then Doc Aspects
forall a. Null a => a
empty else Doc Aspects -> Doc Aspects
parens Doc Aspects
d

-- | Return 'empty' for empty strings.
textNonEmpty :: String -> Doc
textNonEmpty :: [Char] -> Doc Aspects
textNonEmpty = \case
  [Char]
"" -> Doc Aspects
forall a. Null a => a
empty
  [Char]
s  -> [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text [Char]
s

-- | @align max rows@ lays out the elements of @rows@ in two columns,
-- with the second components aligned. The alignment column of the
-- second components is at most @max@ characters to the right of the
-- left-most column.
--
-- Precondition: @max > 0@.

align :: Int -> [(String, Doc)] -> Doc
align :: Int -> [([Char], Doc Aspects)] -> Doc Aspects
align Int
max [([Char], Doc Aspects)]
rows =
  [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
vcat ([Doc Aspects] -> Doc Aspects) -> [Doc Aspects] -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ (([Char], Doc Aspects) -> Doc Aspects)
-> [([Char], Doc Aspects)] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map (\([Char]
s, Doc Aspects
d) -> [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text [Char]
s Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
$$ Int -> Doc Aspects -> Doc Aspects
forall a. Int -> Doc a -> Doc a
nest (Int
maxLen Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Doc Aspects
d) ([([Char], Doc Aspects)] -> [Doc Aspects])
-> [([Char], Doc Aspects)] -> [Doc Aspects]
forall a b. (a -> b) -> a -> b
$ [([Char], Doc Aspects)]
rows
  where maxLen :: Int
maxLen = [Int] -> Int
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ Int
0 Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
max) ((([Char], Doc Aspects) -> Int) -> [([Char], Doc Aspects)] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map ([Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Char] -> Int)
-> (([Char], Doc Aspects) -> [Char])
-> ([Char], Doc Aspects)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Doc Aspects) -> [Char]
forall a b. (a, b) -> a
fst) [([Char], Doc Aspects)]
rows)

-- | Handles strings with newlines properly (preserving indentation)
multiLineText :: String -> Doc
multiLineText :: [Char] -> Doc Aspects
multiLineText = [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
vcat ([Doc Aspects] -> Doc Aspects)
-> ([Char] -> [Doc Aspects]) -> [Char] -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Doc Aspects) -> [[Char]] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([[Char]] -> [Doc Aspects])
-> ([Char] -> [[Char]]) -> [Char] -> [Doc Aspects]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
lines

infixl 6 <?>
-- | @a <?> b = hang a 2 b@
(<?>) :: Doc -> Doc -> Doc
Doc Aspects
a <?> :: Doc Aspects -> Doc Aspects -> Doc Aspects
<?> Doc Aspects
b = Doc Aspects -> Int -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Int -> Doc a -> Doc a
hang Doc Aspects
a Int
2 Doc Aspects
b

-- | @pshow = text . show@
pshow :: Show a => a -> Doc
pshow :: forall a. Show a => a -> Doc Aspects
pshow = [Char] -> Doc Aspects
forall a. [Char] -> Doc a
text ([Char] -> Doc Aspects) -> (a -> [Char]) -> a -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [Char]
forall a. Show a => a -> [Char]
show

singPlural :: Sized a => a -> c -> c -> c
singPlural :: forall a c. Sized a => a -> c -> c -> c
singPlural a
xs c
singular c
plural = if a -> Peano
forall a. Sized a => a -> Peano
natSize a
xs Peano -> Peano -> Bool
forall a. Eq a => a -> a -> Bool
== Peano
1 then c
singular else c
plural

pluralS :: Sized a => a -> Doc -> Doc
pluralS :: forall a. Sized a => a -> Doc Aspects -> Doc Aspects
pluralS a
xs Doc Aspects
d = a -> Doc Aspects -> Doc Aspects -> Doc Aspects
forall a c. Sized a => a -> c -> c -> c
singPlural a
xs Doc Aspects
d (Doc Aspects
d Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
"s")

-- | Used for with-like 'telescopes'

prefixedThings :: Doc -> [Doc] -> Doc
prefixedThings :: Doc Aspects -> [Doc Aspects] -> Doc Aspects
prefixedThings Doc Aspects
kw = \case
  []           -> Doc Aspects
forall a. Doc a
P.empty
  (Doc Aspects
doc : [Doc Aspects]
docs) -> [Doc Aspects] -> Doc Aspects
forall (t :: * -> *). Foldable t => t (Doc Aspects) -> Doc Aspects
fsep ([Doc Aspects] -> Doc Aspects) -> [Doc Aspects] -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ (Doc Aspects
kw Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+> Doc Aspects
doc) Doc Aspects -> [Doc Aspects] -> [Doc Aspects]
forall a. a -> [a] -> [a]
: (Doc Aspects -> Doc Aspects) -> [Doc Aspects] -> [Doc Aspects]
forall a b. (a -> b) -> [a] -> [b]
map (Doc Aspects -> Doc Aspects
hlSymbol Doc Aspects
"|" Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Doc a -> Doc a -> Doc a
<+>) [Doc Aspects]
docs

---------------------------------------------------------------------------
-- * Annotations

-- | Only adds an annotation node if the 'Aspects' is non-'null'.
annotate :: Aspects -> Doc -> Doc
annotate :: Aspects -> Doc Aspects -> Doc Aspects
annotate Aspects
a Doc Aspects
x
  | Aspects -> Bool
forall a. Null a => a -> Bool
null Aspects
a    = Doc Aspects
x
  | Bool
otherwise = Aspects -> ()
forall a. NFData a => a -> ()
rnf Aspects
a () -> Doc Aspects -> Doc Aspects
forall a b. a -> b -> b
`seq` Aspects -> Doc Aspects -> Doc Aspects
forall a. a -> Doc a -> Doc a
P.annotate Aspects
a Doc Aspects
x

-- | Attach a simple 'Aspect', rather than a full set of 'Aspects', to a
-- document.
annotateAspect :: Aspect -> Doc -> Doc
annotateAspect :: Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
a = Aspects -> Doc Aspects -> Doc Aspects
annotate Aspects
a' where
  a' :: Aspects
a' = Aspects
    { aspect :: Maybe Aspect
aspect         = Aspect -> Maybe Aspect
forall a. a -> Maybe a
Just Aspect
a
    , otherAspects :: Set OtherAspect
otherAspects   = Set OtherAspect
forall a. Monoid a => a
mempty
    , note :: [Char]
note           = [Char]
""
    , definitionSite :: Maybe DefinitionSite
definitionSite = Maybe DefinitionSite
forall a. Maybe a
Nothing
    , tokenBased :: TokenBased
tokenBased     = TokenBased
TokenBased
    }

-- * Hyperlink annotations

-- | Attach a link to a document (cf. LaTeX @\href@).
href :: Text -> Doc -> Doc
href :: Text -> Doc Aspects -> Doc Aspects
href = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect (Aspect -> Doc Aspects -> Doc Aspects)
-> (Text -> Aspect) -> Text -> Doc Aspects -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Aspect
URL

-- | A URL formatted as link (cf. LaTeX @\url@).
url :: String -> Doc
url :: [Char] -> Doc Aspects
url [Char]
s = Text -> Doc Aspects -> Doc Aspects
href ([Char] -> Text
Text.pack [Char]
s) ([Char] -> Doc Aspects
forall a. [Char] -> Doc a
text [Char]
s)

-- | Link to an issue on the Agda bug tracker.
githubIssue :: Int -> Doc
githubIssue :: Int -> Doc Aspects
githubIssue = [Char] -> Doc Aspects
url ([Char] -> Doc Aspects) -> (Int -> [Char]) -> Int -> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"https://github.com/agda/agda/issues/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> (Int -> [Char]) -> Int -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char]
forall a. Show a => a -> [Char]
show

-- | Attach the position of something as the "binding site" of a 'Doc'.
definedAt :: HasRange a => Doc -> a -> Doc
definedAt :: forall a. HasRange a => Doc Aspects -> a -> Doc Aspects
definedAt Doc Aspects
doc a
p = Aspects -> Doc Aspects -> Doc Aspects
annotate (a -> Aspects
forall a. HasRange a => a -> Aspects
rangeDefinitionSite a
p) Doc Aspects
doc

-- ** Basic syntax highlighting helpers

hlComment, hlSymbol, hlKeyword, hlString, hlNumber, hlHole, hlPrimitiveType, hlPragma
  :: Doc -> Doc

hlComment :: Doc Aspects -> Doc Aspects
hlComment       = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
Comment
hlSymbol :: Doc Aspects -> Doc Aspects
hlSymbol        = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
Symbol
hlKeyword :: Doc Aspects -> Doc Aspects
hlKeyword       = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
Keyword
hlString :: Doc Aspects -> Doc Aspects
hlString        = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
String
hlNumber :: Doc Aspects -> Doc Aspects
hlNumber        = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
Number
hlHole :: Doc Aspects -> Doc Aspects
hlHole          = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
Hole
hlPrimitiveType :: Doc Aspects -> Doc Aspects
hlPrimitiveType = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
PrimitiveType
hlPragma :: Doc Aspects -> Doc Aspects
hlPragma        = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect Aspect
Pragma

-- ** Helpers introducing 'NameKind's

hlNameKind :: NameKind -> Doc -> Doc
hlNameKind :: NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
k = Aspect -> Doc Aspects -> Doc Aspects
annotateAspect (Maybe NameKind -> Bool -> Aspect
Name (NameKind -> Maybe NameKind
forall a. a -> Maybe a
Just NameKind
k) Bool
False)

hlBound, hlGeneralizable, hlDatatype, hlField,
  hlFunction, hlModule, hlPostulate, hlPrimitive, hlRecord, hlArgument,
  hlMacro :: Doc -> Doc

hlBound :: Doc Aspects -> Doc Aspects
hlBound         = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Bound
hlGeneralizable :: Doc Aspects -> Doc Aspects
hlGeneralizable = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Generalizable
hlDatatype :: Doc Aspects -> Doc Aspects
hlDatatype      = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Datatype
hlField :: Doc Aspects -> Doc Aspects
hlField         = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Field
hlFunction :: Doc Aspects -> Doc Aspects
hlFunction      = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Function
hlModule :: Doc Aspects -> Doc Aspects
hlModule        = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Module
hlPostulate :: Doc Aspects -> Doc Aspects
hlPostulate     = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Postulate
hlPrimitive :: Doc Aspects -> Doc Aspects
hlPrimitive     = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Primitive
hlRecord :: Doc Aspects -> Doc Aspects
hlRecord        = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Record
hlArgument :: Doc Aspects -> Doc Aspects
hlArgument      = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Argument
hlMacro :: Doc Aspects -> Doc Aspects
hlMacro         = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind NameKind
Macro

hlConstructor :: Induction -> Doc -> Doc
hlConstructor :: Induction -> Doc Aspects -> Doc Aspects
hlConstructor = NameKind -> Doc Aspects -> Doc Aspects
hlNameKind (NameKind -> Doc Aspects -> Doc Aspects)
-> (Induction -> NameKind)
-> Induction
-> Doc Aspects
-> Doc Aspects
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Induction -> NameKind
Constructor

---------------------------------------------------------------------------
-- * Delimiter wrappers
--
-- These use the 'Symbol' highlight for the punctuation characters.

parens       :: Doc -> Doc -- ^ Wrap document in @(...)@
brackets     :: Doc -> Doc -- ^ Wrap document in @[...]@
braces       :: Doc -> Doc -- ^ Wrap document in @{...}@
quotes       :: Doc -> Doc -- ^ Wrap document in @\'...\'@
doubleQuotes :: Doc -> Doc -- ^ Wrap document in @\"...\"@
quotes :: Doc Aspects -> Doc Aspects
quotes Doc Aspects
p       = Doc Aspects -> Doc Aspects
hlSymbol (Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'\'') Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
p Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects -> Doc Aspects
hlSymbol (Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'\'')
doubleQuotes :: Doc Aspects -> Doc Aspects
doubleQuotes Doc Aspects
p = Doc Aspects -> Doc Aspects
hlSymbol (Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'"') Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
p Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects -> Doc Aspects
hlSymbol (Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'"')
parens :: Doc Aspects -> Doc Aspects
parens Doc Aspects
p       = Doc Aspects
lparen Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
p Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
rparen
brackets :: Doc Aspects -> Doc Aspects
brackets Doc Aspects
p     = Doc Aspects
lbrack Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
p Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
rbrack
braces :: Doc Aspects -> Doc Aspects
braces Doc Aspects
p       = Doc Aspects
lbrace Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
p Doc Aspects -> Doc Aspects -> Doc Aspects
forall a. Semigroup a => a -> a -> a
<> Doc Aspects
rbrace

semi, comma, colon, dot, pipe, equals, lparen, rparen, lbrack, rbrack, lbrace, rbrace :: Doc
semi :: Doc Aspects
semi   = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
';'
comma :: Doc Aspects
comma  = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
','
colon :: Doc Aspects
colon  = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
':'
dot :: Doc Aspects
dot    = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'.'
pipe :: Doc Aspects
pipe   = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'|'
equals :: Doc Aspects
equals = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'='
lparen :: Doc Aspects
lparen = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'('
rparen :: Doc Aspects
rparen = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
')'
lbrack :: Doc Aspects
lbrack = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'['
rbrack :: Doc Aspects
rbrack = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
']'
lbrace :: Doc Aspects
lbrace = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'{'
rbrace :: Doc Aspects
rbrace = Doc Aspects -> Doc Aspects
hlSymbol (Doc Aspects -> Doc Aspects) -> Doc Aspects -> Doc Aspects
forall a b. (a -> b) -> a -> b
$ Char -> Doc Aspects
forall a. Char -> Doc a
char Char
'}'