ADP.Fusion.SynVar.Fill

Specialized table-filling wrapper for MTbls

runFreezeMTbls :: ((~#) * * (TableFun t1) ((:.) tail (MutArr m (arr sh elm), t)), ExposeTables t1, PrimMonad m, IndexStream sh, FreezeTables m (OnlyTables t1), MPrimArrayOps arr sh elm, WriteCell m ((:.) tail (MutArr m (arr sh elm), t)) sh) => 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.

Minimal complete definition

expose, onlyTables

Associated Types

type TableFun t :: *

type OnlyTables t :: *

Methods

expose :: t -> TableFun t

onlyTables :: t -> OnlyTables t

Instances

ExposeTables Z

Associated Types

type TableFun Z :: *

type OnlyTables Z :: *

Methods

expose :: Z -> TableFun Z

onlyTables :: Z -> OnlyTables 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 (TwITbl im arr c i x)) im om i

Methods

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

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

Methods

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

Methods

mutateCell :: 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 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)

Minimal complete definition

mutateCell

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

Methods

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

Methods

mutateCell :: 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 om i, PrimMonad om) => MutateCell CFG ((:.) ts (TwITbl im arr c i x)) im om i

Methods

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

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

Methods

mutateCell :: 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 om ((:.) ((:.) Z (Subword I)) (Subword I)), PrimMonad om) => MutateCell h ((:.) ts (TwITbl im arr c (Subword I) x)) im om ((:.) ((:.) Z (Subword I)) (Subword I))

Methods

mutateCell :: 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 om where

Minimal complete definition

mutateTables

Methods

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

Instances

(Monad om, MutateCell h ((:.) ts (TwITbl im arr c i x)) im om 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 om

Methods

mutateTables :: 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 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.