ADP.Fusion.SynVar.Fill

Specialized table-filling wrapper for MTbls

runFreezeMTbls :: (WriteCell m ((:.) tail (MutArr m (arr sh elm), t)) sh, MPrimArrayOps arr sh elm, FreezeTables m (OnlyTables t1), IndexStream sh, PrimMonad m, ExposeTables t1, (~) * (TableFun t1) ((:.) tail (MutArr m (arr sh elm), t))) => t1 -> m (Frozen (OnlyTables t1))

Run and freeze MTbls. Since actually running the table-filling part is usually the last thing to do, we can freeze as well.

Expose inner mutable tables

class ExposeTables t where

Expose the actual mutable table with an MTbl. (Should be temporary until MTbls get a more thorough treatment for auto-filling.

Associated Types

type TableFun t :: *

type OnlyTables t :: *

Methods

expose :: t -> TableFun t

onlyTables :: t -> OnlyTables t

Instances

ExposeTables Z

data CFG

A vanilla context-free grammar

Instances

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

(MutateCell CFG ts im om i, PrimMonad om) => MutateCell CFG ((:.) ts (IRec im c i x)) im om i

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 om ZS2, PrimMonad om) => MutateCell MonotoneMCFG ((:.) ts (ITbl im arr c ZS2 x)) im om ZS2

Unsafely mutate ITbls and similar tables in the forward phase.

class MutateCell h s im om 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)

Methods

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

Instances

Monad om => MutateCell p Z im om i

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

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

(MutateCell CFG ts im om i, PrimMonad om) => MutateCell CFG ((:.) ts (IRec im c i x)) im om i

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

class MutateTables h s im om where

Methods

mutateTables :: Proxy h -> (forall a. im a -> om a) -> s -> om s

Instances

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

class TableOrder s where

Methods

tableLittleOrder :: s -> [Int]

tableBigOrder :: s -> [Int]

Instances

TableOrder Z

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

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

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

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 IO => t -> t

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

TODO generalize to MonadIO or MonadPrim.

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

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