ADP.Fusion.Base.Classes

Documentation

data OutsideContext s

Constructors

OStatic s

ORightOf s

OFirstLeft s

OLeftOf s

Instances

Show s => Show (OutsideContext s)

data InsideContext s

Constructors

IStatic s

IVariable s

Instances

Show s => Show (InsideContext s)

data ComplementContext

Constructors

Complemented

Instances

Show ComplementContext

class RuleContext i where

Associated Types

type Context i :: *

Methods

initialContext :: i -> Context i

data family RunningIndex i :: *

While we ostensibly use an index of type i we typically do not need every element of an i. For example, when looking at Subwords, we do not need both element of j:.k but only k. Also, inside grammars do need fewer moving indices than outside grammars.

TODO Sometimes, the actual RunningIndex ctors are not erased. This could be due to https://ghc.haskell.org/trac/ghc/ticket/2289. To test, we should transform RunningIndex into a type class to give us access to the left and right member, also we should create instances a la RunningIndex (is :. Subword I) = RiSwI !(RunningIndex is) !Int. Hopefully, these are completely erased.

Instances

Show (RunningIndex Z)

GetIndexGo (RunningIndex Z) (RunningIndex Z) EQ

GetIndexGo (RunningIndex ix) (RunningIndex Z) (CmpNat (ToNat (RunningIndex ix)) (ToNat (RunningIndex Z))) => GetIndexGo (RunningIndex ((:.) ix i)) (RunningIndex Z) GT

GetIndexGo (RunningIndex ix) (RunningIndex ((:.) my m)) (CmpNat (ToNat (RunningIndex ix)) (ToNat (RunningIndex ((:.) my m)))) => GetIndexGo (RunningIndex ((:.) ix i)) (RunningIndex ((:.) my m)) GT

GetIndexGo (RunningIndex ((:.) ix i)) (RunningIndex ((:.) my m)) EQ

data RunningIndex Z = RiZ

data RunningIndex (Subword I) = RiSwI Int

The moving index k in Subword (i:.k).

data RunningIndex (Subword O) = RiSwO !Int !Int !Int !Int

The moving indices Inside (i:.j) and Outside (k:.l) in order i j k l.

TODO can we do with 2x Int?

data RunningIndex (Subword C) = RiSwC !Int !Int

The indices Subword (i:.j) in order i j.

data RunningIndex (BitSet I) = RiBsI (BitSet I)

data RunningIndex (BitSet O) = RiBsO !(BitSet O) !(BitSet O)

data RunningIndex (BitSet C) = RiBsC !(BitSet C) !(BitSet C)

data RunningIndex (PointL I) = RiPlI Int

data RunningIndex (PointL O) = RiPlO !Int !Int

data RunningIndex (PointL C) = RiPlC !Int

data RunningIndex (Unit t) = RiU

type ToNat (RunningIndex Z) = 0

type ToNat (RunningIndex ((:.) is i)) = (+) (ToNat (RunningIndex is)) 1

type ResolvedIx (RunningIndex Z) (RunningIndex Z) EQ = RunningIndex Z

type ResolvedIx (RunningIndex ((:.) ix i)) (RunningIndex Z) GT = ResolvedIx (RunningIndex ix) (RunningIndex Z) (CmpNat (ToNat (RunningIndex ix)) (ToNat (RunningIndex Z)))

type ResolvedIx (RunningIndex ((:.) ix i)) (RunningIndex ((:.) my m)) GT = ResolvedIx (RunningIndex ix) (RunningIndex ((:.) my m)) (CmpNat (ToNat (RunningIndex ix)) (ToNat (RunningIndex ((:.) my m))))

type ResolvedIx (RunningIndex ((:.) ix i)) (RunningIndex ((:.) my m)) EQ = RunningIndex i

data RunningIndex ((:.) is i) = !(RunningIndex is) :.: !(RunningIndex i)

data RunningIndex (BS2 First Last I) = RiBs2I (BS2 First Last I)

data RunningIndex (BS2 First Last O) = RiBs2O !(BS2 First Last O) !(BS2 First Last O)

data RunningIndex (BS2 First Last C) = RiBs2C !(BS2 First Last C) !(BS2 First Last C)

class Element x i where

During construction of the stream, we need to extract individual elements from symbols in production rules. An element in a stream is fixed by both, the type x of the actual argument we want to grab (say individual characters we parse from an input) and the type of indices i we use.

Elm data constructors are all eradicated during fusion and should never show up in CORE.

Associated Types

data Elm x i :: *

type RecElm x i :: *

type Arg x :: *

Methods

getArg :: Elm x i -> Arg x

getIdx :: Elm x i -> RunningIndex i

getElm :: Elm x i -> RecElm x i

Instances

Element S i

((~) * s (Elm x0 i), Element x0 i) => Element (Term1 s) ((:.) Z i)

((~) * s (Elm x0 i), Element x0 i) => Element (SynVar1 s) ((:.) Z i)

Element ls i => Element ((:!:) ls (TermSymbol a b)) i

Element ls i => Element ((:!:) ls (Backtrack (ITbl mF arr c j x) mF mB r)) i

Element ls i => Element ((:!:) ls (ITbl m arr c j x)) i

Element ls i => Element ((:!:) ls (Backtrack (IRec mF c u x) mF mB r)) i

Element ls i => Element ((:!:) ls (IRec m c u x)) i

Element ls i => Element ((:!:) ls (Split uId splitType (Backtrack (ITbl mF arr c j x) mF mB r))) i

Element ls i => Element ((:!:) ls (Split uId splitType (ITbl m arr c j x))) i

Element ls i => Element ((:!:) ls (Chr r x)) i

Element ls i => Element ((:!:) ls Deletion) i

Element ls i => Element ((:!:) ls (Edge e)) i

Element ls i => Element ((:!:) ls Epsilon) i

Element ls i => Element ((:!:) ls (PeekIndex i)) i

Element ls i => Element ((:!:) ls (Strng v x)) i

class Monad m => MkStream m x i where

mkStream creates the actual stream of elements (Elm) that will be fed to functions on the left of the (<<<) operator. Streams work over all monads and are specialized for each combination of arguments x and indices i.

Methods

mkStream :: x -> Context i -> i -> i -> Stream m (Elm x i)

Instances

(Monad m, MkStream m ls i, Element ls i, TermStaticVar (TermSymbol a b) i, TermStream m (TermSymbol a b) (Elm ls i) i) => MkStream m ((:!:) ls (TermSymbol a b)) i

(Monad mB, Element ls ((:.) is i), TableStaticVar ((:.) us u) ((:.) cs c) ((:.) is i), AddIndexDense (Elm ls ((:.) is i)) ((:.) us u) ((:.) cs c) ((:.) is i), MkStream mB ls ((:.) is i), PrimArrayOps arr ((:.) us u) x) => MkStream mB ((:!:) ls (Backtrack (ITbl mF arr ((:.) cs c) ((:.) us u) x) mF mB r)) ((:.) is i)

(Monad m, Element ls ((:.) is i), TableStaticVar ((:.) us u) ((:.) cs c) ((:.) is i), AddIndexDense (Elm ls ((:.) is i)) ((:.) us u) ((:.) cs c) ((:.) is i), MkStream m ls ((:.) is i), PrimArrayOps arr ((:.) us u) x) => MkStream m ((:!:) ls (ITbl m arr ((:.) cs c) ((:.) us u) x)) ((:.) is i)

(Monad mB, Element ls ((:.) is i), TableStaticVar ((:.) us u) ((:.) cs c) ((:.) is i), AddIndexDense (Elm ls ((:.) is i)) ((:.) us u) ((:.) cs c) ((:.) is i), MkStream mB ls ((:.) is i)) => MkStream mB ((:!:) ls (Backtrack (IRec mF ((:.) cs c) ((:.) us u) x) mF mB r)) ((:.) is i)

(Monad m, Element ls ((:.) is i), TableStaticVar ((:.) us u) ((:.) cs c) ((:.) is i), AddIndexDense (Elm ls ((:.) is i)) ((:.) us u) ((:.) cs c) ((:.) is i), MkStream m ls ((:.) is i)) => MkStream m ((:!:) ls (IRec m ((:.) cs c) ((:.) us u) x)) ((:.) is i)

class Build x where

Finally, we need to be able to correctly build together symbols on the right-hand side of the (<<<) operator.

The default makes sure that the last (or only) argument left over is correctly assigned a Z to terminate the symbol stack.

Minimal complete definition

Nothing

Associated Types

type Stack x :: *

Methods

build :: x -> Stack x

Instances

Build Deletion

Build Epsilon

Build (Edge e)

Build (PeekIndex i)

Build x => Build ((:!:) x y)

Build (TermSymbol a b)

Build (Chr r x)

Build (Strng v x)

Build (Split uId splitType synVar)

Build (Backtrack t mF mB r)

Build (IRec m c i x)

Build (ITbl m arr c i x)

data S

Similar to Z, but terminates an argument stack.

Constructors

S

Instances

Eq S

Show S

Element S i

SplitIxCol uId b (Elm S i)

Show (RunningIndex ix) => Show (Elm S ix)

data Elm S = ElmS !(RunningIndex i)

type Arg S = Z

type SplitIxTy uId b (Elm S i) = Z

staticCheck :: Monad m => Bool -> Stream m a -> Stream m a

staticCheck acts as a static filter. If b is true, we keep all stream elements. If b is false, we discard all stream elements.

data StaticCheck a b

Constructors

CheckLeft Bool a

CheckRight b

data EmptyOk

Constrains the behaviour of the memoizing tables. They may be EmptyOk if i==j is allowed (empty subwords or similar); or they may need NonEmpty indices, or finally they can be OnlyZero (only i==j allowed) which is useful in multi-dimensional casese.

Constructors

EmptyOk

Instances

MinSize EmptyOk

type TNE (Backtrack (ITbl mF arr EmptyOk i x) mF mB r) = Backtrack (ITbl mF arr NonEmpty i x) mF mB r

type TE (Backtrack (ITbl mF arr EmptyOk i x) mF mB r) = Backtrack (ITbl mF arr EmptyOk i x) mF mB r

type TNE (ITbl m arr EmptyOk i x) = ITbl m arr NonEmpty i x

type TE (ITbl m arr EmptyOk i x) = ITbl m arr EmptyOk i x

data NonEmpty

Constructors

NonEmpty

Instances

MinSize NonEmpty

class MinSize c where

Methods

minSize :: c -> Int

Instances

MinSize NonEmpty

MinSize EmptyOk

class ModifyConstraint t where

TODO Rewrite to generalize easily over multi-dim cases.

Associated Types

type TNE t :: *

type TE t :: *

Methods

toNonEmpty :: t -> TNE t

toEmpty :: t -> TE t