Variable pattern: always succeeds, and binds the value to a variable.

give b always succeeds, ignoring the matched value and providing the value b instead. Useful in conjunction with (/\) for providing default values in cases that would otherwise not bind any values.

Wildcard pattern: always succeeds, binding no variables. (This is written as two underscores.)

Failure pattern: never succeeds.

Constant pattern: test for equality to the given constant.

cst x = is (==x).

Conjunctive (and) pattern: matches a value against two patterns, and succeeds only if both succeed, binding variables from both.

(/\) = mk2 (\a -> Just (a,a))

Disjunctive (or) pattern: matches a value against the first pattern, or against the second pattern if the first one fails.

View pattern: do some computation, then pattern match on the result.

Convenient infix synonym for view.

Partial view pattern: do some (possibly failing) computation, then pattern match on the result if the computation is successful.

Convenient infix synonym for tryView.

Predicate pattern. Succeeds if the given predicate yields True, fails otherwise.

Can be used with (/\) for some uses similar to pattern guards:

match a $
     left (var /\ is even) ->> id
 <|> left  __              ->> const 0
 <|> right __              ->> const 1

Note that is is like mk0 but with Bool instead of Maybe ().

pfilter p matches every element of a Foldable data structure against the pattern p, discarding elements that do not match. From the matching elements, binds a list of values corresponding to each pattern variable.

pmap p matches every element of a Traversable data structure against the pattern p. The entire match fails if any of the elements fail to match p. If all the elements match, binds a t-structure full of bound values corresponding to each variable bound in p.

pfoldr p f b matches every element of a Foldable data structure against the pattern p, discarding elements that do not match. Folds over the bindings produced by the matching elements to produce a summary value.

The same functionality could be achieved by matching with pfilter p and then appropriately combining and folding the resulting lists of bound values. In particular, if p binds only one value we have

match t (pfoldr p f b ->> id) === match t (pfilter p ->> foldr f b)

However, when p binds more than one value, it can be convenient to be able to process the bindings from each match together, rather than having to deal with them once they are separated out into separate lists.

match satisfies the identity match a c = fromJust (tryMatch a c).

"Runs" a Clause, by matching it against a value and returning a result if it matches, or Nothing if the match fails.

mmatch m p = m >>= elim p

Useful for applicative-looking monadic pattern matching, as in

ex7 :: IO ()
ex7 = mmatch getLine $
      cst "" ->> return ()
  <|> var    ->> putStrLn . ("You said " ++)

elim = flip match

Useful for anonymous matching (or for building "eliminators", like maybe and either). For example:

either withLeft withRight = elim $
             left  var ->> withLeft
         <|> right var ->> withRight

Match True.

Match False.

A strict match on the unit value ().

A synonym for unit.

Construct a pattern match against a pair from a pair of patterns.

A synonym for pair.

Match a 3-tuple.

Match a 4-tuple.

Match a 5-tuple.

Match the Nothing constructor of Maybe.

Match the Just constructor of Maybe.

Match the Left constructor of Either.

Match the Right constructor of Either.

Match the empty list.

Match a cons.

Match zero.

Match a natural number which is the successor of another natural (and match the predecessor with a nested pattern). Together, zero and suc allow viewing Integral types as Peano numbers.

Note that suc never matches negative numbers.