8&f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          Safe  !"#$% !"#$%  !"#$%Safe     Safe   Safe7&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[1SafeAll of the keywords. This list is used when parsing and rendering because an unquoted string cannot have a name that is exactly the same as a keyword. \ !"#$  !"#$  !"#$ \ !"#$Safe%qA string that can be rendered unquoted. Unquoted strings are restricted to a conservative set of characters; see * for the full rules.[The constructor is tagged "unsafe" because it lets you construct and invalid value. Prefer ( which does validate the text. )9Throws an exception if the string cannot render unquoted.*Whether a string having this name can be rendered without quoting it. We allow a string to render unquoted if all these conditions are met:The string is nonemptyAll characters satify +The string is not a keywordstr'canRenderUnquoted "-ab_c"Truestr'canRenderUnquoted ""Falsestr'canRenderUnquoted "a\"b"Falsestr'canRenderUnquoted "let"False+ Letters, -, and _.%&'()*+,%&'()*+%&'()*+%&'()*+,NoneI[f*1A with expression. See m.5<A semicolon-terminated binding within the binding list of a 8 expression. 6+A binding with an equals sign, of the form x = y;7A binding using the inherit keyword, of the form  inherit a b; or inherit (x) a b;8A let-in expression. See l.:%The bindings (everything between the let and in keywords); The value (everything after the in keyword)<An expression of the form  person.name& that looks up a key from a dict. See i. @A binding of the form x = y; within a  DictLiteral or LetExpr.C)A dict literal expression, starting with { or rec { and ending with }. See h. E.Whether the dict is recursive (denoted by the rec keyword)F!The bindings (everything between { and })G)A list literal expression, starting with [ and ending with ]. See g. IOne item within a M.K+The name of the key to pull out of the dictLBThe default value to be used if the key is not present in the dictMA type of function parameter (Q) that does dict destructuring.OUThe list of keys to pull out of the dict, along with any default value each may haveP[Whether to allow additional keys beyond what is listed in the items, corresponding to the ... keywordQA parameter to a Y}. All functions have a single parameter, but it's more complicated than that because it may also include dict destructuring. R"A simple single-parameter functionSgDict destructuring, which gives you something resembling multiple named parameters with default valuesTBoth a param name and" a dict pattern, separated by the @ keywordU'A function application expression. See k.WThe function being calledXThe argument to the functionYA function expression. See j.['Declaration of the function's parameter\*Body of the function; what it evaluates to]One part of a `.`>A quoted string expression, which may be a simple string like "hello"8 or a more complex string containing antiquotation like "Hello, my name is ${name}!". See f.`We use the description "dynamic" to mean the string may contain antiquotation, in contrast with c which cannot. cyA fixed string value. We use the description "static" to mean the string may not contain antiquotation, in contrast with ` which can. eA variable , such as x.fA stringL may be quoted either in the traditional form using a single double-quote ("..."):  "one\ntwo":or in the "indented string" form using two single-quotes (''...''): '' one two ''oBoth of these examples reduce to the same value, because leading whitespace is stripped from indented strings.Either may contain "antiquotation" (also known as "string interpolation") to conveniently concatenate string-valued variables into the string. "Hello, my name is ${name}!":Normal strings may contain the following escape sequences:\\ ! \\" ! "\${ ! ${\n ! newline\r ! carriage return\t ! tabAThe indented string form does not interpret any escape sequences.gA list) is an ordered collection of expressions.The empty list: [ ]"A list containing three variables:  [ a b c ] Lambdas, function applications, let-in expressions, and with3 expressions must be parenthesized when in a list. B[ (x: f x y) (g y) (let a = y; in f a a) (with d; f x a) ]hA dict2 is an unordered extensional mapping from strings."The empty dict (with no bindings): { }A dict with two bindings: !{ a = "one"; b = "one two"; }NBy default, dict bindings cannot refer to each other. For that, you need the rec keyword to create a  recursive dict. &rec { a = "one"; b = "${a} two"; }:In either case, the order of the bindings does not matter.QThe left-hand side of a dict binding may be a quoted string (in the traditional "..." style, not the indented-string '' style), which make it possible for them to be strings that otherwise couldn't be expressed unquoted, such as strings containing spaces: { "a b" = "c"; }MThe left-hand side of a dict may even be an arbitrary expression, using the ${ ... } form: !let x = "a b"; in { ${x} = "c"; }Dicts also support the inherit keyword: { inherit a; inherit (x) c d; })The previous expression is equivalent to: { a = a; c = x.c; d = x.d; }iA dot expression (named after the .6 character it contains) looks up the value in a dict.+The examples in this section all reduce to Z. { a = "Z"; }.a let x = { a = "Z"; }; in x.a { x = { a = "Z"; }; }.x.aIThe right-hand side of a dot may be a quoted string (in the traditional "..." style, not the indented-string '' style): { a = "Z"; }."a"MThe right-hand side of a dot may even be an arbitrary expression, using the ${ ... } form: #{ a = "Z"; }.${ let b = "a"; in b }jA lambda expression x: y where x is the parameter.5This is a function that turns a name into a greeting: name: "Hello, ${name}!"%The function parameter can also be a  dict pattern, which looks like this: 7{ a, b, c ? "another" }: "Hello, ${a}, ${b}, and ${c}!"3That function accepts a dict and looks up the keys a, b, and c& from it, applying the default value  "another" to c if it is not present in the dict. Dict patterns therefore give us something that resembles functions with named parameters and default arguments.By default, a lambda defined with a dict pattern fails to evaluate if the dict argument contains keys that are not listed in the pattern. To prevent it from failing, you can end the pattern with ...: %({ a, ... }: x) { a = "1"; b = "2"; }[Every function has a single parameter. If you need multiple parameters, you have to curry:  a: b: [ a b ]k Function  application: f xVIf a function has multiple (curried) parameters, you can chain them together like so: f x y zlA let-in expression: Blet greet = x: "Hello, ${x}!"; name = "Chris"; in greet nameLet0 bindings, like dict bindings, may also use the inherit keyword. blet d = { greet = x: "Hello, ${x}!"; name = "Chris"; } inherit (d) greet name; in greet name=The previous example also demonstrates how the bindings in a let@ expression may refer to each other (much like a dict with the recE keyword). As with dicts, the order of the bindings does not matter.mA with expression is similar to a let-in0 expression, but the bindings come from a dict. Ewith { greet = x: "Hello, ${x}!"; name = "Chris"; }; greet nameThis instance is designed for doctests and REPL experimentation. The format is designed to strike a balance in verbosity between the derived . implementations (which are unwieldily long) and the Bricks language itself (which is quite terse but unsuitable for demonstrating the parser, as outputting a Bricks rendering of parse result wouldn't illumunate anyone's understanding of the AST that the . instances are here to depict). s]^-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstFunctionArgsFunction applicationuDictLookupsDot expression_`abcdefvwxyz{|}~I-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuIdefghijklmc`ab]^_nopqrsGHCDEF@AB<=>?uYZ[\QRSTMNOPIJKLUVWXt89:;5671234-./0B]^-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd efghijklmnopqrstu_`abcdefvwxyz{|}~None<=?IA newtype for ] just so we can give it the g? instance which would be dubiously appropriate for the actual ] type./Combine two params, merging dict patterns with 9 and preferring the right-hand-side when names conflict. VCombine two dict patterns, taking the concatenation of the item list, and the Boolean or of the ellipsis flag. $$NoneI[ One line of an ._The number of leading space characters. We store this separately for easier implementation of ..The rest of the line after any leading spaces.=An "indented string literal," delimited by two single-quotes ''.wThis type of literal is called "indented" because the parser automatically removes leading whitespace from the string (), which makes it convenient to use these literals for multi-line strings within an indented expression without the whitespace from indentation ending up as part of the string. Join s with newlines interspersed. Determines whether an 4 contains any non-space characters. The opposite of .}This is used to determine whether this line should be considered when calculating the number of space characters to strip in . The opposite of .NDetermine how many characters of whitespace to strip from an indented string.  Modify an 8 by applying a function to its number of leading spaces.|Determine the minimum indentation of any nonempty line, and remove that many space characters from the front of every line. GRemove any empty lines from the beginning or end of an indented string.  None[-Backtracking parser for a particular keyword.Parser for an unquoted string. Unquoted strings are restricted to a conservative set of characters, and they may not be any of the keywords.!parseTest parse'strUnquoted "abc"unquoted "abc"!parseTest parse'strUnquoted "x{y" unquoted "x"!parseTest parse'strUnquoted "let""parse error at (line 1, column 4):unexpected end of inputBParser for a static string which may be either quoted or unquoted.%parseTest parse'strStatic "\"hello\"""hello"!parseTest parse'strStatic "hello""hello"#parseTest parse'strStatic "\"a b\"""a b"parseTest parse'strStatic "a b""a")By "static," we mean that the string may not contain antiquotation.*parseTest parse'strStatic "\"a${x}b\" xyz""parse error at (line 1, column 5):,antiquotation is not allowed in this context*Parser for a static string that is quoted.%Parser for an unquoted static string.mParser for a dynamic string that is quoted. It may be a "normal" quoted string delimited by one double-quote "..." (9) or an "indented" string delimited by two single-quotes ''...'' (). 9Parser for a dynamic string enclosed in "normal" quotes ("...").Parser for at least one normal character, within a normally-quoted string context, up to but not including the end of the string or the start of an antiquotation. aParser for a dynamic string enclosed in "indented string" format, delimited by two single-quotes ''...'':. This form of string does not have any escape sequences. Parser for an indented string. This parser produces a representation of the lines from the source as-is, before the whitespace is cleaned up. Parser for a single line of an .4Parser for a function parameter (the beginning of a Y+), including the colon. This forms part of S, so it backtracks in places where it has overlap with other types of expressions. gParser for a parameter that starts with a variable. This could be a simple param that consists only of onlyB the variable, or the variable may be followed by a dict pattern. Parser for a param that has no variable, only a a dict pattern. This parser backtracks because the beginning of a dict pattern looks like the beginning of a dict expression. vParser for a dict pattern (the type of lambda parameter that does dict destructuring. This parser does not backtrack. This is used in a lookahead by 5 to determine whether we're about to start parsing a M.  Parser for a lambda expression (x: y).'parseTest parse'lambda "x: [x x \"a\"]"7lambda (param "x") (list [var "x", var "x", str ["a"]]) parseTest parse'lambda "{a,b}:a"1lambda (pattern [param "a", param "b"]) (var "a")'parseTest parse'lambda "{ ... }: \"x\""+lambda (pattern [] <> ellipsis) (str ["x"])3parseTest parse'lambda "a@{ f, b ? g x, ... }: f b"~lambda (param "a" <> pattern [param "f", param "b" & def (apply (var "g") (var "x"))] <> ellipsis) (apply (var "f") (var "b"))$parseTest parse'lambda "a: b: \"x\""3lambda (param "a") (lambda (param "b") (str ["x"]))Parser for a list expression ([ ... ]).parseTest parse'list "[]"list []/parseTest parse'list "[x \"one\" (a: b) (c d)]"Tlist [var "x", str ["one"], lambda (param "a") (var "b"), apply (var "c") (var "d")]0Parser for a dict expression, either recursive (rec keyword) or not.parseTest parse'dict "{}"dict []parseTest parse'dict "rec { }" rec'dict []:parseTest parse'dict "{ a = b; inherit (x) y z \"s t\"; }"Ndict [binding (str ["a"]) (var "b"), inherit'from (var "x") ["y", "z", "s t"]]Parser for a recursive (rec keyword) dict.parseTest parse'dict "rec { }" rec'dict []8parseTest parse'dict "rec { a = \"1\"; b = \"${a}2\"; }"`rec'dict [binding (str ["a"]) (str ["1"]), binding (str ["b"]) (str [antiquote (var "a"), "2"])]Parser for a non-recursive (no rec keyword) dict.parseTest parse'dict "{ }"dict []4parseTest parse'dict "{ a = \"1\"; b = \"${a}2\"; }"\dict [binding (str ["a"]) (str ["1"]), binding (str ["b"]) (str [antiquote (var "a"), "2"])])Parser for a chain of dict lookups (like .a.b.c) on the right-hand side of a < expression. parseTest parse'dot'rhs'chain ""[]$parseTest parse'dot'rhs'chain ".abc" [str ["abc"]]7parseTest parse'dot'rhs'chain ".a.${b}.\"c\".\"d${e}\""<[str ["a"],var "b",str ["c"],str ["d", antiquote (var "e")]]JThe primary, top-level expression parser. This is what you use to parse a .nix file.parseTest parse'expression """parse error at (line 1, column 1):unexpected end of inputexpecting expression4Parser for a list of expressions in a list literal ( [ x y z ]') or in a chain of function arguments (f x y z).!parseTest parse'expressionList ""[]HparseTest (length <$> parse'expressionList) "x \"one two\" (a: b) (c d)"4JparseTest (length <$> parse'expressionList) "(x \"one two\" (a: b) (c d))"14Parser for a single item within an expression list (expressionListP>). This expression is not a lambda, a function application, a let-in expression, or a with expression.(parseTest parse'expressionList'1 "ab.xy"dot (var "ab") (str ["xy"])1parseTest parse'expressionList'1 "(x: f x x) y z"@lambda (param "x") (apply (apply (var "f") (var "x")) (var "x"))1parseTest parse'expressionList'1 "{ a = b; }.a y"6dot (dict [binding (str ["a"]) (var "b")]) (str ["a"])Like D, but with the further restriction that the expression may not be a <..parseTest parse'expressionList'1'noDot "ab.xy"var "ab"7parseTest parse'expressionList'1'noDot "(x: f x x) y z"@lambda (param "x") (apply (apply (var "f") (var "x")) (var "x"))7parseTest parse'expressionList'1'noDot "{ a = b; }.a y"$dict [binding (str ["a"]) (var "b")]XParser for a parenthesized expression, from opening parenthesis to closing parenthesis. CParser for an expression in a context that is expecting a dict key.One of:an unquoted stringa quoted dynamic string/an arbitrary expression wrapped in antiquotes (${...}),h++,h None[<Insert escape sequences for rendering normal double-quoted (" ) strings.+Render an unquoted string in unquoted form.5Render a static string, in unquoted form if possible.'Render a static string, in quoted form.6Render a dynamic string, in unquoted form if possible.(Render a dynamic string, in quoted form.'Render one line of an indented string ().cRender a lambda parameter: everything from the beginning of a lambda, up to but not including the :6 that separates the head from the body of the lambda.Render a dict pattern ({ a, b ? c, ... }).Render a single item in a M.Render a lambda expression (x: y). *Render a function application expression (f x). Render a list literal ([ ... ]). Render a dict literal ({ ... }). Render a binding within a C!, without the trailing semicolon. Render a dot expression (a.b). Render a let-in expression.Render a binding within a 8!, without the trailing semicolon. Render a with expression.Render an expression.'Render an expression in a list context.?Render an expression in the context of the left-hand side of a <.@Render an expression in the context of the left-hand side of an U.ARender an expression in the context of the right-hand side of an U.                     None !"#$%&'()*+-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu     defghijklmc`ab]^_nop%&'()*+qrsGH CDEF @AB <=>?u YZ[\QRSTMNOPIJKLUVWXt 89:; !5671234"-./0#$i  !"##$%&'()'*+,-./0123456789:;<=>??@ABBCDEFGHHIJKKLMNOPQQRSTTUUVWXXYZ[\]^__`abbcdefghhijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( )*+,-+,.+,/ )0 )1 )2 )3 45 46 47 48 )9 ): ); )< = > ? @ A B CD CE )F )G )H+IJ+IK+IL+IM )N )O )P QR QS QT UV WX Y Z[ \] \^ \_ 4` ab ac )d )e )f )g+,h+,i+,j-klmnopqrst uv wx%bricks-0.0.0.1-HS776CPmiIfGy3noSNPU3KBricks.Internal.SeqBricks.Internal.TextBricks.Internal.PreludeBricks.KeywordBricks.UnquotedStringBricks.ExpressionBricks.Expression.ConstructionBricks.IndentedStringBricks.ParsingBricks.Rendering Paths_bricksBricksbase Data.FoldabletoListcontainers-0.5.7.1 Data.SequencefromListfilter dropWhileR dropWhileLnull|><| singletonemptySeq#text-1.2.2.2-KC7dWoG09dA1F6jKj5GSqh Data.Textunwords replicateallreplacepackData.Text.ShowunpackData.Text.InternalTextconcat intercalate intersperseminimummap<&>Keyword keywordTextkeywords keywordString keyword'rec keyword'let keyword'in keyword'withkeyword'inheritkeyword'inlineComment Str'UnquotedStr'Unquoted'Unsafestr'unquotedToStaticstr'tryUnquotedstr'unquoted'orThrowstr'canRenderUnquotedchar'canRenderUnquoted$fShowStr'UnquotedInheritinherit'source inherit'namesWith with'context with'value LetBinding LetBinding'EqLetBinding'InheritLet let'bindings let'valueDotdot'dictdot'key DictBindingDictBinding'EqDictBinding'InheritDictdict'rec dict'bindingsList DictPattern'1dictPattern'1'namedictPattern'1'default DictPatterndictPattern'itemsdictPattern'ellipsisParam Param'NameParam'DictPattern Param'BothApply apply'func apply'argLambda lambda'head lambda'bodyStr'1 Str'1'LiteralStr'1'Antiquote Str'DynamicstrDynamic'toSeq Str'Static ExpressionExpr'VarExpr'Str Expr'List Expr'DictExpr'Dot Expr'Lambda Expr'ApplyExpr'Let Expr'WithstrDynamic'toListstrDynamic'fromListstrDynamic'singletonstr'dynamicToStaticstr'staticToDynamicstr'unquotedToDynamicexpression'applyArgsexpression'applyDots$fShow'Inherit $fShow'With$fShow'LetBinding $fShow'Let $fShow'Apply$fShow'DictPattern'1$fShow'DictPattern $fShow'Param $fShow'Lambda $fShow'Dot$fShow'DictBinding $fShow'Dict $fShow'List $fShow'Str'1$fShow'Str'Dynamic$fShow'Expression $fShowInherit $fShowWith$fShowLetBinding $fShowLet $fShowApply$fShowDictPattern'1$fShowDictPattern $fShowParam $fShowLambda $fShowDot$fShowDictBinding $fShowDict $fShowList $fShowStr'1$fShowStr'Dynamic$fShowExpression $fMonoidList$fSemigroupList$fMonoidStr'Dynamic$fSemigroupStr'Dynamic Param'BuilderIsParamparamStr'1'unStr'1' IsInherit fromInheritBindingbindinglambdaapplyvardotlet'indictrec'dictinherit inherit'fromstr antiquote buildParam paramBuilderpatterndefellipsis mergeParamsmergeDictPatterns$fIsParamDictPattern'1$fIsParamParam'Builder$fIsStringStr'1'$fIsInheritLetBinding$fIsInheritDictBinding$fBindingTextLetBinding$fBindingExpressionDictBinding$fSemigroupParam'BuilderInStr'1 inStr'1'level inStr'1'strInStr inStr'toSeq inStr'toList inStr'joininStr'1'nonEmpty inStr'1'empty inStr'levelinStr'1'modifyLevel inStr'dedent inStr'trim $fShowInStr'1 $fShowInStr $fMonoidInStr$fSemigroupInStr parse'spaces parse'commentparse'comment'inlineparse'comment'block parse'keywordparse'strUnquotedparse'strStaticparse'strStatic'quotedparse'strStatic'unquotedparse'strDynamic'quotedparse'strDynamic'normalQparse'str'within'normalQparse'str'escape'normalQparse'strDynamic'indentedQ parse'inStr parse'inStr'1parse'antiquote parse'paramparse'param'varparse'param'noVarparse'dictPatternparse'dictPattern'start parse'lambda parse'list parse'dictparse'dict'recparse'dict'noRecparse'dot'rhs'chain parse'let parse'withparse'dictBindingparse'dictBinding'inheritparse'dictBinding'eqparse'letBindingparse'letBinding'eqparse'letBinding'inherit parse'inheritparse'expressionparse'expressionListparse'expressionList'1parse'expressionList'1'noDotparse'expression'parenparse'expression'dictKeyRender str'escaperender'strUnquoted#render'strStatic'unquotedIfPossiblerender'strStatic'quoted$render'strDynamic'unquotedIfPossiblerender'strDynamic'quotedrender'inStr'1 render'paramrender'dictPatternrender'dictPattern'1 render'lambda render'apply render'list render'dictrender'dictBinding render'dot render'letrender'letBindingrender'inherit render'withrender'expressionrender'expression'listContext render'expression'dotLeftContext"render'expression'applyLeftContext#render'expression'applyRightContextrender'expression'inParensrender'expression'dictKeycatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameGHC.Base$ghc-prim GHC.ClassesEq==/=>>=Functorfmap<$GHC.ShowShow showsPrecshowshowListpure<*>*><*foldrfoldMapfoldlfoldl1foldr1foldData.Semigroup Semigroup<>Monoidmemptymappend GHC.TypesBoolFalseTrueCharMaybeNothingJust Data.EitherEitherLeftRight GHC.NaturalNaturalControl.Category>>>asum Data.Function& Data.Functorvoid$><$>shows Data.Maybe catMaybesmaybe.id<|>String&&||notShow'show' showsPrec' show'list show'list' show'quoted' show'paren show'static show'paramshow'var Data.StringIsString parse'count