ADP.Fusion.SynVar.Fill

Documentation

data CFG

A vanilla context-free grammar

Instances

(PrimArrayOps arr i x, MPrimArrayOps arr i x, MutateCell CFG ts im i) => MutateCell CFG ((:.) ts (TwITbl im arr c i x)) im i

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * CFG -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwITbl im arr c i x) -> i -> i -> om ()

MutateCell CFG ts im i => MutateCell CFG ((:.) ts (TwIRec im c i x)) im i

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * CFG -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwIRec im c i x) -> i -> i -> om ()

data MonotoneMCFG

This grammar is a multi-cfg in a monotone setting

Instances

(PrimArrayOps arr ZS2 x, MPrimArrayOps arr ZS2 x, MutateCell MonotoneMCFG ts im ZS2) => MutateCell MonotoneMCFG ((:.) ts (TwITbl im arr c ZS2 x)) im ZS2

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * MonotoneMCFG -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwITbl im arr c ZS2 x) -> ZS2 -> ZS2 -> om ()

Unsafely mutate ITbls and similar tables in the forward phase.

class MutateCell h s im i where

Mutate a cell in a stack of syntactic variables.

TODO generalize to monad morphism via mmorph package. This will allow more interesting mrph functions that can, for example, track some state in the forward phase. (Note that this can be dangerous, we do not want to have this state influence forward results, unless that can be made deterministic, or we'll break Bellman)

Minimal complete definition

mutateCell

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy h -> Int -> Int -> (forall a. im a -> om a) -> s -> i -> i -> om ()

Instances

MutateCell p Z im i

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * p -> Int -> Int -> (forall a. im a -> om a) -> Z -> i -> i -> om ()

(PrimArrayOps arr ZS2 x, MPrimArrayOps arr ZS2 x, MutateCell MonotoneMCFG ts im ZS2) => MutateCell MonotoneMCFG ((:.) ts (TwITbl im arr c ZS2 x)) im ZS2

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * MonotoneMCFG -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwITbl im arr c ZS2 x) -> ZS2 -> ZS2 -> om ()

(PrimArrayOps arr i x, MPrimArrayOps arr i x, MutateCell CFG ts im i) => MutateCell CFG ((:.) ts (TwITbl im arr c i x)) im i

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * CFG -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwITbl im arr c i x) -> i -> i -> om ()

MutateCell CFG ts im i => MutateCell CFG ((:.) ts (TwIRec im c i x)) im i

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * CFG -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwIRec im c i x) -> i -> i -> om ()

(PrimArrayOps arr (Subword I) x, MPrimArrayOps arr (Subword I) x, MutateCell h ts im ((:.) ((:.) Z (Subword I)) (Subword I))) => MutateCell h ((:.) ts (TwITbl im arr c (Subword I) x)) im ((:.) ((:.) Z (Subword I)) (Subword I))

Methods

mutateCell :: (Monad om, PrimMonad om) => Proxy * h -> Int -> Int -> (forall a. im a -> om a) -> (ts :. TwITbl im arr c (Subword I) x) -> ((Z :. Subword I) :. Subword I) -> ((Z :. Subword I) :. Subword I) -> om ()

class MutateTables h s im where

Minimal complete definition

mutateTables

Methods

mutateTables :: (Monad om, PrimMonad om) => Proxy h -> (forall a. im a -> om a) -> s -> om s

Instances

(MutateCell h ((:.) ts (TwITbl im arr c i x)) im i, PrimArrayOps arr i x, Show i, IndexStream i, TableOrder ((:.) ts (TwITbl im arr c i x))) => MutateTables h ((:.) ts (TwITbl im arr c i x)) im

Methods

mutateTables :: (Monad om, PrimMonad om) => Proxy * h -> (forall a. im a -> om a) -> (ts :. TwITbl im arr c i x) -> om (ts :. TwITbl im arr c i x)

class TableOrder s where

Minimal complete definition

tableLittleOrder, tableBigOrder

Methods

tableLittleOrder :: s -> [Int]

tableBigOrder :: s -> [Int]

Instances

TableOrder Z

Methods

tableLittleOrder :: Z -> [Int]

tableBigOrder :: Z -> [Int]

TableOrder ts => TableOrder ((:.) ts (TwIRec im c i x))

IRecs do not need an order, given that they do not memoize.

Methods

tableLittleOrder :: (ts :. TwIRec im c i x) -> [Int]

tableBigOrder :: (ts :. TwIRec im c i x) -> [Int]

TableOrder ts => TableOrder ((:.) ts (TwITbl im arr c i x))

Methods

tableLittleOrder :: (ts :. TwITbl im arr c i x) -> [Int]

tableBigOrder :: (ts :. TwITbl im arr c i x) -> [Int]

individual instances for filling a *single cell*

type ZS2 = (Z :. Subword I) :. Subword I

individual instances for filling a complete table and extracting the

mutateTablesDefault :: MutateTables CFG t Id => t -> t

Default table filling, assuming that the forward monad is just IO.

TODO generalize to MonadIO or MonadPrim.

mutateTablesWithHints :: MutateTables h t Id => Proxy h -> t -> t

Mutate tables, but observe certain hints. We use this for monotone mcfgs for now.

mutateTablesST :: (TableOrder t, TSBO t) => t -> t

mutateTablesNew :: forall t m. (TableOrder t, TSBO t, Monad m, PrimMonad m) => t -> m t

TODO new way how to do table filling. Because we now have heterogeneous tables (i) group tables by big order into different bins; (ii) check that each bin has the same bounds (needed? -- could we have smaller-sized tables once in a while); (iii) run each bin one after the other

TODO measure performance penalty, if any. We might need liberal INLINEABLE, and specialization. On the other hand, we can do the freeze/unfreeze outside of table filling.

data Q

Constructors

Q

Fields

• qBigOrder :: Int
• qLittleOrder :: Int
• qTypeRep :: TypeRep
• qObject :: Dynamic

Instances

Eq Q

Methods

(==) :: Q -> Q -> Bool

(/=) :: Q -> Q -> Bool

Ord Q

Methods

compare :: Q -> Q -> Ordering

(<) :: Q -> Q -> Bool

(<=) :: Q -> Q -> Bool

(>) :: Q -> Q -> Bool

(>=) :: Q -> Q -> Bool

max :: Q -> Q -> Q

min :: Q -> Q -> Q

Show Q

Methods

showsPrec :: Int -> Q -> ShowS

show :: Q -> String

showList :: [Q] -> ShowS

class TSBO t where

Find the outermost table that has a certain big order and then fill from there.

Minimal complete definition

asDyn, fillWithDyn

Methods

asDyn :: t -> [Q]

fillWithDyn :: (Monad m, PrimMonad m) => [Q] -> t -> m [Q]

Instances

TSBO Z

Methods

asDyn :: Z -> [Q]

fillWithDyn :: (Monad m, PrimMonad m) => [Q] -> Z -> m [Q]

TSBO ts => TSBO ((:.) ts (TwIRec Id c i x))

Methods

asDyn :: (ts :. TwIRec Id c i x) -> [Q]

fillWithDyn :: (Monad m, PrimMonad m) => [Q] -> (ts :. TwIRec Id c i x) -> m [Q]

(TSBO ts, Typeable (* -> * -> *) arr, Typeable * c, Typeable * i, Typeable * x, PrimArrayOps arr i x, MPrimArrayOps arr i x, IndexStream i) => TSBO ((:.) ts (TwITbl Id arr c i x))

Methods

asDyn :: (ts :. TwITbl Id arr c i x) -> [Q]

fillWithDyn :: (Monad m, PrimMonad m) => [Q] -> (ts :. TwITbl Id arr c i x) -> m [Q]