kRF      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{ | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !!!!!%None!"%&*,/0569:;<=DLOQRTWrap tables of type t'. The tables are strict, the functions fC can not be strict, because we need to build grammars recursively."None!"%&*,/0569:;<=DLOQRTNone!"%&*,/0569:;<=DLOQRTTODO this should go into ADP.Fusion.Table.Backtrack?, more than just tabulated syntactic vars are going to use it.#NOTE You probably need to give the monad morphism between mF and mBH so as to be able to extract forward results in the backtracking phase.None!"%&*,/0569:;<=DLOQRTThe Axiom type class +The corresponding stream being returned by  Given a table, run the axiom    None!"%&*,/0569:;<=DLOQRT  The last Name< of a rule is the name of the syntactic type of the result.    None!"%&*,/0569:;<=DLOQRT This SynVarI spans the full column of tapes; i.e. it is a normal syntactic variable.pWe have just a single-tape grammar and as such just a single-dimensional terminal. We call this term, because  StackedTerms will be rewritten to just Term!We have a multi-tape grammar with a stack of just terminals. We normally can ignore the contents in the functions above, but keep them anyway.CWe have a multi-tape grammar, but the stack contains a mixture of ArgTys. A single-dim () caseThe result type name Type for backtracking functions.-Not too interesting, mostly to keep track of choice.eThe ADP-established product operation. Returns a vector of results, along the lines of what the ADP f *** b provides.f **> g% assumes a vector-to-vector function f#, and a vector-to-scalar function g. Backtracking products of f and b . Choice in fD needs to be reduced to a scalar value. It is then compared to the fst values in b. From those, choice b selects.?Creates instances for all products given a signature data type.  Returns the  of the monad variable.! Returns the ]s of the objective function variables, as well as the name of the objective function itself."'The left algebra type. Assumes that in choice :: Stream m x -> m r we have that x ~ r.#2Here, we do not set any restrictions on the types m and r.$_Build up the type for backtracking. We want laziness in the right return type. Hence, we have AppT ListT (VarT xR)- ; i.e. we want to return results in a list.% 1we want a list for [xR] because this will make it lazy here. At least that was the reason for backtracking. For forward mode, we may not want this. We will have to change the function combination then?&^Build up attribute and choice function. Here, we actually bind the left and right algebra to l and r.'6Simple wrapper for creating the choice fun expression.(We take the left and right function name for one attribute and build up the combined attribute function. Mostly a wrapper around recBuildLampat which does the main work.TODO need fun names from l and r)-Now things become trickly. We are given all non-terminal names (to differentiate between a terminal (stack) and a syntactic variable; the left and right function; and the arguments to this attribute function (except the result parameter). We are given the latter as a result to an earlier call to 1.~We now look at each argument and determine wether it is a syntactic variable. If so, then we actually have a tuple arguments (x,ys) where x has to optimized value and ys9 the backtracking list. The left function receives just xi in this case. For the right function, things are more complicated, since we have to flatten lists. See -.}Terminals are always given "as is" since we do not have a need for tupled-up information as we have for syntactic variables.+uLook at the argument type and build the capturing variables. In particular captures synvar arguments with a 2-tuple (x,ys).-4Build the right-hand side of a function combined in f <|| g". This splits the paired synvars (x,xs) such that we calculate f x and g xs.NOTE If we want to write [ f x | x <- xs ] /then in template haskell, this looks like this: CCompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))] The NoBindS is the final binding of f to the individual x's, while the prior x <- xs comes from BindS (VarP x) (VarE xs).OTODO This is where we might be able to improve performance if we can optimize [f x y | x <- xs, y <- ys] for  concatMap in vector..Build up the backtracking choice function. This choice function will backtrack based on the first result, then return only the second.^TODO it should be (only?) this function we will need to modify to build all algebra products.ysM can't be unboxed, as snd: of each element is a list, lazily consumed. We build up ysM as this makes fusion happen. Of course, this is a boxed vector and not as efficient, but we gain the ability to have lazily created backtracking from this!4This means strict optimization AND lazy backtracking=TODO in principle, we do more work than necessary. The line  hFres <- ...' evaluates the optimal choice from the fstM elements again. As long as the cost is small compared to the evaluation of sndT (or the list-comprehension based creation of all parses), this won't matter much./We assume parses of type (x,y) in a vector  (x,y). the function acting on x will produce a subset  x+ (in vector form). the function acting on y produces scalars y . We have  actFst ::  x -> x and  actSnd ::  y -> y. This in total should yield  (x,y) -> (x,y).TODO This should create genericB vectors, that are specialized by the table they are stored into.0Turn a stream into a vector.1TODO need to be improved in terms of performance.1BGets the names used in the evaluation function. This returns one  for each variable. In case of TupleT 0 the type is ()0 and there isn't a name to go with it. We just  mkName "()"Q a name, but this might be slightly dangerous? (Not really sure if it indeed is)With AppT _ _T we have a multidim terminal and produce another hackish name to be consumed above. AppT (AppT ArrowT (AppT (AppT (ConT Data.Array.Repa.Index.:.) (AppT (AppT (ConT Data.Array.Repa.Index.:.) (ConT Data.Array.Repa.Index.Z)) (VarT c_1627675270))) (VarT c_1627675270))) (VarT x_1627675265) 3(Get all synvars, even if deep in a stack(  !"#$%&'()all non-terminal namesleft attribute functionright attribute function'all arguments to the attribute function*+,-./0123(   !"#$%&'()*+,-./0123( !"#$%&'()*+,-./01 23  !"#$%&'()*+,-./0123None!"%&*,/0569:;<=DLOQRT6666None!"%&*,/0569:;<=BDLOQRT 77TODO Rewrite to generalize easily over multi-dim cases.@>Constrains the behaviour of the memoizing tables. They may be @ if i==j: is allowed (empty subwords or similar); or they may need >" indices, or finally they can be OnlyZero (only i==j7 allowed) which is useful in multi-dimensional casese.H Similar to #, but terminates an argument stack.J_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.MmkStream( creates the actual stream of elements (Elm4) 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.ODuring 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 xt of the actual argument we want to grab (say individual characters we parse from an input) and the type of indices i we use.ElmV data constructors are all eradicated during fusion and should never show up in CORE.V)While we ostensibly use an index of type i/ we typically do not need every element of an i. For example, when looking at #s, we do not need both element of j:.k but only kM. Also, inside grammars do need fewer moving indices than outside grammars.TTODO 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.ZiNeeded for structures that have long-range interactions and "expand", like sets around edge boundaries: set  edge set%. requires the sets to be connected.kk acts as a static filter. If b+ is true, we keep all stream elements. If b* is false, we discard all stream elements.=789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs7789:;<=>?@ABCDEFGHIJKLMNORPQSTUPhVjiWXYZ[\]^_`abcdefgkl?cdefg_`abb]^Z[\WXYVsjriOPQRSTUMNJKLLqHIpohkEFGlBCD@A>?<=nm789:;789:;<=>?@ABCDEFGHIJKLLMNOPQRSTUVWXYZ[\]^_`abbcdefgklmnpohqrisj None!"%&*,/0569:;<=DLOQRT{Given some index structure x$, return the dimensional number in Nats.}Wrap  GetIndexGo and the type-level shenanigans.~Given some complete index list ixTy% and some lower-dimensional version myTy, walk down along ixTy until we have  is:.i ~ ms:.m and return m.Simplifying wrapper around  getIndexGo.{|}~{|}~~}|{ {|}~ None!"%&*,/0569:;<=DLOQRT Shorthand for proxifying getIndexTerm TermStream context Term MkStream context?state coming in from the left , tIx :: !(RunningIndex a) -- I/C index from sSI/C. building up state to hand over to next symbol element dataFor multi-dimensional terminals we need to be able to calculate how the static/variable signal changes and if the index for the inner part needs to be modified.;Extracts the type of a multi-dimensional terminal argument.+Terminal symbols are stacked together with a tails and b head.5Terminates a multi-dimensional terminal symbol stack. TODO need t -> ElmType t type function TODO need to actually return an  ElmType t# can do that instead of returning u !!!)P)2 None!"%&*,/0569:;<=BDLOQRTV None!"%&*,/0569:;<=DLOQRTV  None!"%&*,/0569:;<=DLOQRT$Instance headers, we typically need.SvState6 holds the state that is currently being built up by  AddIndexDense. We have both tIx (and tOx) and iIx (and iOxr). For most index structures, the indices will co-incide; however for some, this will not be true -- herein for Set index structures.?state coming in from the left , sIx :: !(RunningIndex a) -- I/C index from sSI/C building up state to index the table.I/C. building up state to hand over to next symbolTThis type classes enable enumeration both in single- and multi-dim cases. The type a is the type of the  full stack/ of indices, i.e. the full multi-tape problem.fGiven an incoming stream with indices, this adds indices for the current syntactic variable / symbol.ZIn case of 1-dim tables, we wrap the index creation in a multi-dim system and remove the ZC later on. This allows us to have to write only a single instance.P None!"%&*,/0569:;<=DLOQRTImmutable table.6We need this somewhat annoying instance construction (i ~ j and m ~ mB/) in order to force selection of this instance. P None!"%&*,/0569:;<=DLOQRTConstraints needed to use  iTblStream.General function for ITbls with skalar indices.General function for Backtrack ITbls with skalar indices.    P        None!"%&*,/0569:;<=DLOQRTyA syntactic variable that does not memoize but simplify recurses. One needs to be somewhat careful when using this one. ITbla performs memoization to perform DP in polynomial time (roughly speaking). If the rules for an IRecL are of a particular type, they will exponential running time. Things like X -> X X2 are, for example, rather bad. Rules of the type X -> Y, Y -> Z are ok, if Y is an IRec0 since we just continue on. The same holds for Y -> a YY. Basically, things are safe if there is only a (small) constant number of parses of an IRec synvar.   ! P    !     !None!"%&*,/0569:;<=DLOQRT"PFind the outermost table that has a certain big order and then fill from there.10Mutate a cell in a stack of syntactic variables.&TODO generalize to monad morphism via mmorph, package. This will allow more interesting mrphs functions that can, for example, track some state in the forward phase. (Note that this can be dangerous, we do nots want to have this state influence forward results, unless that can be made deterministic, or we'll break Bellman)31This grammar is a multi-cfg in a monotone setting4A vanilla context-free grammar5?Default table filling, assuming that the forward monad is just IO.TODO generalize to MonadIO or  MonadPrim.6RMutate tables, but observe certain hints. We use this for monotone mcfgs for now.8dTODO 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 otherTODO 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.DIRec7s do not need an order, given that they do not memoize.%"#$%&'()*+,-./0123456789:;<=>?@ABCDEF"#$%&'()*+,-./012345678%4312/0,-.FEDCBA+@?>5678%&'()*=<"#$;:9"#$%&'()*+,-./0123456789:;<=>?@ABCDEFNone!"%&*,/0569:;<=DLOQRT HIActually collect split indices based on if we managed to find the right Split$ synvar (based on the right symbol).PTODO this is not completely right, or? Since we should consider inside/outside?TODO J will need the index type iA to combine running index and index into the actual lookup part.Kx ++ y but for inductive tuples.TODO move to PrimitiveArrayN Type-level (||)OMClosed type family that gives us a (type) function for type symbol equality.PgWraps a normal non-terminal and attaches a type-level unique identier and z-ordering (with the unused Z at 0).DTODO attach empty/non-empty stuff (or get from non-splitted synvar?)<TODO re-introduce z-ordering later (once we have a sort fun)SShould never fail?TThe  Arg synVarJ means that we probably need to rewrite the internal type resolution now!Z,TODO Here, we probably want to default to a NonEmpty4 condition. Or at least have different versions of split.[[G gobbles up indices that are tagged with the same symbolic identifier. HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgYXHIJKLMNOPQRSTUWVZ["UVWTSPQRZgfeYdcX[ONKLMbaHIJ`_^]\HIJKLMNOPQRSTUVWZ[\]^_`abdcXfeYgNone!"%&*,/0569:;<=DLOQRThdA generic Character parser that reads a single character but allows passing additional information.h expects a function to retrieve rF at index position, followed by the actual generic vector with data.k1smart constructor for regular 1-character parsersl=Smart constructor for Maybe Peeking, followed by a character.hijklmnoPjhiklhiklonmjhiklnmjoNone!"%&*,/0569:;<=DLOQRTqrstuvPsqrqrvutsqrutsvNone!"%&*,/0569:;<=DLOQRTwKAn edge in a graph. As a parsing symbol, it will provide (From:.To) pairs. wxyz{|}~ Pwxyz{|}~ |}~yz{wxwxyz{|}~None!"%&*,/0569:;<=DLOQRTPNone!"%&*,/0569:;<=DLOQRTPNone!"%&*,/0569:;<=DLOQRT- terminals return "strings", i.e. vectors of Chr#s. They allow the user to specify [ 0 .. ][ atoms to be parsed at once. It is possible to both, limit the minimal and maximal number.-NOTE gadt comments are not parsed by haddock? P None!"%&*,/0569:;<=DLOQRTNone!"%&*,/0569:;<=DLOQRT_Apply a function to symbols on the RHS of a production rule. Builds the stack of symbols from xs using L, then hands this stack to N together with the initial iniT telling NL that we are in the "outer" position. Once the stream has been created, we  S5 to get just the arguments in the stack, and finally  the function f.1Combine two RHSs to give a choice between parses.Applies the objective function h to a stream sn. The objective function reduces the stream to a single optimal value (or some vector of co-optimal things).Separator between RHS symbols.LThis separator looks much paper "on paper" and is not widely used otherwise. 6789:;<=>?@ABCDEFGHIJKLMNORPQSTUsjYXhVjiWXYZ[\]^_`abcdefgkl{|}~  "#$%&'()*+,-./012345678HIJKLMNOPQRSTUWVZ[hiklqrwxyz{|}~88759 9 None!"%&*,/0569:;<=DLOQRTNone!"%&*,/0569:;<=DLOQRTNone!"%&*,/0569:;<=DLOQRTCurrent first try for using  TermStreamTODO what happens to fusion if  staticCheck happens before S.map?NOTE / TODO a bit faster with seq xs ?'First try in getting this right with a  termStream. TODO use PointL iE since this is probably the same for all single-tape instances with ElmChr.ATODO it might even be possible to auto-generate this code via TH.None!"%&*,/0569:;<=DLOQRTNone!"%&*,/0569:;<=DLOQRTNone!"%&*,/0569:;<=DLOQRT None!"%&*,/0569:;<=DLOQRT!None!"%&*,/0569:;<=DLOQRT#None!"%&*,/0569:;<=DLOQRT 6789:;<=>?@ABCDEFGHIJKLMNORPQSTUhYXjsVjiWXYZ[\]^_`abcdefgkl{|}~  "#$%&'()*+,-./012345678HIJKLMNOPQRSTUWVZ[hiklqrwxyz{|}~$None!"%&*,/0569:;<=DLOQRT%None!"%&*,/0569:;<=DLOQRT 6789:;<=>?@ABCDEFGHIJKLMNORPQSTUhYXjsVjiWXYZ[\]^_`abcdefgkl{|}~  "#$%&'()*+,-./012345678HIJKLMNOPQRSTUWVZ[hiklqrwxyz{|}~&'(&'())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddeefghijkllmnopqrstuvwxyz{|}~                                                 !"#$%%&'()*+,-.//0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYYZ2[\]^_`abcdefghijkklmnoppqrssttuvvwxyz{|}~     !!!!!(ADPfusion-0.5.2.2-LNVISjirdHED8ZnxMhz2tWADP.Fusion.SynVar.Split.TypeADP.Fusion.SynVar.TableWrapADP.Fusion.SynVar.BacktrackADP.Fusion.SynVar.AxiomADP.Fusion.Core.TH.CommonADP.Fusion.Core.TH.BacktrackADP.Fusion.Core.THADP.Fusion.Core.ClassesADP.Fusion.Core.TyLvlIxADP.Fusion.Core.MultiADP.Fusion.Core.PointADP.Fusion.Core.Unit!ADP.Fusion.SynVar.Indices.ClassesADP.Fusion.SynVar.Array.TypeADP.Fusion.SynVar.Array ADP.Fusion.SynVar.Recursive.TypeADP.Fusion.SynVar.FillADP.Fusion.Term.Chr.TypeADP.Fusion.Term.Deletion.TypeADP.Fusion.Term.Edge.TypeADP.Fusion.Term.Epsilon.TypeADP.Fusion.Term.PeekIndex.TypeADP.Fusion.Term.Strng.TypeADP.Fusion.Core.ApplyADP.Fusion.CoreADP.Fusion.SynVar.Indices.PointADP.Fusion.SynVar.Indices.UnitADP.Fusion.Term.Chr.PointADP.Fusion.Term.Deletion.PointADP.Fusion.Term.Deletion.UnitADP.Fusion.Term.Epsilon.PointADP.Fusion.Term.Epsilon.UnitADP.Fusion.Term.Strng.Point!ADP.Fusion.SynVar.Recursive.PointADP.Fusion.Point#ADP.Fusion.Tutorial.NeedlemanWunschADP.Fusion.Unitbase Data.ProxyProxyTWGenBacktrackTable BacktrackBacktrackIndex toBacktrackAxiom AxiomStreamaxiomgetRuleResultTypeArgTySynVarTerm StackedTerms StackedVarsNilVarResult synVarNametermName stackedTerms stackedVarsresultChoiceProductCombining SigCombining**>ProductBacktrackingSigBacktracking<||makeProductInstances getMonadNamegetObjectiveNames buildLeftTypebuildRightTypebuildSigBacktrackingTypebuildSigCombiningTypegenAlgProdFunctionsgenChoiceFunctiongenAttributeFunctionrecBuildLamPat buildLamPat argTyArgsbuildLnsbuildRnsbuildBacktrackingChoicebuildCombiningChoicestreamToVectorMgetRuleSynVarNames unpackArgTyflattenSynVars $fShowArgTy $fEqArgTymakeAlgebraProductModifyConstraintTNETE toNonEmptytoEmptyMinSizeminSizeNonEmptyEmptyOkSLRSLSR StaticCheck CheckLeft CheckRightSBuildStackbuildMkStreammkStreamElementElmRecElmArggetArggetIdxgetElm RunningIndex RuleContextContextinitialContextExtComplementContextCStatic CVariableComplementContext Complemented InsideContextIStatic IVariable iGetContextOutsideContextOStaticORightOf OFirstLeftOLeftOfElmSRiZ:.: staticCheck staticCheck#$fMinSizeNonEmpty$fMinSizeEmptyOk D:R:ElmSi0 $fElementSi $fBuildPairD:R:RunningIndexZ0D:R:RunningIndex:.0$fShowOutsideContext$fShowInsideContext$fShowComplementContext$fEqS$fShowS $fShowElm$fShowRunningIndexToNatGetIxGetIndex GetIndexGo ResolvedIx getIndexGogetIndex&$fGetIndexGoRunningIndexRunningIndexEQ&$fGetIndexGoRunningIndexRunningIndexGT'$fGetIndexGoRunningIndexRunningIndexGT0'$fGetIndexGoRunningIndexRunningIndexEQ0$fGetIndexGoZZEQ$fGetIndexGo:.ZGT$fGetIndexGo:.:.GT$fGetIndexGo:.:.EQPRITstCtxTmkCtx1Term1 TermStream termStream TermStateTStatetSiIxeTSTableStaticVartableStaticVartableStreamIndex TermStaticVar termStaticVartermStreamIndexTermArg TermSymbol:|MElmTerm1ElmTSaddTermStream1elmTerm1D:R:ElmTerm1:.0$fElementTerm1:.$fTermStreammMsZ$fTableStaticVar:.:.:.$fTableStaticVarcuZ$fRuleContext:.$fRuleContextZ$fTermStaticVarTermSymbol:.$fTermStaticVarMZ $fMkStreammSZ$fMkStreammPairi D:R:ElmPairi0$fElementPairi$fBuildTermSymbol$fEqM$fShowM$fEqTermSymbol$fShowTermSymbolRiPlCRiPlORiPlI$fTableStaticVarucPointL$fTableStaticVarucPointL0$fTableStaticVarucPointL1$fMkStreammSPointL$fMkStreammS:.$fMkStreammSPointL0$fMkStreammS:.0$fMkStreammSPointL1D:R:RunningIndexPointL0D:R:RunningIndexPointL2D:R:RunningIndexPointL4$fRuleContextPointL$fRuleContextPointL0$fRuleContextPointL1RiU$fTableStaticVarcuUnit$fTableStaticVarcuUnit0$fTableStaticVarcuUnit1$fMkStreammS:.1$fMkStreammSUnit$fMkStreammSUnit0$fMkStreammSUnit1D:R:RunningIndexUnit0$fRuleContextUnit$fRuleContextUnit0$fRuleContextUnit1IndexHdrSynVar1SvStateSvSsStx AddIndexDenseaddIndexDenseGo ElmSynVar1 addIndexDenseaddIndexDense1 elmSynVar1D:R:ElmSynVar1:.0$fElementSynVar1:.$fAddIndexDenseaZZZTwITblBtTwITblITbl iTblBigOrderiTblLittleOrderiTblConstraint iTblArray ElmBtITblElmITblBtITbl$fMkStreammBPair:.$fMkStreammPair:. D:R:ElmPairi2$fElementPairi0 $fAxiomTW $fAxiomTW0D:R:BacktrackTWmFmB0$fGenBacktrackTableTWmFmB $fBuildTW $fBuildTW0 $fShowElm0ITblCx iTblStream btITblStream$fModifyConstraintTW$fModifyConstraintTW0$fMkStreammBPairi$fMkStreammBPairi0$fMkStreammBPairi1$fMkStreammPairi0$fMkStreammPairi1TwIRecBtTwIRecIReciRecConstraintiRecFromiRecTo ElmBtIRecElmIRecBtIRecTSBOasDyn fillWithDynQ qBigOrder qLittleOrderqTypeRepqObjectZS2 TableOrdertableLittleOrder tableBigOrder MutateTables mutateTables MutateCell mutateCell MonotoneMCFGCFGmutateTablesDefaultmutateTablesWithHintsmutateTablesSTmutateTablesNew$fTSBO:. $fTSBO:.0$fTSBOZ$fOrdQ$fEqQ$fMutateTablesh:.im$fMutateCellh:.im:.$fMutateCellMonotoneMCFG:.im:.$fMutateCellCFG:.imi$fMutateCellCFG:.imi0$fMutateCellpZimi$fTableOrder:.$fTableOrder:.0 $fTableOrderZ$fShowQ SplitIxCol SplitIxTy splitIxColZconcatZppzconcatORSameSidSplitgetSplit CalcSplitType SplitTypeFragmentFinalElmSplitBtITbl ElmSplitITblsplit collectIx$fSplitIxColuIdTrueElm$fSplitIxColuIdTrueElm0$fSplitIxColuIdTrueElm1$fSplitIxColuIdFalseElm$fSplitIxColuIdbElm $fZconcatx:. $fZconcatxZ $fBuildSplitChrElmChrchrchrLeft $fBuildChrDeletion ElmDeletion$fBuildDeletionEdgeTogetToFromgetFromElmEdge $fBuildEdge$fEqFrom $fOrdFrom $fShowFrom$fEqTo$fOrdTo$fShowToEpsilon ElmEpsilon$fBuildEpsilon PeekIndex ElmPeekIndex$fBuildPeekIndexStrngElmStrngmanySsomeSstrng $fBuildStrngApplyFunapply $fApply(->) $fApply(->)0 $fApply(->)1 $fApply(->)2 $fApply(->)3 $fApply(->)4 $fApply(->)5 $fApply(->)6 $fApply(->)7 $fApply(->)8 $fApply(->)9 $fApply(->)10 $fApply(->)11 $fApply(->)12 $fApply(->)13<<<<<#|||...~~%$fAddIndexDenses:.:.:.$fAddIndexDenses:.:.:.0$fAddIndexDenses:.:.:.1$fAddIndexDenses:.:.:.2$fTermStaticVarChrPointL$fTermStaticVarChrPointL0$fTermStreammTermSymbols:.$fTermStreammTermSymbols:.0$fMkStreammPairPointL$fTermStaticVarDeletionPointL$fTermStaticVarDeletionPointL0$fTermStaticVarDeletionUnit$fTermStaticVarDeletionUnit0$fMkStreammPairUnit$fTermStaticVarEpsilonPointL$fTermStaticVarEpsilonPointL0$fTermStaticVarEpsilonUnit$fTermStaticVarEpsilonUnit0$fTermStaticVarStrngPointL$fTermStaticVarStrngPointL0template-haskellLanguage.Haskell.TH.SyntaxName-PrimitiveArray-0.8.0.1-H8L9mO6Qdgd6EjLRyswnkqData.PrimitiveArray.Index.ClassZ!Data.PrimitiveArray.Index.SubwordSubword&vector-0.11.0.0-6uB77qGCxR6GPLxI2sqsX3!Data.Vector.Fusion.Stream.MonadicmapStreamData.Vector.Fusion.UtilIdunId