first-class-patterns- First class patterns and pattern matching, using type families

Portabilitynon-portable (see .cabal)
MaintainerBrent Yorgey <>
Safe HaskellNone




The main types used in the implementation of first-class patterns: Pattern and Clause.



newtype Pattern vars a Source

The pattern type. A value of type Pattern vars a is a pattern which matches values of type a and binds variables with types given by the type-list vars. For example, something of type

 Pattern (a :*: c :*: Nil) (a,b,c)

is a pattern which matches against a triple and binds values of types a and c. (A pattern of this type can be constructed as tup3 var __ var.)

Many "normal" patterns can be conveniently defined using mk0, mk1, mk2, and so on.




runPattern :: a -> Maybe (Tuple vars)


data Clause a r Source

Pattern-match clauses. Typically something of the form

pattern ->> function

where the function takes one argument for each variable bound by the pattern.

Clauses can be constructed with (->>), run with tryMatch, and manipulated by the Monad and MonadPlus instances. In particular, the (<|>) operator from the Alternative class is the way to list multiple cases in a pattern.

runClause :: Clause a r -> ReaderT a Maybe rSource

Extract the underlying computation constituting a Clause. This function is not intended to be used directly; instead, see match, tryMatch, mmatch, and elim from Data.Pattern.Common.

(->>) :: Pattern vars a -> Fun vars r -> Clause a rSource

Construct a Clause from a pattern and a function which takes one argument for each variable bound by the pattern. For example,

 pair __ nothing     ->> 3
 pair var nothing    ->> \x -> x + 3
 pair var (just var) ->> \x y -> x + y + 3

(<|>) :: Alternative f => forall a. f a -> f a -> f a

An associative binary operation