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

MaintainerReiner Pope <>




The main types used.



newtype Pattern vars a Source

The pattern type. A Pattern vars a is a pattern which matches against as and binds variables with types given by the type-list vars.

Although this is the basic type used by patterns, many of pattern combinators (for instance, Data.Pattern.Base.Common.left) have types better expressed by the type synonyms Pat0, Pat1, Pat2, etc, Pat5, so that nesting of patterns (e.g. left (tup2 var var)) can be written as function application.

Most "normal" pattern matchers (in fact, all of the matchers in Data.Pattern.Common except var and (/)) can be conveniently defined using mk0, mk1, etc, mk5.




runPattern :: a -> Maybe (Tuple vars)

Pattern synonyms. A PatN is a function which takes N subpatterns and yields a Pattern which binds all of the subpatterns' variables in order.

type Pat1 b a = forall bs. Pattern bs b -> Pattern bs aSource

type Pat2 b c a = forall bs cs. Pattern bs b -> Pattern cs c -> Pattern (bs :++: cs) aSource

type Pat3 b c d a = forall bs cs ds. Pattern bs b -> Pattern cs c -> Pattern ds d -> Pattern (bs :++: (cs :++: ds)) aSource

type Pat4 b c d e a = forall bs cs ds es. Pattern bs b -> Pattern cs c -> Pattern ds d -> Pattern es e -> Pattern (bs :++: (cs :++: (ds :++: es))) aSource

type Pat5 b c d e f a = forall bs cs ds es fs. Pattern bs b -> Pattern cs c -> Pattern ds d -> Pattern es e -> Pattern fs f -> Pattern (bs :++: (cs :++: (ds :++: (es :++: fs)))) aSource


data Clause a r Source

Pattern-match clauses. Typically something of the form

pattern ->> function

Three primitives on them are exposed: (->>), (|||), and tryMatch, plus one convenience function: match.

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

Constructs a Clause.

(|||) :: Clause a r -> Clause a r -> Clause a rSource

Alternative clauses: p ||| q is the clause which first attempts p, and then q if p fails.

tryMatch :: a -> Clause a r -> Maybe rSource

"Runs" a Clause.

match :: a -> Clause a r -> rSource

match a c = fromJust (tryMatch a c)