Control.Egison.Core

Definitions of data types for patterns, matchers, match clauses, matching states, and matching atoms.

Patterns

data Pattern a m ctx vs where

A pattern for data of a type a for a matcher m. ctx is an intermediate pattern-matching result that is a type of a list of data bound in the left-side of the pattern. vs is a list of types bound to the pattern variables in this pattern.

Constructors

Wildcard :: Pattern a m ctx '[]

PatVar :: String -> Pattern a m ctx '[a]

AndPat :: Pattern a m ctx vs -> Pattern a m (ctx :++: vs) vs' -> Pattern a m ctx (vs :++: vs')

OrPat :: Pattern a m ctx vs -> Pattern a m ctx vs -> Pattern a m ctx vs

NotPat :: Pattern a m ctx '[] -> Pattern a m ctx '[]

PredicatePat :: (HList ctx -> a -> Bool) -> Pattern a m ctx '[]

Pattern :: Matcher m a => (HList ctx -> m -> a -> [MList ctx vs]) -> Pattern a m ctx vs

User-defined pattern; pattern is a function that takes a target, an intermediate pattern-matching result, and a matcher and returns a list of lists of matching atoms.

class Matcher m a

The Matcher class is used to declare that m is a matcher for data of a type a.

Instances

Integral a => Matcher Integer a

Defined in Control.Egison.Matcher

Matcher Eql a

Defined in Control.Egison.Matcher

Matcher Something a

Defined in Control.Egison.Matcher

Matcher m a => Matcher (Set m) [a]

Defined in Control.Egison.Matcher

Matcher m a => Matcher (Multiset m) [a]

Defined in Control.Egison.Matcher

Matcher m a => Matcher (List m) [a]

Defined in Control.Egison.Matcher

(Matcher m1 a1, Matcher m2 a2) => Matcher (Pair m1 m2) (a1, a2)

Defined in Control.Egison.Matcher

data MatchClause a m b

A match clause of a match expression whose target data is a and matcher is m. The body of the match clause is evaluated to b.

Constructors

Matcher m a => MatchClause (Pattern a m '[] vs) (HList vs -> b)

Matching states and matching atoms

data MState vs where

A matching state. A matching state consists of an intermediate pattern-matching result and a stack of matching atoms.

Constructors

MState :: vs ~ (xs :++: ys) => HList xs -> MList xs ys -> MState vs

data MAtom ctx vs

A matching atom. ctx is a intermediate pattern-matching result. vs is a list of types bound to the pattern variables by processing this matching atom.

Constructors

Matcher m a => MAtom (Pattern a m ctx vs) m a

data MList ctx vs where

A stack of matching atoms

Constructors

MNil :: MList ctx '[]

MCons :: MAtom ctx xs -> MList (ctx :++: xs) ys -> MList ctx (xs :++: ys)

mappend :: MList ctx xs -> MList (ctx :++: xs) ys -> MList ctx (xs :++: ys)

Concatenate two lists of matching atoms.

oneMAtom :: MAtom ctx xs -> MList ctx xs

Create a list of a single matching atom.

twoMAtoms :: MAtom ctx xs -> MAtom (ctx :++: xs) ys -> MList ctx (xs :++: ys)

Create a list of two matching atoms.

threeMAtoms :: MAtom ctx xs -> MAtom (ctx :++: xs) ys -> MAtom ((ctx :++: xs) :++: ys) zs -> MList ctx ((xs :++: ys) :++: zs)

Create a list of three matching atoms.

Heterogeneous lists

data HList xs where

Heterogeneous lists.

Constructors

HNil :: HList '[]

HCons :: a -> HList as -> HList (a ': as)

happend :: HList as -> HList bs -> HList (as :++: bs)

Concatenate two heterogeneous lists.

type family (as :: [*]) :++: (bs :: [*]) :: [*] where ...

Axioms for heterogeneous lists.

Equations

as :++: '[] = as

'[] :++: bs = bs

(a ': as) :++: bs = a ': (as :++: bs)