Language.Haskell.Tools.Rewrite.Match.Exprs

UPattern matching expression-level AST fragments for refactorings.

Expressions

pattern Var :: forall dom. Name dom -> Expr dom

An expression for a variable or a data constructor ( a )

pattern Lit :: forall dom. Literal dom -> Expr dom

A literal expression ( 42 )

pattern InfixApp :: forall dom. Expr dom -> Operator dom -> Expr dom -> Expr dom

An infix operator application ( a + b )

pattern PrefixApp :: forall dom. Operator dom -> Expr dom -> Expr dom

Prefix operator application ( -x )

pattern App :: forall dom. Expr dom -> Expr dom -> Expr dom

Function application ( f 4 )

pattern Lambda :: forall dom. PatternList dom -> Expr dom -> Expr dom

Lambda expression ( \a b -> a + b )

pattern Let :: forall dom. LocalBindList dom -> Expr dom -> Expr dom

Local binding ( let x = 2; y = 3 in e x y )

pattern If :: forall dom. Expr dom -> Expr dom -> Expr dom -> Expr dom

If expression ( if a then b else c )

pattern MultiIf :: forall dom. GuardedCaseRhsList dom -> Expr dom

Multi way if expressions with MultiWayIf extension ( if | guard1 -> expr1; guard2 -> expr2 )

pattern Case :: forall dom. Expr dom -> AltList dom -> Expr dom

Pattern matching expression ( case expr of pat1 -> expr1; pat2 -> expr2 )

pattern Do :: forall dom. StmtList dom -> Expr dom

Do-notation expressions ( do x <- act1; act2 )

pattern ParArrayComp :: forall dom. Expr dom -> ListCompBodyList dom -> Expr dom

pattern Tuple :: forall dom. ExprList dom -> Expr dom

Tuple expression ( (e1, e2, e3) )

pattern UnboxedTuple :: forall dom. ExprList dom -> Expr dom

Unboxed tuple expression ( (# e1, e2, e3 #) )

pattern TupleSection :: forall dom. TupSecElemList dom -> Expr dom

Tuple section, enabled with TupleSections ( (a,,b) ). One of the elements must be missing.

pattern UnboxedTupleSection :: forall dom. TupSecElemList dom -> Expr dom

Unboxed tuple section enabled with TupleSections ( () ). One of the elements must be missing.

pattern List :: forall dom. ExprList dom -> Expr dom

List expression: [1,2,3]

pattern ParArray :: forall dom. ExprList dom -> Expr dom

Parallel array expression: [: 1,2,3 :]

pattern Paren :: forall dom. Expr dom -> Expr dom

Parenthesized expression: ( a + b )

pattern LeftSection :: forall dom. Expr dom -> Operator dom -> Expr dom

Left operator section: (1+)

pattern RightSection :: forall dom. Operator dom -> Expr dom -> Expr dom

Right operator section: (+1)

pattern RecCon :: forall dom. Name dom -> FieldUpdateList dom -> Expr dom

Record value construction: Point { x = 3, y = -2 }

pattern RecUpdate :: forall dom. Expr dom -> FieldUpdateList dom -> Expr dom

Record value update: p1 { x = 3, y = -2 }

pattern Enum :: forall dom. Expr dom -> MaybeExpr dom -> MaybeExpr dom -> Expr dom

Enumeration expression ( [1,3..10] )

pattern ParArrayEnum :: forall dom. Expr dom -> MaybeExpr dom -> Expr dom -> Expr dom

Parallel array enumeration ( [: 1,3 .. 10 :] )

pattern ListComp :: forall dom. Expr dom -> ListCompBodyList dom -> Expr dom

List comprehension ( [ (x, y) | x <- xs | y <- ys ] )

pattern ParArrayListComp :: forall dom. Expr dom -> ListCompBodyList dom -> Expr dom

Parallel array comprehensions [: (x, y) | x <- xs , y <- ys :] enabled by ParallelArrays

pattern TypeSig :: forall dom. Expr dom -> Type dom -> Expr dom

Explicit type signature ( x :: Int )

pattern ExplicitTypeApp :: forall dom. Expr dom -> Type dom -> Expr dom

Explicit type application ( show @Integer (read "5") )

pattern VarQuote :: forall dom. Name dom -> Expr dom

'x for template haskell reifying of expressions

pattern TypeQuote :: forall dom. Name dom -> Expr dom

''T for template haskell reifying of types

pattern BracketExpr :: forall dom. Bracket dom -> Expr dom

Template haskell bracket expression

pattern SpliceExpr :: forall dom. Splice dom -> Expr dom

Template haskell splice expression, for example: $(gen a) or $x

pattern QuasiQuoteExpr :: forall dom. QuasiQuote dom -> Expr dom

Template haskell quasi-quotation: [$quoter|str]

pattern ExprPragma :: forall dom. ExprPragma dom -> Expr dom -> Expr dom

Template haskell quasi-quotation: [$quoter|str]

pattern Proc :: forall dom. Pattern dom -> Cmd dom -> Expr dom

Arrow definition: proc a -> f -< a+1

pattern ArrowApp :: forall dom. Expr dom -> ArrowApp dom -> Expr dom -> Expr dom

Arrow definition: proc a -> f -< a+1

pattern LambdaCase :: forall dom. AltList dom -> Expr dom

Lambda case ( case 0 -> 1; 1 -> 2 )

pattern StaticPointer :: forall dom. Expr dom -> Expr dom

Static pointer expression ( static e ). The inner expression must be closed (cannot have variables bound outside)

Field updates

pattern NormalFieldUpdate :: forall dom. Name dom -> Expr dom -> FieldUpdate dom

Update of a field ( x = 1 )

pattern FieldPun :: forall dom. Name dom -> FieldUpdate dom

Update the field to the value of the same name ( x )

pattern FieldWildcard :: forall dom. FieldWildcard dom -> FieldUpdate dom

Update the fields of the bounded names to their values ( .. ). Must be the last initializer. Cannot be used in a record update expression.

Tuple sections

pattern TupSecPresent :: forall dom. Expr dom -> TupSecElem dom

An existing element in a tuple section

pattern TupSecMissing :: forall dom. TupSecElem dom

A missing element in a tuple section

Pattern matching and guards

pattern Alt :: forall dom. Pattern dom -> CaseRhs dom -> MaybeLocalBinds dom -> Alt dom

Clause of case expression ( Just x -> x + 1 )

pattern CaseRhs :: forall dom. Expr dom -> CaseRhs dom

Unguarded right-hand side a pattern match ( -> 3 )

pattern GuardedCaseRhss :: forall dom. GuardedCaseRhsList dom -> CaseRhs dom

Guarded right-hand sides of a pattern match ( | x == 1 -> 3; | otherwise -> 4 )

pattern GuardedCaseRhs :: forall dom. RhsGuardList dom -> Expr dom -> GuardedCaseRhs dom

A guarded right-hand side of pattern matches binding ( | x > 3 -> 2 )

Pragmas that can be applied to expressions

pattern CorePragma :: forall dom. String -> ExprPragma dom

A CORE pragma for adding notes to expressions.

pattern SccPragma :: forall dom. String -> ExprPragma dom

An SCC pragma for defining cost centers for profiling

pattern GeneratedPragma :: forall dom. SourceRange dom -> ExprPragma dom

A pragma that describes if an expression was generated from a code fragment by an external tool ( {--} )

pattern SourceRange :: forall dom. String -> Integer -> Integer -> Integer -> Integer -> SourceRange dom

In-AST source ranges (for generated pragmas)

Commands

pattern ArrowAppCmd :: forall dom. Expr dom -> ArrowApp dom -> Expr dom -> Cmd dom

An arrow application command ( f -< x + 1 )

pattern ArrowFormCmd :: forall dom. Expr dom -> CmdList dom -> Cmd dom

A form command ( (|untilA (increment -< x+y) (within 0.5 -< x)|) )

pattern AppCmd :: forall dom. Cmd dom -> Expr dom -> Cmd dom

A function application command

pattern InfixCmd :: forall dom. Cmd dom -> Name dom -> Cmd dom -> Cmd dom

An infix command application

pattern LambdaCmd :: forall dom. PatternList dom -> Cmd dom -> Cmd dom

An infix command application

pattern ParenCmd :: forall dom. Cmd dom -> Cmd dom

A parenthesized command

pattern CaseCmd :: forall dom. Expr dom -> CmdAltList dom -> Cmd dom

A pattern match command

pattern IfCmd :: forall dom. Expr dom -> Cmd dom -> Cmd dom -> Cmd dom

An if command ( if f x y then g -< x+1 else h -< y+2 )

pattern LetCmd :: forall dom. LocalBindList dom -> Cmd dom -> Cmd dom

A local binding command ( let z = x+y )

pattern DoCmd :: forall dom. CmdStmtList dom -> Cmd dom

A local binding command ( let z = x+y )

pattern LeftAppl :: forall dom. ArrowApp dom

Left arrow application: -<

pattern RightAppl :: forall dom. ArrowApp dom

Right arrow application: >-

pattern LeftHighApp :: forall dom. ArrowApp dom

Left arrow high application: -<<

pattern RightHighApp :: forall dom. ArrowApp dom

Right arrow high application: >>-