U<      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                       !SafeOCommand line config.Command line mode.Parse command-line arguments.  SafeO/!"Safe OT #Get the endianness from the GHC header file. We do this via a filty #include so that the information is statically visible to the GHC simplifier.$=Convert from a big endian 64 bit value to the cpu endianness.%@Convert from a little endian 64 bit value to the cpu endianness.&=Convert from a big endian 32 bit value to the cpu endianness.'@Convert from a little endian 32 bit value to the cpu endianness.(=Convert from a big endian 16 bit value to the cpu endianness.)@Convert from a little endian 16 bit value to the cpu endianness.*5Convert a 64 bit value in cpu endianess to big endian+8Convert a 64 bit value in cpu endianess to little endian,5Convert a 32 bit value in cpu endianess to big endian-8Convert a 32 bit value in cpu endianess to little endian.6Convert a 16 bit value in cpu endianness to big endian/9Convert a 16 bit value in cpu endianness to little endian $%&'()*+,-./012SafeO4"Index of a nominal constant.Generic names for things.#A reference to some external thing.An uninterpreted symbol.A primitive value.A text string. A macro name. A set name. A nominal variable. Bump index indicator. Binding depth indicator. .Indicates how to bump the index on a variable. QLifting indicator, mapping name and binding depth to number of levels to lift.YExplicit substitution map, parameterised by the types used for symbols and primitives._A car on the substitution train, parameterised by the types used for symbols and primitives.Simultaneous subsitution.Recursive substitution.Lifting."Expression keys (super primitives)bDelay evaluation of an expression used as the argument of a call-by-value function application.Run a boxed expression.)Form of argument required in application.Value for call-by-value.Expression for call-by-nameFunction parameter. Substitution train.!CExpression, parameterised by the types of symbols and primitives"Reference to an external thing.#Keyed expressions.$4Application of a function expression to an argument.%#Variable name with a depth counter.&<Abstraction with a list of parameters and a body expression.'gSubstitution train applied to an expression. The train car at the head of the list is applied first.(OTop-level declaration, parameterised by the types of symbols and primitives.*   !'&%$#"(*)  !"#$%&'()*SafeO;+{Make an application of a function to the given list of arguments, suppressing the application of there are no arguments.,9Take an application of a function to a list of arguments.-PMake an abstraction, short circuiting to the body if there are no parameters..%Get the name of a function parameter./.Get the argument form required by a parameter.+,-./SafeHOQ0-Cons a car on the front of an existing train..If the new car is empty it will be suppressed.dIf the new car can be combined with the first car on the existing train then it will be combined.1Append two trains.3VBump a train due to pushing it under an abstraction with the given parameter names.2KWrap an expression in a substitution train. If the expression is a plain4<Apply a train to a named variable of a given name and depth.55Apply a train to a nominal variable of a given index.6%Check if a substitution car is empty.37Build a substitution from lists of names and arguments.7)Check if the given substitution is empty.8]Bump a substitution due to pushing it under an abstraction with the given parameter names.4VWrap a train consisting of a single simultaneous substitution around an expression.9=Apply a substitution to a variable of a given name and depth.:>Apply a substitution to a nominal variable of the given index.; Check if the given ups is empty.<9Wrap an expression in a train consisting of a single ups.=Apply an ups to a variable.>fBump ups (substitution lifting) due to pushing it under an absraction with the given named binders.?Combine two lists of ups.@Combine a bump with an existing list of them. Applying the result to an expression will achieve the same result as applying the whole list and then the extra one.013245637849:;<=>?@SafeOW5JPush down any outermost substitution train to reveal the head constructor.6CPush down the left-most substitution train in an expression, or A if there isn't one.B8Push down the first substiution train in the given list.CTPush a substitution train down into an expression to reveal the head constructor.56BCSafeOWY7  !"#$%&'()*+,-./01234567()*!"#$%&'     +,-./0124356SafeOZ7World state for evaluation9 Generator for nominal variables.: User state;Initialize a new world.78:9;789:SafeOb<jAn unordered collection of things. O(1) to add a single element, a list of elements, or union two bags.AO(1). Construct an empty bag.B2O(1). Construct a bag containing a single element.C4O(1). Construct a bag containing a list of elements.DO(1). Union two bags.EoO(n). Convert a bag to a list. The elements come out in some deterministic but arbitrary order, no promises.F.Apply a function to all the elements in a bag. <@?>=ABCDEF <=>?@ABCDEF<=>?@SafeOgxH4A thing located at the given range in a source file.JLocation in a source file.L(Take the start point of a located thing.M&Take the end point of a located thing.N"Take the value of a located thing.O4Increment the character position of a located thing.P/Increment the line position of a located thing. HIJKLMNOP JKHILMNOPHIJKSafeOoBDPrimitive evaluator.EOp name.FOp description.GArgument passing methods.HEvaluation function.SPrimitive values and operators.I=Take the first expression argument from a list of primitives.d'Take a literal Bool from an expression.eMake a literal Bool expression.f+Split a literal Bool from an argument list.g&Take a literal Nat from an expression.hMake a literal Nat expression.i*Split a literal Nat from an argument list.jMake a list of expressions.DJEFGHSTUVWXYZ[\]^_`abcIdefghijDJEFGHSTUVWXYZ[\]^_`abcSafeOqk"Pretty print a primitive operator.l,Parse a primitive name, without the leading #.STUVWXYZ[\]^_`abcdefghijklSTUVWXYZ[\]^_`abckledfhgijSafeO mResult of evaluation.pEvaluation configr!Reduce under lambda abstractions.s1Reduce arguments when head is not an abstraction.t Primitive operator declarations.uMacro declarations.v$Multi-step reduction to normal form.wSingle step reduction.LThis is a definitional interpreter, intended to be easy to understand and get right, but not fast. Each time we take a step we decend into the AST looking for the next redex, which causes evaluation to have a higher asymptotic complexity than it would with an evaluator that that manages the evaluation context properly.K>Step an application of a primitive operators to its arguments.L?Step an application of an abstraction applied to its arguments.M>Step an application of a primitive operator to some arguments.NSStep the first available expression in a list, reducing them all towards values.O.Step the first available expression in a list.789:;mnopqrstuvwpqrstu789:mno;vwmnopqrstuNone;=O yICompute the serialized size of a shimmer file containing the given decls.z3Compute the serialized size of a given declaration.{4Compute the serialized size of the given expression.P+Compute the serialized size of a parameter.Q2Compute the serialized size of a substitution car.R3Compute the serialized size of a substitution bind.S/Compute the serialized size of an lifting bump.|3Compute the serialized size of the given reference.T-Compute the serialized size of a text string.U.Compute the serialized size of a bump bounter.V.Compute the serialized size of a nominal atom.W4Compute the serialized size of a sequence of things.yz{|None);=OT9}!Type of a function that pokes an a thing into memory.NIt takes a pointer to the next byte to use, and returns an updated pointer.~Poke a list of (, into memory, including the SMR file header.Poke a ( into memory.Poke an ! into memory.XPoke an !, abstraction into memory with packed length.YPoke an !, application into memory with packed length.ZPoke a  into memory.[Poke a  into memory.\Poke a  into memory.]Poke an  into memory.^Poke an   into memory._Poke a Var into memory.Poke a  into memory.`Peek a  from memory.aPoke a   into memory.bPoke a  into memory.cPoke a prim into memory.d7Poke a list of things into memory, including size info.e1Poke a text value into memory as UTF8 characters.fPoke a g into memory.hPoke a i$ into memory, in network byte order.jPoke a k$ into memory, in network byte order.lPoke a m$ into memory, in network byte order.nPoke a Float32$ into memory, in network byte order.oPoke a Float64$ into memory, in network byte order.}~None;=OTVg!Type of a function that peeks an a thing from memory.tIt takes the current pointer and count of remaining bytes in the buffer, returns new pointer and remaining bytes.Peek a list of (, from memory, including the SMR file header.%If the packed data is malformed then p.Peek a ( from memory.%If the packed data is malformed then p.Peek an ! from memory.%If the packed data is malformed then p.q%Peek a short abstraction from memory.r%Peek a short application from memory.sPeek a  from memory.tPeek a  from memory.uPeek a  from memory.vPeek an  from memory.wPeek an   from memory.Peek a  from memory.%If the packed data is malformed then p.xPeek a  from memory.yPeek a   counter from memory.zPeek a  from memory.{Peek a prim from memory.|"Peek a list of things from memory.}'Peek a short variable name from memory.~1Peek a text value from memory as UTF8 characters.Peek a g7 from memory, in network byte order, with bounds check.Peek a g: from memory, in network byte order, with no bounds check.Peek a i7 from memory, in network byte order, with bounds check.Peek a i9 from memory, in network byte order, with no bound check.Peek a k7 from memory, in network byte order, with bounds check.Peek a k: from memory, in network byte order, with no bounds check.Peek a m7 from memory, in network byte order, with bounds check.Peek a m$ from memory, in network byte order.Peek a Float327 from memory, in network byte order, with bounds check.Peek a Float647 from memory, in network byte order, with bounds check.NoneO|Pack a list of ( into a  ByteString, including the file header.Pack a ( into a  ByteString.Pack an ! into a  ByteString.Pack a  into a  ByteString.Unpack a list of (. into a ByteString, including the file header.%If the packed data is malformed then p. Unpack a ( from a ByteString.%If the packed data is malformed then p. Unpack an ! into a ByteString.%If the packed data is malformed then p. Unpack a  from a ByteString.%If the packed data is malformed then p.yz{|}~yz{|}~SafeOh+Primitive evaluators for boolean operators.1Construct an evaluator for 1-arity bool operator.1Construct an evaluator for 2-arity bool operator.hPrimitive evaluator for the #if operator. Only the scrutinee is demanded, while the branches are not.SafeOa(Primitive evaluators for list operators.)Cons an element to a the front of a list.*Split an element from the front of a list.'Snoc an element to a the end of a list.)Unsnoc an element from the end of a list.Append two lists.SafeHOPrimitive matching operators.Match against a given symbol.8Match an application. TODO: pack the args into a list'Match all parameters of an abstraction.,Match the first parameter of an abstraction.SafeO'Primitive evaluators for nat operators.@Construct an evaluator for a 2-arity nat operator returning nat.AConstruct an evaluator for a 2-arity nat operator returning bool.SafeOh2Primitive evalutor for nominal variable operators.,Check for equality of two nominal variables."Allocate a fresh nominal variable.5Create a closing substitution for a nominal variable.SafeO)Primitive evaluator for symbol operators.Check equality of two symbols.SafeO<Set containing textual names of all the primitive operators.+Evaluators for all the primitive operators.SafeO9Describes why the parser could not make further progress.'Remaining input tokens where we failed.&Description of what we were expecting.Result of a parser, parameterised by (t) the type of tokens, (e) the type for decriptions of what we're expecting to parse. (a) type of value to parse.Parser failed after consuming no input. The parser looked at one or more tokens at the front of the input but based on these the input does not look like whatever syntax the parser was supposed to parse.Parser yielding a value after consuming no input. The parser returned a value without looking at any tokens, this is a pure value returning action.Parse failed after partially consuming input. The parser thought that the input sequence looked like what it was supposed to parse, but complete parsing failed once it had committed.yParse succeeded yielding a value after consuming input. We have a complete value, and have consumed some input tokens.Parser is a function that takes a list of tokens, and returns a list of remaining tokens along with (on error) a list of descriptions of expected input, (on success) a parsed value.)Apply a parser to a list of input tokens.GAlways fail, producing no possible parses and no helpful error message.EAlways fail, yielding the given message describing what was expected.pCommit to the given parser, so if it skips or returns without consuming any input then treat that as failure. Parse in an expectation context.RIf the given parser suceeds then enter an expectation context for the next one.7Peek at the first input token, without consuming at it.;Consume the first input token, failing if there aren't any.~Consume the first input token if it matches the given predicate, failing without consuming if the predicate does not match.|Consume the first input token if it is accepted by the given match function. Fail without consuming if there is no match.pGiven two parsers, try the first and if it succeeds produce the output of that parser, if not try the second.Like 1 but take a list of parser, trying them in order.;Parse zero or more things, yielding a list of those things.:Parse one or more things, yielding a list of those things.,Parse some things separated by other things.3Parse at least one thing separated by other things.8Run a parser, peeking at the starting and ending tokens. SafeO0Context we're currently in when pretty printing.Top level context.+Functional expression in an an application.&Argument expression in an application.7Class of things that can be converted to text builders.Wrap a thing in parenthesis.Pretty print a thing as strict ."Yield a builder for a declaration."Yield a builder for an expression. Yield a builder for a parameter.Yield a builder for a keyword.Yield a builder for a train. Yield a builder for a train car.#Yield a builder for a substitution.+Yield a builder for a substitution binding.Yield a builder for an ups. Yield a builder for an ups bump. Yield a builder for a reference.:Build a text string, escaping special chars in JSON style. Yield a builder for a primitive. SafeOQName space of a name.Local variable. Macro name. Symbol name. Set name.Primitive name.Keyword (super primitive) Nominal name.#Tokens for for the source language. End of input.Punctuation character.A scoped name.A literal natural number.A literal text string.+Check if a token is equal to the give none.8Check is token is punctuation using the given character.#Take the name from a token, if any.#Take the name from a token, if any.-Take the natural number from a token, if any.*Take the text string from a token, if any. SafeOLex a sequence of tokens.Lex a single token.Lex a variable name.Lex a natural number. Lex a string.6Take the namespace qualifier from the front of a name.9Check if this character can appear in the body of a name.)Check if this is a punctuation character.HIJKHIJK SafeO Parser error.<What we were expecting at the point there was a parse error.Expecting end of input.(Expecting a name in the given namespace."Expecting a name in any namespace.Expecting a natural number.Expecting a text string."Expecting a punctuation character.3Expecting something described by the given message.0Expecting something while parsing a declaration.,Expecting something while parsing a binding.Pretty print an expected thing.Pretty print a blocker.Pretty print a parser error. SafeO/6Parse some Shimmer declarations from a list of tokens.1Parse a Shimmer expression from a list of tokens."Parser for a list of declarations. Parser for a single declaration.Parser for an expression.Parser for an application. Parser for an atomic expression.  Parser for a function parameter. KParser for a substitution train. The cars are produced in reverse order.  Parse a single car in the train. &Parser for a substitution environment. Snv ::= '[' Bind*, ']'  Parser for a binding. Bind ::= Name '=' Exp | Name  Nat '=' Exp Parser for an ups. Ups ::= '{' Bump*, '}' Parser for a bump. Bump ::= Name : Nat | Name  Nat : Nat Parser for a natural number.Parser for a text string.*Parser for a name in the given name space.Parser for a name of any space."Parser for the end of input token.#Parser for a punctuation character.Primop configration.Tokens to parse.Primop configuration.Tokens to parse.           NoneO0Load decls from the given file.!NoneO;Current interpreter mode.0Top-level declarations parsed from source files.Working source files.Execution world.Main repl loop dispatcherQuit the repl.Display the help page.Display the language grammar.Display the list of primops.)Display the list of current declarations.Reload the current source file.#Parse and print back an expression.0Parse an expression and push down substitutions.Advance the train pusher.'Parse an expression and single-step it.Advance the single stepper.%Parse an expression and normalize it.Advance the evaluator stepper.NParse an expression and normalize it, printing out each intermediate state.Advance the evaluator stepper.&"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                         ! " # $ % & ' ( ) * + , - . / 0 123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde`fghijklmnopqrstuvwxyz{|}~[[[[[       [ !!!!!!!!!!!!!!!!!!!!!!!!!!!!2!!!!8!!!!!!$shimmer-0.1.2-2wMzuqf1RpcJjRbVzJOvR0 SMR.Core.Exp SMR.Core.Step SMR.Data.BagSMR.Data.Located SMR.Prim.NameSMR.Core.Codec SMR.Prim.OpSMR.Source.ParsecSMR.Source.PrettySMR.Source.TokenSMR.Source.LexerSMR.Source.ExpectedSMR.Source.ParserSMR.CLI.Config SMR.CLI.HelpSMR.Core.Codec.WordSMR.Core.Exp.BaseSMR.Core.Exp.CompoundsSMR.Core.Exp.TrainSMR.Core.Exp.PushSMR.Core.WorldSMR.Prim.Op.BaseSMR.Core.Codec.SizeSMR.Core.Codec.PokeSMR.Core.Codec.PeekSMR.Prim.Op.BoolSMR.Prim.Op.ListSMR.Prim.Op.MatchSMR.Prim.Op.NatSMR.Prim.Op.NomSMR.Prim.Op.SymSMR.CLI.Driver.Load SMR.CLI.Repl#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.InternalTextNomNameRefRSymRPrmRTxtRMacRSetRNomBumpDepthUpsBumpUpsUUpsSnvBindBindVarBindNomSnvSSnvCarCSimCRecCUpsKeyKBoxKRunFormPValPExpParamPParamTrainExpXRefXKeyXAppXVarXAbsXSubDeclDeclMacDeclSet makeXApps takeXAppsmakeXAbs nameOfParam formOfParam trainCons trainAppend trainApplysnvOfNamesArgssnvApplypushHeadpushDeepWorld worldNomGen worldUsernewWorldBagBagNilBagElemBagListBagUnionnil singletonlistuniontoListmap $fShowBagLocatedLLLocationLstartOfLocated endOfLocatedvalueOfLocatedincCharOfLocationincLineOfLocation$fShowLocation $fShowLocatedPrim PrimTagUnit PrimTagList PrimLitBool PrimLitNat PrimLitInt PrimLitWord8 PrimLitWord16 PrimLitWord32 PrimLitWord64 PrimLitInt8 PrimLitInt16 PrimLitInt32 PrimLitInt64PrimLitFloat32PrimLitFloat64PrimOp takeXBool makeXBool takeArgBooltakeXNatmakeXNat takeArgNat makeXListpprPrimreadPrimResult ResultDone ResultErrorConfigconfigUnderLambdasconfigHeadArgs configPrimsconfigDeclsMacstepsstep $fShowResultsizeOfFileDecls sizeOfDecl sizeOfExp sizeOfRefPoke pokeFileDeclspokeDeclpokeExppokeRefPeek peekFileDeclspeekDeclpeekExppeekRef packFileDeclspackDeclpackExppackRefunpackFileDecls unpackDecl unpackExp unpackRef primOpsBool primOpsList primOpsMatch primOpsNat primOpsNom primOpsSym primNamesprimOpsBlocker blockerTokensblockerExpected ParseResult ParseSkip ParseReturn ParseFailure ParseSuccessParserparsefailexpectedcommitenterenterOnpeekitem satisfiesfromaltaltssomemanysepBysepBy1 withDelims $fMonadParser$fApplicativeParser$fFunctorParser $fShowBlocker$fShowParseResultCtxCtxTopCtxFunCtxArgBuildbuildparenspretty buildDeclbuildExp buildParambuildKey buildTrainbuildCarbuildSnv buildSnvBindbuildUps buildUpsBumpbuildRef buildText buildPrim $fBuildPrim $fBuildText $fBuildExp $fShowCtxSpaceSVarSMacSSymSSetSPrmSKeySNomTokenKEndKPuncKNameKNatKTextisTokenisKPunctakeNameOfTokentakeAnyNameOfTokentakeNatOfTokentakeTextOfToken $fShowSpace $fEqSpace $fShowToken $fEqToken lexTokens ParseErrorExpected ExBaseEnd ExBaseNameOf ExBaseNameAny ExBaseNat ExBaseText ExBasePunc ExBaseMsg ExContextDecl ExContextBind pprExpected pprBlocker pprLocation pprParseError$fShowExpected$fShowParseError configReadSym configReadPrmError parseDeclsparseExppDeclspDeclpExppExpApppExpAtompParampTrain pTrainCar pCarSimRecpBindpUpspBumppNatpText pNameOfSpacepNamepEndpPuncMode parseArgs configMode ModeConvertModeLoadModeREPLModeNone configZerousage helpCommands helpGrammar systemEndianfromBE64fromLE64fromBE32fromLE32fromBE16fromLE16toBE64toLE64toBE32toLE32toBE16toLE16EndianBigLittle trainBump trainApplyVar trainApplyNom carIsEmpty snvIsEmptysnvBump snvApplyVar snvApplyNom upsIsEmptyupsApply upsApplyVarupsBump upsCombineupsCombineBumpbaseGHC.BaseNothing pushDeepFirst pushTrainPrimEval primEvalName primEvalDesc primEvalForm primEvalFun takeArgExp stepAppPrm stepAppAbsstepPrim stepFirstVal stepFirst sizeOfParam sizeOfCar sizeOfSnvBind sizeOfUpsBump sizeOfName sizeOfBump sizeOfNom sizeOfListpokeAbspokeApppokeKey pokeParampokeCar pokeSnvBind pokeUpsBumppokeVarpokeNamepokeBumppokeNompokePrimpokeListpokeText pokeWord8GHC.WordWord8 pokeWord16Word16 pokeWord32Word32 pokeWord64Word64 pokeFloat32 pokeFloat64GHC.ErrerrorpeekAbspeekApppeekKey peekParampeekCar peekSnvBind peekUpsBumppeekNamepeekBumppeekNompeekPrimpeekListpeekVarpeekText peekWord8 peekWord8' peekWord16 peekWord16' peekWord32 peekWord32' peekWord64 peekWord64' peekFloat32 peekFloat64 primOpBool1 primOpBool2primOpIfprimOpListConsprimOpListUnconsprimOpListSnocprimOpListUnsnocprimOpListAppendprimOpMatchSymprimOpMatchAppprimOpMatchAbsprimOpMatchAbs1 primOpNat2NatprimOpNat2BoolNat primOpNomEqprimOpNomFreshprimOpNomClose primOpSymEqlexTokenlexNamelexNatlexText takeSpaceisNameBodyChar isCharPuncGHC.Real^runLoadFileDecls stateMode stateDecls stateFiles stateWorldreplLoopreplQuitreplHelp replGrammar replPrims replDecls replReload replParsereplPush replPush_nextreplStep replStep_next replStepsreplSteps_next replTracereplTrace_nextRExpRDeclRWorldRConfigRStateStateModeStepModePush ModeParse replStartshowFormleftPad printDecl replLoadExp replParseExp