[{"name":"MultiTool","comment":" **Fun fact**: The type annotations for the functions in this package are\npretty horrifying.\n\n**Hot tip**: Ignore them! There's no need to put any of these functions, or the\ntools they produce, in your application's `Msg` or `Model` type. So you don't\nneed to know or care about what their type signatures are. Just read the docs\nand look at the examples. It'll be fine.\\*\n\n\\* Unless you make any kind of minor typo in your code, in which case the Elm\ncompiler may respond with a Lovecraftian error message 😱.\n\n@docs define, Builder\n\n@docs add\n\n@docs end, ToolSpec\n\n","unions":[{"name":"Builder","comment":" A data structure produced by `define`, used to create MultiTools\n","args":["a"],"cases":[]},{"name":"ToolSpec","comment":" A tool specification - the basic building block for creating tools for the\ntypes in your application.\n","args":["toolSpec"],"cases":[]}],"aliases":[],"values":[{"name":"add","comment":"\n\n\n### `add`\n\nAdd a tool to your MultiTool.\n\nThis function takes three arguments. The first is a field accessor, which should\nmatch one of the fields of the record constructor you passed to\n`MultiTool.define`. For example: `.codec`.\n\nThe second is a tool interface - a record whose fields contain all the functions\nwe will need to make the tool work. Here's an example of an interface for the\nawesome `miniBill/elm-codec` package:\n\n    import Codec\n\n    codecInterface =\n        { string = Codec.string\n        , int = Codec.int\n        , bool = Codec.bool\n        , float = Codec.float\n        , char = Codec.char\n        , list = Codec.list\n        , maybe = Codec.maybe\n        , array = Codec.array\n        , dict =\n            \\k v ->\n                Codec.tuple k v\n                    |> Codec.list\n                    |> Codec.map Dict.fromList Dict.toList\n        , set = Codec.set\n        , tuple = Codec.tuple\n        , triple = Codec.triple\n        , result = Codec.result\n        , record = Codec.object\n        , field = Codec.field\n        , endRecord = Codec.buildObject\n        , customType = Codec.custom\n        , variant0 = Codec.variant0\n        , variant1 = Codec.variant1\n        , variant2 = Codec.variant2\n        , variant3 = Codec.variant3\n        , variant4 = Codec.variant4\n        , variant5 = Codec.variant5\n        , endCustomType = Codec.buildCustom\n        }\n\n(You'll notice that this interface type mostly looks straightforward, except for\nthe `dict` field. The problem here is that we need a `Dict` implementation that\ncan take any `comparable` as a key, but `elm-codec`'s built-in `dict` function\nonly accepts `String`s as keys. Fortunately, we can build the function we need\nusing `elm-codec`'s lower-level primitives.)\n\nThe third and final argument is the `MultiTool.Builder` that you've already\ncreated using `define`. The API here is designed for piping with the `|>`\noperator, so you'll usually want to apply this final argument like this:\n\n    tools =\n        MultiTool.define Tools Tools\n            |> MultiTool.add .codec codecInterface\n\n","type":"(customDestructor -> c) -> { array : thisA7 -> thisB7, bool : a5, char : a4, customType : c -> customBuilder7, dict : thisA6 -> thisB6 -> thisC4, endCustomType : customBuilder8 -> customTypeSpec, endRecord : recordBuilder1 -> recordSpec, field : String.String -> getField -> fieldTool -> recordBuilder3 -> recordBuilder2, float : a3, int : a2, list : thisA5 -> thisB5, maybe : thisA4 -> thisB4, record : recordConstructor -> recordBuilder, result : thisA3 -> thisB3 -> thisC3, set : thisA2 -> thisB2, string : a1, triple : thisA1 -> thisB1 -> thisC2 -> thisD, tuple : thisA -> thisB -> thisC1, variant0 : String.String -> variantConstructor5 -> customBuilder6 -> customBuilder2_5, variant1 : String.String -> variantConstructor4 -> arg1Tool4 -> customBuilder5 -> customBuilder2_4, variant2 : String.String -> variantConstructor3 -> arg1Tool3 -> arg2Tool3 -> customBuilder4 -> customBuilder2_3, variant3 : String.String -> variantConstructor2 -> arg1Tool2 -> arg2Tool2 -> arg3Tool2 -> customBuilder3 -> customBuilder2_2, variant4 : String.String -> variantConstructor1 -> arg1Tool1 -> arg2Tool1 -> arg3Tool1 -> arg4Tool1 -> customBuilder1 -> customBuilder2_1, variant5 : String.String -> variantConstructor -> arg1Tool -> arg2Tool -> arg3Tool -> arg4Tool -> arg5Tool -> customBuilder -> customBuilder2 } -> MultiTool.Builder { after : e, afters : f, applyTweakFn : g -> restA8 -> restB8 -> restC4, arrayMaker : (( thisA7, restA7 ) -> ( thisB7, restB7 )) -> h, before : ( Maybe.Maybe mapper, after ) -> tweakFns, bool : ( a5, b4 ) -> i, char : ( a4, b3 ) -> j, customEnder : (( customBuilder8, restCustomBuilders8 ) -> ( customTypeSpec, restCustomTypeSpecs )) -> k, customMaker : (customDestructor -> ( customBuilder7, restCustomBuilders7 )) -> l, dictMaker : (( thisA6, restA6 ) -> ( thisB6, restB6 ) -> ( thisC4, restC3 )) -> m, fieldMaker : (String.String -> getField -> ( fieldTool, restFieldTools ) -> ( recordBuilder3, restRecordBuilders2 ) -> ( recordBuilder2, restRecordBuilder2s )) -> n, float : ( a3, b2 ) -> o, int : ( a2, b1 ) -> p, listMaker : (( thisA5, restA5 ) -> ( thisB5, restB5 )) -> q, maybeMaker : (( thisA4, restA4 ) -> ( thisB4, restB4 )) -> r, recordEnder : (( recordBuilder1, restRecordBuilders1 ) -> ( recordSpec, restRecordSpecs )) -> s, recordMaker : (recordConstructor -> ( recordBuilder, restRecordBuilders )) -> t, resultMaker : (( thisA3, restA3 ) -> ( thisB3, restB3 ) -> ( thisC3, restC2 )) -> u, setMaker : (( thisA2, restA2 ) -> ( thisB2, restB2 )) -> v, string : ( a1, b ) -> w, toolConstructor : x, toolMaker : y -> multiToolConstructor -> restTools -> multiTool, tripleMaker : (( thisA1, restA1 ) -> ( thisB1, restB1 ) -> ( thisC2, restC1 ) -> ( thisD, restD )) -> z, tupleMaker : (( thisA, restA ) -> ( thisB, restB ) -> ( thisC1, restC )) -> c1, tweakConstructor : d1, tweakMaker : (((mapper -> MultiTool.ToolSpec tool -> MultiTool.ToolSpec tool) -> tweakConstructor) -> ((() -> () -> ()) -> tweakFns -> tool -> tool) -> ( after, restAfters ) -> tweak) -> e1, variant0Maker : (String.String -> variantConstructor5 -> ( customBuilder6, restCustomBuilders6 ) -> ( customBuilder2_5, restCustomBuilders2_5 )) -> f1, variant1Maker : (String.String -> variantConstructor4 -> ( arg1Tool4, restArg1Tools4 ) -> ( customBuilder5, restCustomBuilders5 ) -> ( customBuilder2_4, restCustomBuilders2_4 )) -> g1, variant2Maker : (String.String -> variantConstructor3 -> ( arg1Tool3, restArg1Tools3 ) -> ( arg2Tool3, restArg2Tools3 ) -> ( customBuilder4, restCustomBuilders4 ) -> ( customBuilder2_3, restCustomBuilders2_3 )) -> h1, variant3Maker : (String.String -> variantConstructor2 -> ( arg1Tool2, restArg1Tools2 ) -> ( arg2Tool2, restArg2Tools2 ) -> ( arg3Tool2, restArg3Tools2 ) -> ( customBuilder3, restCustomBuilders3 ) -> ( customBuilder2_2, restCustomBuilders2_2 )) -> i1, variant4Maker : (String.String -> variantConstructor1 -> ( arg1Tool1, restArg1Tools1 ) -> ( arg2Tool1, restArg2Tools1 ) -> ( arg3Tool1, restArg3Tools1 ) -> ( arg4Tool1, restArg4Tools1 ) -> ( customBuilder1, restCustomBuilders1 ) -> ( customBuilder2_1, restCustomBuilders2_1 )) -> j1, variant5Maker : (String.String -> variantConstructor -> ( arg1Tool, restArg1Tools ) -> ( arg2Tool, restArg2Tools ) -> ( arg3Tool, restArg3Tools ) -> ( arg4Tool, restArg4Tools ) -> ( arg5Tool, restArg5Tools ) -> ( customBuilder, restCustomBuilders ) -> ( customBuilder2, restCustomBuilders2 )) -> k1 } -> MultiTool.Builder { after : ( Maybe.Maybe a, e ), afters : ( e, f ), applyTweakFn : g -> ( Maybe.Maybe (thisC -> thisC), restA8 ) -> ( thisC, restB8 ) -> ( thisC, restC4 ), arrayMaker : (restA7 -> restB7) -> h, before : after -> tweakFns, bool : b4 -> i, char : b3 -> j, customEnder : (restCustomBuilders8 -> restCustomTypeSpecs) -> k, customMaker : (customDestructor -> restCustomBuilders7) -> l, dictMaker : (restA6 -> restB6 -> restC3) -> m, fieldMaker : (String.String -> getField -> restFieldTools -> restRecordBuilders2 -> restRecordBuilder2s) -> n, float : b2 -> o, int : b1 -> p, listMaker : (restA5 -> restB5) -> q, maybeMaker : (restA4 -> restB4) -> r, recordEnder : (restRecordBuilders1 -> restRecordSpecs) -> s, recordMaker : (recordConstructor -> restRecordBuilders) -> t, resultMaker : (restA3 -> restB3 -> restC2) -> u, setMaker : (restA2 -> restB2) -> v, string : b -> w, toolConstructor : x, toolMaker : y -> (tool1 -> multiToolConstructor) -> ( tool1, restTools ) -> multiTool, tripleMaker : (restA1 -> restB1 -> restC1 -> restD) -> z, tupleMaker : (restA -> restB -> restC) -> c1, tweakConstructor : d1, tweakMaker : (tweakConstructor -> ((() -> () -> ()) -> tweakFns -> tool -> tool) -> restAfters -> tweak) -> e1, variant0Maker : (String.String -> variantConstructor5 -> restCustomBuilders6 -> restCustomBuilders2_5) -> f1, variant1Maker : (String.String -> variantConstructor4 -> restArg1Tools4 -> restCustomBuilders5 -> restCustomBuilders2_4) -> g1, variant2Maker : (String.String -> variantConstructor3 -> restArg1Tools3 -> restArg2Tools3 -> restCustomBuilders4 -> restCustomBuilders2_3) -> h1, variant3Maker : (String.String -> variantConstructor2 -> restArg1Tools2 -> restArg2Tools2 -> restArg3Tools2 -> restCustomBuilders3 -> restCustomBuilders2_2) -> i1, variant4Maker : (String.String -> variantConstructor1 -> restArg1Tools1 -> restArg2Tools1 -> restArg3Tools1 -> restArg4Tools1 -> restCustomBuilders1 -> restCustomBuilders2_1) -> j1, variant5Maker : (String.String -> variantConstructor -> restArg1Tools -> restArg2Tools -> restArg3Tools -> restArg4Tools -> restArg5Tools -> restCustomBuilders -> restCustomBuilders2) -> k1 }"},{"name":"define","comment":"\n\n\n### `define`\n\nBegin creating a new MultiTool.\n\nThis function takes two identical arguments. Both arguments should be a function\nthat constructs a record with a field for each of the tools you intend to\ninclude in your MultiTool.\n\nFor example, if you want to combine a `ToString` tool and a `ToComparable` tool,\nyou could do something like this:\n\n    import ToComparable\n    import ToString\n\n    type alias Tools toString toComparable =\n        { toString : toString\n        , toComparable : toComparable\n        }\n\n    tools =\n        MultiTool.define Tools Tools\n            |> MultiTool.add\n                .toString\n                ToString.interface\n            |> MultiTool.add\n                .toComparable\n                ToComparable.interface\n            |> MultiTool.end\n\n**Note**: The order of the type parameters in the `Tools` type alias is\nimportant. It needs to match the order in which you add the tool interfaces with\n`MultiTool.add`.\n\nIn this example, we see that `toString` comes first and `toComparable` comes\nsecond in _both_ the `Tools` type alias and the interfaces added to `tools`.\n\n","type":"toolConstructor -> tweakConstructor -> MultiTool.Builder { after : (), afters : (), applyTweakFn : applyTweakFn -> applyTweakFn, arrayMaker : arrayMaker -> arrayMaker, before : before -> before, bool : bool -> bool, char : char -> char, toolMaker : toolMaker -> toolMaker, customEnder : customEnder -> customEnder, customMaker : customMaker -> customMaker, dictMaker : dictMaker -> dictMaker, fieldMaker : fieldMaker -> fieldMaker, float : float -> float, int : int -> int, listMaker : listMaker -> listMaker, maybeMaker : maybeMaker -> maybeMaker, recordEnder : recordEnder -> recordEnder, recordMaker : recordMaker -> recordMaker, resultMaker : resultMaker -> resultMaker, setMaker : setMaker -> setMaker, string : string -> string, toolConstructor : toolConstructor, tripleMaker : tripleMaker -> tripleMaker, tupleMaker : tupleMaker -> tupleMaker, tweakConstructor : tweakConstructor, tweakMaker : tweakMaker -> tweakMaker, variant0Maker : variant0Maker -> variant0Maker, variant1Maker : variant1Maker -> variant1Maker, variant2Maker : variant2Maker -> variant2Maker, variant3Maker : variant3Maker -> variant3Maker, variant4Maker : variant4Maker -> variant4Maker, variant5Maker : variant5Maker -> variant5Maker }"},{"name":"end","comment":"\n\n\n### `end`\n\nComplete the definition of a MultiTool.\n\n    tools =\n        MultiTool.define Tools Tools\n            |> MultiTool.add\n                .toString\n                ToString.interface\n            |> MultiTool.add\n                .toComparable\n                ToComparable.interface\n            |> MultiTool.end\n\nThis function converts a `MultiTool.Builder` into a record that contains all the\nfunctions you'll need to create tool specifications (`ToolSpec`s) for the types\nin your application. If you define a MultiTool like `tools` in the example\nabove, it'll give you access to the following `ToolSpecs` and helper functions:\n\n\n## `ToolSpec`s for primitive types\n\nWe've got `tools.bool`, `tools.string`, `tools.int`, `tools.float`, and\n`tools.char`.\n\nFor example:\n\n    boolTool =\n        tools.build tools.bool\n\n    trueFact =\n        boolTool.toString True == \"True\"\n\n\n## `ToolSpec`s for common combinators\n\nWe've got `tools.maybe`, `tools.result`, `tools.list`, `tools.array`,\n`tools.dict`, `tools.set`, `tools.tuple`, _and_ `tools.triple`.\n\nFor example:\n\n    listBoolSpec =\n        tools.list tools.bool\n\n    tupleIntStringSpec =\n        tools.tuple tools.int tools.string\n\n\n## `ToolSpec`s for combinators for custom types\n\nTo define `ToolSpec`s for your own custom types, use `tools.customType`,\n`tools.variant0`, `tools.variant1`, `tools.variant2`, `tools.variant3`,\n`tools.variant4`, `tools.variant5`, and `tools.endCustomType`.\n\nFor example, if we really hated Elm's `Maybe` type and wanted it to be called\n`Option` instead:\n\n    type Option value\n        = Some value\n        | None\n\n    optionSpec valueSpec =\n        let\n            match some none variant =\n                case variant of\n                    Some value ->\n                        some value\n\n                    None ->\n                        none\n        in\n        tools.customType\n            { toString = match, toComparable = match }\n            |> tools.variant1 \"Some\" Some valueSpec\n            |> tools.variant0 \"None\" None\n            |> tools.endCustomType\n\n**Note**: You _must_ define the `match` function either in a `let-in` block\nwithin your tool specification, or as a top-level function in one of your\nmodules. If you try and parameterise your tool specification to take a `match`\nfunction as one of its arguments, it won't work - you'll get a compiler error.\n\nThe explanation for this is a bit beyond me, but I think it goes: \"something\nsomething `forall`, something something let-polymorphism.\"\n\n\n## `ToolSpec`s for combinators for records\n\nFor records (and indeed any kind of \"product\" type), check out `tools.record`,\n`tools.field`, and `tools.endRecord`.\n\nFor example:\n\n    type alias User =\n        { name : String, age : Int }\n\n    userToolSpec =\n        tools.record User\n            |> tools.field \"name\" .name tools.string\n            |> tools.field \"age\" .age tools.int\n            |> tools.endRecord\n\n\n## Converting a `ToolSpec` into a usable tool\n\n`tools.build` turns a `ToolSpec` into a usable tool.\n\nFor example:\n\n    userTool =\n        tools.build userToolSpec\n\n    user =\n        { name = \"Ed\", age = 41 }\n\n    trueFact =\n        userTool.toString user\n            == \"{ name = \\\"Ed\\\", age = 41 }\"\n\n\n## Customising a `ToolSpec`\n\n`tools.tweak` allows you to alter (or replace) the tools contained within a\n`ToolSpec`.\n\nFor example, if you're using `edkelly303/elm-any-type-forms`, you could\ncustomise the `tools.string` and `tools.int` `ToolSpec`s like this:\n\n    import Control\n\n    myIntSpec =\n        tools.int\n            |> tools.tweak.control\n                (Control.failIf\n                    (\\int -> int < 0)\n                    \"Must be greater than or equal to 0\"\n                )\n\n    myStringSpec =\n        tools.string\n            |> tools.tweak.control\n                (\\_ ->\n                    -- throw away whatever control we\n                    -- had in tools.string, and use\n                    -- this instead:\n                    Control.string\n                        |> Control.debounce 1000\n                )\n\n","type":"MultiTool.Builder { after : after, afters : afters, applyTweakFn : applyTweakFn, arrayMaker : (() -> ()) -> ( thisA7, restA7 ) -> ( thisB7, restB7 ), before : before, bool : () -> toolSpec4, char : () -> toolSpec3, customEnder : (() -> ()) -> customBuilder7 -> customTypeSpec, customMaker : (customDestructor -> ()) -> customDestructor -> ( customBuilder8, restCustomBuilders7 ), dictMaker : (() -> () -> ()) -> ( thisA6, restA6 ) -> ( thisB6, restB6 ) -> ( thisC3, restC3 ), fieldMaker : (String.String -> getField -> () -> () -> ()) -> String.String -> getField -> fieldSpec -> ( recordBuilder1, restRecordBuilders1 ) -> ( recordBuilder2, restRecordBuilder2s ), float : () -> toolSpec2, int : () -> toolSpec1, listMaker : (() -> ()) -> ( thisA5, restA5 ) -> ( thisB5, restB5 ), maybeMaker : (() -> ()) -> ( thisA4, restA4 ) -> ( thisB4, restB4 ), recordEnder : (() -> ()) -> ( recordBuilder3, restRecordBuilders2 ) -> ( recordSpec, restRecordSpecs ), recordMaker : (recordConstructor -> ()) -> recordConstructor -> ( recordBuilder, restRecordBuilders ), resultMaker : (() -> () -> ()) -> ( thisA3, restA3 ) -> ( thisB3, restB3 ) -> ( thisC2, restC2 ), setMaker : (() -> ()) -> ( thisA2, restA2 ) -> ( thisB2, restB2 ), string : () -> toolSpec, toolConstructor : toolConstructor, toolMaker : (multiTool -> () -> multiTool) -> toolConstructor -> ( tool, restTools ) -> multiTool, tripleMaker : (() -> () -> () -> ()) -> ( thisA1, restA1 ) -> ( thisB1, restB1 ) -> ( thisC1, restC1 ) -> ( thisD, restD ), tupleMaker : (() -> () -> ()) -> ( thisA, restA ) -> ( thisB, restB ) -> ( thisC, restC ), tweakConstructor : tweakConstructor, tweakMaker : (tweak -> applyTweakFn -> () -> tweak) -> tweakConstructor -> applyTweakFn -> afters -> tweak, variant0Maker : (String.String -> variantConstructor5 -> () -> ()) -> String.String -> variantConstructor5 -> ( customBuilder6, restCustomBuilders6 ) -> ( customBuilder2_5, restCustomBuilders2_5 ), variant1Maker : (String.String -> variantConstructor4 -> () -> () -> ()) -> String.String -> variantConstructor4 -> ( arg1Tool4, restArg1Tools4 ) -> ( customBuilder5, restCustomBuilders5 ) -> ( customBuilder2_4, restCustomBuilders2_4 ), variant2Maker : (String.String -> variantConstructor3 -> () -> () -> () -> ()) -> String.String -> variantConstructor3 -> ( arg1Tool3, restArg1Tools3 ) -> ( arg2Tool3, restArg2Tools3 ) -> ( customBuilder4, restCustomBuilders4 ) -> ( customBuilder2_3, restCustomBuilders2_3 ), variant3Maker : (String.String -> variantConstructor2 -> () -> () -> () -> () -> ()) -> String.String -> variantConstructor2 -> ( arg1Tool2, restArg1Tools2 ) -> ( arg2Tool2, restArg2Tools2 ) -> ( arg3Tool2, restArg3Tools2 ) -> ( customBuilder3, restCustomBuilders3 ) -> ( customBuilder2_2, restCustomBuilders2_2 ), variant4Maker : (String.String -> variantConstructor1 -> () -> () -> () -> () -> () -> ()) -> String.String -> variantConstructor1 -> ( arg1Tool1, restArg1Tools1 ) -> ( arg2Tool1, restArg2Tools1 ) -> ( arg3Tool1, restArg3Tools1 ) -> ( arg4Tool1, restArg4Tools1 ) -> ( customBuilder1, restCustomBuilders1 ) -> ( customBuilder2_1, restCustomBuilders2_1 ), variant5Maker : (String.String -> variantConstructor -> () -> () -> () -> () -> () -> () -> ()) -> String.String -> variantConstructor -> ( arg1Tool, restArg1Tools ) -> ( arg2Tool, restArg2Tools ) -> ( arg3Tool, restArg3Tools ) -> ( arg4Tool, restArg4Tools ) -> ( arg5Tool, restArg5Tools ) -> ( customBuilder, restCustomBuilders ) -> ( customBuilder2, restCustomBuilders2 ) } -> { array : MultiTool.ToolSpec ( thisA7, restA7 ) -> MultiTool.ToolSpec ( thisB7, restB7 ), bool : MultiTool.ToolSpec toolSpec4, build : MultiTool.ToolSpec ( tool, restTools ) -> multiTool, char : MultiTool.ToolSpec toolSpec3, customType : customDestructor -> ( customBuilder8, restCustomBuilders7 ), dict : MultiTool.ToolSpec ( thisA6, restA6 ) -> MultiTool.ToolSpec ( thisB6, restB6 ) -> MultiTool.ToolSpec ( thisC3, restC3 ), endCustomType : customBuilder7 -> MultiTool.ToolSpec customTypeSpec, endRecord : ( recordBuilder3, restRecordBuilders2 ) -> MultiTool.ToolSpec ( recordSpec, restRecordSpecs ), field : String.String -> getField -> MultiTool.ToolSpec fieldSpec -> ( recordBuilder1, restRecordBuilders1 ) -> ( recordBuilder2, restRecordBuilder2s ), float : MultiTool.ToolSpec toolSpec2, int : MultiTool.ToolSpec toolSpec1, list : MultiTool.ToolSpec ( thisA5, restA5 ) -> MultiTool.ToolSpec ( thisB5, restB5 ), maybe : MultiTool.ToolSpec ( thisA4, restA4 ) -> MultiTool.ToolSpec ( thisB4, restB4 ), record : recordConstructor -> ( recordBuilder, restRecordBuilders ), result : MultiTool.ToolSpec ( thisA3, restA3 ) -> MultiTool.ToolSpec ( thisB3, restB3 ) -> MultiTool.ToolSpec ( thisC2, restC2 ), set : MultiTool.ToolSpec ( thisA2, restA2 ) -> MultiTool.ToolSpec ( thisB2, restB2 ), string : MultiTool.ToolSpec toolSpec, triple : MultiTool.ToolSpec ( thisA1, restA1 ) -> MultiTool.ToolSpec ( thisB1, restB1 ) -> MultiTool.ToolSpec ( thisC1, restC1 ) -> MultiTool.ToolSpec ( thisD, restD ), tuple : MultiTool.ToolSpec ( thisA, restA ) -> MultiTool.ToolSpec ( thisB, restB ) -> MultiTool.ToolSpec ( thisC, restC ), tweak : tweak, variant0 : String.String -> variantConstructor5 -> ( customBuilder6, restCustomBuilders6 ) -> ( customBuilder2_5, restCustomBuilders2_5 ), variant1 : String.String -> variantConstructor4 -> MultiTool.ToolSpec ( arg1Tool4, restArg1Tools4 ) -> ( customBuilder5, restCustomBuilders5 ) -> ( customBuilder2_4, restCustomBuilders2_4 ), variant2 : String.String -> variantConstructor3 -> MultiTool.ToolSpec ( arg1Tool3, restArg1Tools3 ) -> MultiTool.ToolSpec ( arg2Tool3, restArg2Tools3 ) -> ( customBuilder4, restCustomBuilders4 ) -> ( customBuilder2_3, restCustomBuilders2_3 ), variant3 : String.String -> variantConstructor2 -> MultiTool.ToolSpec ( arg1Tool2, restArg1Tools2 ) -> MultiTool.ToolSpec ( arg2Tool2, restArg2Tools2 ) -> MultiTool.ToolSpec ( arg3Tool2, restArg3Tools2 ) -> ( customBuilder3, restCustomBuilders3 ) -> ( customBuilder2_2, restCustomBuilders2_2 ), variant4 : String.String -> variantConstructor1 -> MultiTool.ToolSpec ( arg1Tool1, restArg1Tools1 ) -> MultiTool.ToolSpec ( arg2Tool1, restArg2Tools1 ) -> MultiTool.ToolSpec ( arg3Tool1, restArg3Tools1 ) -> MultiTool.ToolSpec ( arg4Tool1, restArg4Tools1 ) -> ( customBuilder1, restCustomBuilders1 ) -> ( customBuilder2_1, restCustomBuilders2_1 ), variant5 : String.String -> variantConstructor -> MultiTool.ToolSpec ( arg1Tool, restArg1Tools ) -> MultiTool.ToolSpec ( arg2Tool, restArg2Tools ) -> MultiTool.ToolSpec ( arg3Tool, restArg3Tools ) -> MultiTool.ToolSpec ( arg4Tool, restArg4Tools ) -> MultiTool.ToolSpec ( arg5Tool, restArg5Tools ) -> ( customBuilder, restCustomBuilders ) -> ( customBuilder2, restCustomBuilders2 ) }"}],"binops":[]}]