GHC.SourceGen.Overloaded

This module overloads some combinators so they can be used in different contexts: for expressions, types and/or patterns.

Documentation

class Par e where

A class for wrapping terms in parentheses.

Methods

par :: e -> e

Instances

Par Pat'

Defined in GHC.SourceGen.Overloaded

Methods

par :: Pat' -> Pat'

Par HsType'

Defined in GHC.SourceGen.Overloaded

Methods

par :: HsType' -> HsType'

Par HsExpr'

Defined in GHC.SourceGen.Overloaded

Methods

par :: HsExpr' -> HsExpr'

class App e where

A class for term application.

These functions may add additional parentheses to the AST. GHC's pretty-printing functions expect those parentheses to already be present, because GHC preserves parentheses when it parses the AST from a source file.

Methods

(@@) :: e -> e -> e infixl 2

Prefix-apply a term:

f x
=====
var "f" @@ var "x"

(+) x
=====
var "+" @@ var "x"

Also parenthesizes the right-hand side in order to preserve its semantics when pretty-printed, but tries to do so only when necessary:

f x y
=====
var "f" @@ var "x" @@ var "y"
-- equivalently:
(var "f" @@ var "x") @@ var "y"

f (g x)
=====
var "f" @@ (var "g" @@ var "x")

f (g x)
=====
var "f" @@ par (var "g" @@ par (var "x"))

op :: e -> RdrNameStr -> e -> e

Infix-apply an operator or function.

For example:

x + y
=====
op (var "x") "+" (var "y")

Also parenthesizes the right-hand side in order to preserve its semantics when pretty-printed, but tries to do so only when necessary:

f x + g y
=====
op (var "f" @@ var "x") "+" (var "g" @@ var "y")

x + (y + z)
=====
op (var "x") "+" (op (var "y") "+" (var "z"))

f x `plus` g y
=====
op (var "f" @@ var "x") "plus" (var "g" @@ var "y")

Instances

App HsType'

Defined in GHC.SourceGen.Overloaded

Methods

(@@) :: HsType' -> HsType' -> HsType'

op :: HsType' -> RdrNameStr -> HsType' -> HsType'

App HsExpr'

Defined in GHC.SourceGen.Overloaded

Methods

(@@) :: HsExpr' -> HsExpr' -> HsExpr'

op :: HsExpr' -> RdrNameStr -> HsExpr' -> HsExpr'

class HasTuple e where

Methods

unit :: e

tupleOf :: Boxity -> [e] -> e

Instances

HasTuple Pat'

Defined in GHC.SourceGen.Overloaded

Methods

unit :: Pat'

tupleOf :: Boxity -> [Pat'] -> Pat'

HasTuple HsType'

Defined in GHC.SourceGen.Overloaded

Methods

unit :: HsType'

tupleOf :: Boxity -> [HsType'] -> HsType'

HasTuple HsExpr'

Defined in GHC.SourceGen.Overloaded

Methods

unit :: HsExpr'

tupleOf :: Boxity -> [HsExpr'] -> HsExpr'

tuple :: HasTuple e => [e] -> e

unboxedTuple :: HasTuple e => [e] -> e

class HasList e where

An explicit list of terms.

[x, y]
=====
list [var "x", var "y"]

NOTE: for types, use either listTy or promotedListTy.

Methods

list :: [e] -> e

nil :: e

The empty list [].

cons :: e

The list cons constructor (:).

Instances

HasList Pat'

Defined in GHC.SourceGen.Overloaded

Methods

list :: [Pat'] -> Pat'

nil :: Pat'

cons :: Pat'

HasList HsExpr'

Defined in GHC.SourceGen.Overloaded

Methods

list :: [HsExpr'] -> HsExpr'

nil :: HsExpr'

cons :: HsExpr'

class Var a where

Terms that can contain references to named things. They may be actual variables, functions, or constructors. For example, var "a" and var "A" are equally valid. Depending on the context, the former could refer to either a function, value, type variable, or pattern; and the latter could refer to either a type constructor or a data constructor,

Methods

var :: RdrNameStr -> a

Instances

Var IE'

Defined in GHC.SourceGen.Overloaded

Methods

var :: RdrNameStr -> IE'

Var HsTyVarBndr'

Defined in GHC.SourceGen.Overloaded

Methods

var :: RdrNameStr -> HsTyVarBndr'

Var Pat'

Defined in GHC.SourceGen.Overloaded

Methods

var :: RdrNameStr -> Pat'

Var HsType'

Defined in GHC.SourceGen.Overloaded

Methods

var :: RdrNameStr -> HsType'

Var HsExpr'

Defined in GHC.SourceGen.Overloaded

Methods

var :: RdrNameStr -> HsExpr'