Moduleghc-source-gen-0.4.6.0Haskell2010

GHC.SourceGen.Expr

This module provides combinators for constructing Haskell expressions.

2 types
17 values

Packageghc-source-gen-0.4.6.0
Exports19
LanguageHaskell2010
LicenceBSD-3-Clause
SourceExpr.hs

typetype HsExpr' = HsExpr GhcPs

A Haskell expression, as it is represented after the parsing step.

Instances:

valueoverLabel :: String -> HsExpr'

An overloaded label, as used with the OverloadedLabels extension.

#foo
=====
overLabel "foo"

valuelet' :: [RawValBind] -> HsExpr' -> HsExpr'

valuecase' :: HsExpr' -> [RawMatch] -> HsExpr'

valuelambda :: [Pat'] -> HsExpr' -> HsExpr'

valuelambdaCase :: [RawMatch] -> HsExpr'

valueif' :: HsExpr' -> HsExpr' -> HsExpr' -> HsExpr'

valuemultiIf :: [GuardedExpr] -> HsExpr'

A MultiWayIf expression.

if | f x = "f"
   | g x = "g"
   | otherwise = "h"
=====
multiIf
    [ guardedStmt (var "f" @@ var "x") $ rhs (string "f")
    , guardedStmt (var "g" @@ var "x") $ rhs (string "g")
    , guardedStmt (var "otherwise") $ rhs (string "h")
    ]

valuedo' :: [Stmt'] -> HsExpr'

A do-expression.

Individual statements may be constructed with <-- and/or stmt.

do
  x <- act
  return x
=====
do' [bvar "x" <-- var "act", stmt $ var "return" @@ var "x"]

valuelistComp :: HsExpr' -> [Stmt'] -> HsExpr'

A list comprehension expression.

[x * 2 | x <- [1 .. 10], even x]
=====
listComp (op (bvar "x") "*" (int 2))
         [ bvar "x" <-- fromTo (int 1) (int 10)
         , stmt $ var "even" @@ bvar "x"
         ]

typetype Stmt' = Stmt GhcPs LHsExpr'

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

A type constraint on an expression.

e :: t
=====
var "e" @::@ var "t"

valuetyApp :: HsExpr' -> HsType' -> HsExpr'

Explicit type application.

f @ Int
=====
var "f" @@ var "Int"

valuerecordConE :: RdrNameStr -> [(RdrNameStr, HsExpr')] -> HsExpr'

Constructs a record with explicit field names.

A { x = y }
=====
recordConE "A" [("x", var "y")]

valuerecordUpd :: HsExpr' -> [(RdrNameStr, HsExpr')] -> HsExpr'

Updates a record expression with explicit field names.

r {a = b, c = d}
=====
recordUpd (var "x") [("a", var "b", ("c", var "d"))]

(f x) {a = b}
=====
recordUpd (var "f" @@ var "x") [("a", var "b")]

f x {a = b} -- equivalent to f (x {a = b})
=====
var "f" @@ recordUpd (var "x") [("a", var "b")]

valuefrom :: HsExpr' -> HsExpr'

An arithmetic sequence expression with a start value.

[a ..]
=====
from (var "a")

valuefromThen :: HsExpr' -> HsExpr' -> HsExpr'

An arithmetic sequence expression with a start and a step values.

[a, b ..]
=====
fromThen (var "a") (var "b")

valuefromTo :: HsExpr' -> HsExpr' -> HsExpr'

An arithmetic sequence expression with a start and an end values.

[a .. b]
=====
fromTo (var "a") (var "b")

valuefromThenTo :: HsExpr' -> HsExpr' -> HsExpr' -> HsExpr'

An arithmetic sequence expression with a start, a step, and an end values.

[a, b .. c]
=====
fromThenTo (var "a") (var "b") (var "c")