Text.PrettyPrint.Leijen.DocExpr

Variation of Twan van Laarhoven's simple-reflect http://hackage.haskell.org/cgi-bin/hackage-scripts/package/simple-reflect

Differences from Twan's version: + Generates pretty-printings instead of strings + No evaluation + Removed overloadings that disagree with semantic versions (e.g., '(==)') + A few stylistic tweaks

Construction

data Expr

A reflected expression

Constructors

Expr

Fields

edoc :: Int -> Doc

Generate doc, given contextual precedence level

Instances

Enum Expr

Eq Expr

Floating Expr

Fractional Expr

Integral Expr

Num Expr

Ord Expr

Real Expr

Show Expr

Pretty Expr

PrettyPrec Expr

HasExpr Expr

FromExpr Expr

class FromExpr a where

Conversion from Expr to other types

Methods

fromExpr :: Expr -> a

Instances

FromExpr Expr

(PrettyPrec a, FromExpr b) => FromExpr (a -> b)

lift :: PrettyPrec a => a -> Expr

var :: String -> Expr

A variable with the given name

fun :: FromExpr a => String -> a

A generic, overloaded, function variable

apply :: Expr -> Expr -> Expr

($$) :: Expr -> Expr -> Expr

Function application

data Associativity

This data type specifies the associativity of operators: left, right or none.

Constructors

InfixL

Infix

InfixR

Instances

Eq Associativity

op :: Associativity -> Int -> String -> Expr -> Expr -> Expr

An infix operator with the given associativity, precedence and name

lambdaX :: String -> Expr -> Expr

A lambda expression

letX :: String -> Expr -> Expr -> Expr

A "let" expression

tupleX :: [Expr] -> Expr

A tuple expression

ccall :: String -> [Expr] -> Expr

C-style call

dotX :: String -> Expr -> Expr

e.foo

onDoc :: (Doc -> Doc) -> Expr -> Expr

Altering the generated Doc

class Show a => HasExpr a where

Methods

expr :: a -> Expr

Instances

HasExpr Bool

HasExpr Char

HasExpr Double

HasExpr Float

HasExpr Int

HasExpr Integer

HasExpr ()

HasExpr Doc

HasExpr Expr

(Show a, PrettyPrec a) => HasExpr [a]

Integral a => HasExpr (Ratio a)

(Show a, PrettyPrec a) => HasExpr (Maybe a)

HasExpr a => HasExpr (Complex a)

HasExpr (Type t)

HasExpr (ScalarT a)

HasExpr (E a)

HasExpr a => HasExpr (V a)

(Show a, Show b, Pretty a, Pretty b) => HasExpr (a, b)

(IsNat n, IsScalar a, Show a) => HasExpr (Vec n a)

HasExpr (VectorT n a)

(HasExpr a, HasExprU f) => HasExpr (Glom f a)

(Show a, Show b, Show c, Pretty a, Pretty b, Pretty c) => HasExpr (a, b, c)

class HasExprU h where

Methods

exprU :: forall a. h a -> Expr

Instances

HasExprU Type

HasExprU ScalarT

HasExprU V

HasExprU (VectorT n)

HasExprU f => HasExprU (Glom f)

prettyExpr :: HasExpr a => Int -> a -> Doc

Convenient for defining PrettyPrec when we have a HasExpr.

Utility

docParen :: Bool -> Doc -> Doc

Variant of showParen