Data.Pattern.Base

The main types used.

Patterns

newtype Pattern vars a

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.

Constructors

Pattern

Fields

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 Pat0 a = Pattern Nil a

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

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

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

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))) a

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)))) a

Clauses

data Clause a r

Pattern-match clauses. Typically something of the form

pattern ->> function

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

Instances

Monad (Clause a)

Functor (Clause a)

MonadPlus (Clause a)

Applicative (Clause a)

Alternative (Clause a)

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

Constructs a Clause.

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

"Runs" a Clause.

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

match a c = fromJust (tryMatch a c)

module Data.Pattern.Base.TypeList

module Data.Pattern.Base.Tuple