[{"name":"Control","comment":"\n\n\n# Creating a form\n\n@docs Control, Form, sandbox, simpleForm, form\n\n\n# Basic controls\n\n@docs bool, int, float, string, char, enum\n\n\n# Basic combinators\n\n@docs tuple, triple, maybe, result, list, dict, set, array, map\n\n\n# Creating a new control\n\n@docs ControlConfig, create\n\n\n# Validating controls\n\n\n## Simple validation\n\n@docs failIf, noteIf\n\n\n## Multi-field validation\n\nYou may want display errors on one or more controls based on the validation of\nanother control higher up the tree.\n\nTake the example of a password creation form. You want to validate that the\n\"Enter password\" and \"Confirm password\" fields both contain the same string, and\nshow a helpful error message on the \"Confirm password\" field if they don't. You\ncan achieve this as follows:\n\n    passwordControl =\n        record\n            (\\password confirmation ->\n                { password = password\n                , confirmation = confirmation\n                }\n            )\n            |> field string\n            |> field\n                (string\n                    |> respond\n                        { alert = \"passwords-do-not-match\"\n                        , fail = True\n                        , message = \"Must match 'Enter password' field\"\n                        }\n                )\n            |> endRecord\n            |> alertIf\n                (\\{ password, confirmation } ->\n                    password /= confirmation\n                )\n                \"passwords-do-not-match\"\n\n@docs alertIf, respond\n\n\n## List validation\n\n@docs alertAtIndexes\n\n\n# Configuring controls\n\n@docs default, debounce, id, name, label, class, classList, wrapView\n\n\n# Building record combinators\n\n@docs RecordBuilder, record, field, endRecord, LayoutConfig, Subcontrol, layout\n\n\n# Building custom type combinators\n\n@docs CustomTypeBuilder, customType, tag0, tag1, tag2, tag3, tag4, tag5, endCustomType\n\n\n# Form internals\n\nThese are types that you will see in your form's `State` and `Delta` type signatures.\n\n@docs State, Delta, ListDelta, End\n\n\n# Internal stuff that you can ignore\n\nA user of this package shouldn't need to know about any of these types -\nthey are only exposed to make it possible to write type signatures.\n\n@docs AdvancedControl, ControlFns, Alert, RecordFns, Status, InternalViewConfig, Path, Feedback\n\n","unions":[{"name":"AdvancedControl","comment":" A slightly more flexible version of `Control`\n","args":["input","state","delta","output"],"cases":[]},{"name":"Alert","comment":" Some internal stuff needed to handle validations\n","args":[],"cases":[]},{"name":"ControlFns","comment":" Some internal stuff needed to build up record and custom type controls\n","args":["input","state","delta","output"],"cases":[]},{"name":"CustomTypeBuilder","comment":" A data structure used to build custom types\n","args":["applyInputs","debouncingReceiverCollector","deltaAfter","deltaAfters","deltaBefore","deltaBefores","destructor","errorCollector","alertEmitter","fns","idleSetter","initialDeltas","initialStates","initialiseDeltas","makeDeltaSetters","makeStateSetters","parser","stateAfter","stateAfters","stateBefore","stateBefores","stateInserter","subscriptionCollector","toArgStates","updater","viewer"],"cases":[]},{"name":"Delta","comment":" A `Delta` is the form's equivalent of an Elm program's `Msg` type. It is\nused internally within a form to update its state.\n","args":["delta"],"cases":[]},{"name":"End","comment":" Under the hood, this library encodes complex Elm types (such as records and\ncustom types) as nested tuples, which are used in both the `State` and `Delta`\ntypes for each `Control`. The `End` type is used to mark the end of a nested\ntuple.\n\nFor example, the `State` for this Elm type:\n\n    type alias User =\n        { name : String, age : Int }\n\nCould be encoded as:\n\n    ( String, ( Int, End ) )\n\n","args":[],"cases":[]},{"name":"ListDelta","comment":" Special `Delta` type used only by `list` controls\n","args":["delta"],"cases":[]},{"name":"RecordBuilder","comment":" A data structure used to build records\n","args":["after","afters","before","befores","debouncingReceiverCollector","deltaInitialiser","errorCollector","alertEmitter","fns","idleSetter","initialDeltas","initialStates","initialiser","makeSetters","parser","subscriptionCollector","toOutput","updater","viewer"],"cases":[]},{"name":"RecordFns","comment":" Some internal stuff needed to build up a record control\n","args":["input","state","delta","output","recordOutput"],"cases":[]},{"name":"State","comment":" `State` is the form's equivalent of an Elm program's `Model` type. It is\nused to manage the form's internal state.\n","args":["state"],"cases":[]},{"name":"Status","comment":" an internal type needed to represent the validation state of a control\n","args":[],"cases":[]}],"aliases":[{"name":"Control","comment":" A `Control` is the basic unit from which forms are composed. This library\nprovides various example controls and combinators that you can use to build a\nform for any arbitrarily complex Elm type.\n","args":["state","delta","output"],"type":"Control.AdvancedControl output state delta output"},{"name":"ControlConfig","comment":" Configuration for a custom control. You need to supply the following fields:\n\n  - `initEmpty`: a default initial \"empty\" value for the `state` of the control. For a control whose `state` is of type `String`, this might be `\"\"`, for a number it might be `0`.\n  - `initPrefilled`: a function that initialises the control's `state` from a value of the control's `output` type. For a control that outputs an `Int`, but whose `state` is a `String`, this might be `String.fromInt`.\n  - `update`: a function that updates the `state` of the control based on its existing `state` and a `delta` type that it receives. This is exactly analogous to an Elm program's update function, where `state` = `Model` and `delta` = `Msg`.\n  - `view`: a function that outputs `Html delta` based on the `state` of the control. This is similar to an Elm program's view function, except instead of just taking the `state` as an argument, it takes a record containing the `state` plus the id, name, class, and label for the input.\n  - `subscriptions`: a function that outputs `Sub delta` based on the `state` of the control. This is exactly analogous to an Elm program's subscriptions function.\n  - `parse`: a function that attempts to parse the control's state into its output type, producing a result. If parsing fails, it can provide a list of errors.\n\n","args":["state","delta","output"],"type":"{ blank : ( state, Platform.Cmd.Cmd delta ), prefill : output -> ( state, Platform.Cmd.Cmd delta ), update : delta -> state -> ( state, Platform.Cmd.Cmd delta ), view : { label : String.String, id : String.String, name : String.String, class : String.String, state : state } -> List.List (Html.Html delta), subscriptions : state -> Platform.Sub.Sub delta, parse : state -> Result.Result (List.List String.String) output, label : String.String }"},{"name":"Feedback","comment":" Some internal stuff to handle validation\n","args":[],"type":"{ path : Control.Path, label : String.String, message : String.String, fail : Basics.Bool }"},{"name":"Form","comment":" A `Form` is an interface containing functions that you can use in your\nElm `Program` to initialise, view, update, subscribe, and submit your form.\n","args":["state","delta","output","msg"],"type":"{ blank : ( Control.State state, Platform.Cmd.Cmd msg ), prefill : output -> ( Control.State state, Platform.Cmd.Cmd msg ), update : Control.Delta delta -> Control.State state -> ( Control.State state, Platform.Cmd.Cmd msg ), view : Control.State state -> Html.Html msg, subscriptions : Control.State state -> Platform.Sub.Sub msg, submit : Control.State state -> ( Control.State state, Result.Result (List.List Control.Feedback) output ) }"},{"name":"InternalViewConfig","comment":" Some internal stuff needed to view controls\n","args":["state"],"type":"{ state : state, status : Control.Status, alerts : List.List Control.Alert, selected : Basics.Int, name : String.String, id : String.String, label : String.String, class : List.List String.String }"},{"name":"LayoutConfig","comment":" Configuration for the `layout` function\n","args":["delta"],"type":"{ selected : Basics.Int, selectMsg : Basics.Int -> Control.Delta delta, id : String.String, label : String.String, class : String.String }"},{"name":"Path","comment":" an internal type needed to track the position of a control within a tree of\ncontrols\n","args":[],"type":"Path.Path"},{"name":"Subcontrol","comment":" Data used by the `layout` function to render a subcontrol of a combinator.\n","args":["delta"],"type":"{ html : List.List (Html.Html (Control.Delta delta)), label : String.String, index : Basics.Int }"}],"values":[{"name":"alertAtIndexes","comment":" Conditionally display an error on one or more items in a `list` control,\nbased on the output of the `list` control.\n\nThe following example will display errors on the first two items in a list of\nstrings, if and only if those first two items are \"hello\" and \"world\":\n\n    myString =\n        string\n            |> catch\n                { alert = \"no-hello-world\"\n                , fail = True\n                , message = \"The first two items in the list must not be \\\"hello\\\" and \\\"world\\\".\"\n                }\n\n    myList =\n        list myString\n            |> alertAtIndexes\n                (\\list_ ->\n                    case list of\n                        \"hello\" :: \"world\" :: _ ->\n                            [ 0, 1 ]\n\n                        _ ->\n                            []\n                )\n                \"no-hello-world\"\n\n","type":"(output -> List.List Basics.Int) -> String.String -> Control.Control (List.List state) (Control.ListDelta delta) output -> Control.Control (List.List state) (Control.ListDelta delta) output"},{"name":"alertIf","comment":" Emit an alert from a `Control` if its output fails to meet the predicate.\n\nThis is meant to be used in combination with `respond`, which listens for the\nalert and displays an error or notification message on the appropriate\ncontrol(s).\n\n","type":"(output -> Basics.Bool) -> String.String -> Control.Control state delta output -> Control.Control state delta output"},{"name":"array","comment":" A combinator that produces an `Array` from a control of a given type.\n\n    myArrayControl =\n        array int\n\n","type":"Control.Control state delta output -> Control.Control ( Control.State (List.List (Control.State state)), Control.End ) ( Control.Delta (Control.ListDelta delta), Control.End ) (Array.Array output)"},{"name":"bool","comment":" A control that produces a `Bool`. Renders as an HTML checkbox.\n","type":"Control.Control Basics.Bool Basics.Bool Basics.Bool"},{"name":"char","comment":" A control that produces a `Char`. Renders as an HTML text input.\n","type":"Control.Control String.String String.String Char.Char"},{"name":"class","comment":" Add an HTML class attribute for a `Control`. See docs for Html.Attributes.class in elm-html.\n\n    myStringControlHasAClass =\n        string\n            |> class \"important\"\n            |> class \"no-really\"\n\n","type":"String.String -> Control.Control state delta output -> Control.Control state delta output"},{"name":"classList","comment":" Add a list of HTML class attributes to a `Control`. See docs for Html.Attributes.classList in the `elm/html`\npackage.\n\n    myStringControlHasClasses =\n        string\n            |> classList\n                [ ( \"important\", True )\n                , ( \"no-really\", True )\n                , ( \"ignore-me\", False )\n                ]\n\n","type":"List.List ( String.String, Basics.Bool ) -> Control.Control state delta output -> Control.Control state delta output"},{"name":"create","comment":" Create a simple control, with any arbitrary `state` and `delta` types, and\nproducing any arbitrary `output` type.\n\nHere's how we could create a control like the famous\n[counter example](https://elm-lang.org/examples/buttons) from the Elm Guide\n\n    type CounterDelta\n        = Increment\n        | Decrement\n\n    counterControl : Control Int CounterDelta Int\n    counterControl =\n        create\n            { initEmpty = 0\n            , initPrefilled = identity\n            , update =\n                \\delta state ->\n                    case delta of\n                        Increment ->\n                            state + 1\n\n                        Decrement ->\n                            state - 1\n            , view =\n                \\{ state, name, id, label, class } ->\n                    Html.div [ Html.Attributes.class class ]\n                        [ Html.label\n                            [ Html.Attributes.for id ]\n                            [ Html.text label ]\n                        , Html.div\n                            [ Html.Attributes.id id\n                            , Html.Attributes.name name\n                            ]\n                            [ Html.button\n                                [ Html.Attributes.type_ \"button\"\n                                , Html.Events.onClick Increment\n                                ]\n                                [ Html.text \"+\" ]\n                            , Html.div [] [ Html.text <| String.fromInt state ]\n                            , Html.button\n                                [ Html.Attributes.type_ \"button\"\n                                , Html.Events.onClick Decrement\n                                ]\n                                [ Html.text \"-\" ]\n                            ]\n                        ]\n            , subscriptions = \\state -> Sub.none\n            , parse = Ok\n            }\n\n","type":"Control.ControlConfig state delta output -> Control.Control state delta output"},{"name":"customType","comment":" A combinator that produces a custom type.\n\n    type MyCustomType\n        = NoArgs\n        | OneArg String\n        | TwoArgs Int Float\n\n    myCustomTypeControl =\n        customType\n            (\\noArgs oneArg twoArgs tag ->\n                case tag of\n                    NoArgs ->\n                        noArgs\n\n                    OneArg arg1 ->\n                        oneArg arg1\n\n                    TwoArgs arg1 arg2 ->\n                        TwoArgs arg1 arg2\n            )\n            |> tag0 \"NoArgs\" NoArgs\n            |> tag1 \"OneArg\" OneArg string\n            |> tag2 \"TwoArgs\" TwoArgs int float\n            |> endCustomType\n\n","type":"destructor -> Control.CustomTypeBuilder (applyInputs -> applyInputs) (debouncingReceiverCollector -> debouncingReceiverCollector) Control.End Control.End (deltaBefore -> deltaBefore) (deltaBefores -> deltaBefores) destructor (errorCollector -> errorCollector) (alertEmitter -> alertEmitter) (Control.Path -> fns -> fns) (idleSetter -> idleSetter) (Control.Path -> initialDeltas -> initialDeltas) (Control.Path -> initialStates -> initialStates) (initialiseDeltas -> initialiseDeltas) (makeDeltaSetters -> makeDeltaSetters) (makeStateSetters -> makeStateSetters) (parser -> parser) Control.End Control.End (stateBefore -> stateBefore) (stateBefores -> stateBefores) (stateInserter -> stateInserter) (subscriptionCollector -> subscriptionCollector) (toArgStates -> toArgStates) (updater -> updater) (viewer -> viewer)"},{"name":"debounce","comment":" Debounce a `Control` for a number of milliseconds before it will display\nany parsing or validation errors. This can be used to allow the user to finish\ntyping into a text input before we show them feedback.\n\n    sluggishStringControl =\n        string\n            |> debounce 2000\n\n","type":"Basics.Float -> Control.Control state delta output -> Control.Control state delta output"},{"name":"default","comment":" Set a default `output` value for a `Control`.\n\n    oneAndHello =\n        tuple int string\n            |> default ( 1, \"hello\" )\n\n","type":"input -> Control.AdvancedControl input state delta output -> Control.AdvancedControl input state delta output"},{"name":"dict","comment":" A combinator that produces a `Dict` from controls of given key and value\ntypes. The key type must be `comparable`.\n\n    myDictControl =\n        dict int string\n\n","type":"Control.Control keyState keyDelta comparable -> Control.Control valueState valueDelta value -> Control.Control ( Control.State (List.List (Control.State ( Control.State keyState, ( Control.State valueState, Control.End ) ))), Control.End ) ( Control.Delta (Control.ListDelta ( Control.Delta keyDelta, ( Control.Delta valueDelta, Control.End ) )), Control.End ) (Dict.Dict comparable value)"},{"name":"endCustomType","comment":" Finalise the construction of a `customType` combinator.\n\n    type alias Foo\n        = Bar\n        | Baz\n\n\n    helloControl =\n        customType\n            (\\bar baz tag ->\n                case tag ofcustomType\n                    Bar -> bar\n                    Baz -> baz\n            )\n            |> tag0 \"Bar\" Bar\n            |> tag0 \"Baz\" Baz\n            |> endCustomType\n\n","type":"Control.CustomTypeBuilder (((input -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta, restDeltas )) )) -> Control.End -> input -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta, restDeltas )) )) -> (inputToStateConverter -> destructor) -> ( inputToStateConverter, restInputToStateConverters ) -> input -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta, restDeltas )) )) ((List.List Control.Alert -> Control.End -> Control.End -> List.List Control.Alert) -> List.List Control.Alert -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( Control.State state, restStates ) -> List.List Control.Alert) deltaAfter afters deltaBefore (Control.End -> befores) (inputToStateConverter -> destructor) ((List.List Control.Alert -> List.List Control.Feedback -> Control.End -> Control.End -> List.List Control.Feedback) -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( Control.State state, restStates ) -> List.List Control.Feedback) ((List.List Control.Alert -> Basics.Int -> Control.End -> Control.End -> List.List Control.Alert) -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( Control.State state, restStates ) -> List.List Control.Alert) (Control.Path -> Control.End -> ( Control.ControlFns input1 state delta output1, restFns )) ((Basics.Int -> Control.End -> Control.End -> Control.End) -> Basics.Int -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( Control.State state, restStates ) -> ( Control.State state, restStates )) (Control.Path -> Control.End -> deltas) (Control.Path -> Control.End -> ( Control.State state, restStates )) ((List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )) -> Control.End -> Control.End -> List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas ))) -> List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )) -> ( setter, restSetters ) -> deltas -> List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas ))) ((Control.End -> Control.End -> Control.End) -> befores -> afters -> ( setter, restSetters )) (({ c | finalTagStates : Control.End -> b2 } -> b2) -> { controlFns : ( Control.ControlFns input1 state delta output1, restFns ), deltaSetters : ( setter, restSetters ), finalTagStates : a1 -> a1, initialTagStates : ( Control.State state, restStates ), inputTuplizers : g, maybeOverridesAfter : h, maybeOverridesBefore : i, tagStateOverrider : j } -> ( inputToStateConverter, restInputToStateConverters )) ((a -> b1 -> Control.End -> Control.End -> a) -> Result.Result (List.List Control.Feedback) value -> Basics.Int -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( Control.State state, restStates ) -> Result.Result (List.List Control.Feedback) output) stateAfter h stateBefore (Control.End -> i) j ((List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas )) -> Control.End -> Control.End -> Control.End -> List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas ))) -> List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas )) -> ( setter, restSetters ) -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( Control.State state, restStates ) -> List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas ))) (Control.End -> g) (({ newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : Control.End -> ( Control.State state, restStates ) } -> Control.End -> Control.End -> Control.End -> Control.End -> { newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : Control.End -> ( Control.State state, restStates ) }) -> { newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : ( Control.State state, restStates ) -> ( Control.State state, restStates ) } -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( setter, restSetters ) -> ( Control.Delta delta, restDeltas ) -> ( Control.State state, restStates ) -> { newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : Control.End -> ( Control.State state, restStates ) }) ((List.List (Control.Subcontrol ( Control.Delta delta, restDeltas )) -> b -> Control.End -> Control.End -> Control.End -> List.List (Control.Subcontrol ( Control.Delta delta, restDeltas ))) -> List.List (Control.Subcontrol ( Control.Delta delta, restDeltas )) -> List.List Control.Alert -> ( Control.ControlFns input1 state delta output1, restFns ) -> ( setter, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol ( Control.Delta delta, restDeltas ))) -> Control.AdvancedControl input ( Control.State state, restStates ) ( Control.Delta delta, restDeltas ) output"},{"name":"endRecord","comment":" Finalise the construction of a `record` combinator.\n\n    type alias Hello =\n        { hello : String }\n\n    helloControl =\n        record Hello\n            |> field string\n            |> endRecord\n\n","type":"Control.RecordBuilder after afters before (Control.End -> befores) ((List.List Control.Alert -> Control.End -> Control.End -> List.List Control.Alert) -> List.List Control.Alert -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.State state, restStates ) -> List.List Control.Alert) ((List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )) -> Control.End -> Control.End -> List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas ))) -> List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )) -> ( Control.Delta delta -> recordDelta, restSetters ) -> deltas -> List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas ))) ((List.List Control.Alert -> List.List Control.Feedback -> Control.End -> Control.End -> List.List Control.Feedback) -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.State state, restStates ) -> List.List Control.Feedback) ((List.List Control.Alert -> Control.End -> Control.End -> List.List Control.Alert) -> List.List Control.Alert -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.State state, restStates ) -> List.List Control.Alert) (Control.Path -> Control.End -> ( Control.RecordFns input1 state delta output1 recordInput, restFns )) ((Control.End -> Control.End -> Control.End) -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.State state, restStates ) -> ( Control.State state, restStates )) (Control.Path -> Control.End -> deltas) (Control.Path -> Control.End -> ( Control.State state, restStates )) (((Control.End -> state1) -> List.List (Platform.Cmd.Cmd msg) -> b -> Control.End -> Control.End -> ( Control.State state1, Platform.Cmd.Cmd (Control.Delta msg) )) -> (a -> a) -> List.List c -> input -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.Delta delta -> recordDelta, restSetters ) -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta, restDeltas )) )) ((Control.End -> Control.End -> Control.End) -> befores -> afters -> ( Control.Delta delta -> recordDelta, restSetters )) ((Result.Result (List.List Control.Feedback) output -> Control.End -> Control.End -> Result.Result (List.List Control.Feedback) output) -> Result.Result (List.List Control.Feedback) output1_1 -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.State state, restStates ) -> Result.Result (List.List Control.Feedback) output) ((List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas )) -> Control.End -> Control.End -> Control.End -> List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas ))) -> List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas )) -> ( Control.Delta delta -> recordDelta, restSetters ) -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.State state, restStates ) -> List.List (Platform.Sub.Sub ( Control.Delta delta, restDeltas ))) output1_1 (({ newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : Control.End -> ( Control.State state, restStates ) } -> Control.End -> Control.End -> Control.End -> Control.End -> { newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : Control.End -> ( Control.State state, restStates ) }) -> { newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : ( Control.State state, restStates ) -> ( Control.State state, restStates ) } -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.Delta delta -> recordDelta, restSetters ) -> ( Control.Delta delta, restDeltas ) -> ( Control.State state, restStates ) -> { newCmds : List.List (Platform.Cmd.Cmd ( Control.Delta delta, restDeltas )), newStates : Control.End -> ( Control.State state, restStates ) }) ((List.List (Control.Subcontrol ( Control.Delta delta, restDeltas )) -> List.List Control.Alert -> Control.End -> Control.End -> Control.End -> List.List (Control.Subcontrol ( Control.Delta delta, restDeltas ))) -> List.List (Control.Subcontrol ( Control.Delta delta, restDeltas )) -> List.List Control.Alert -> ( Control.RecordFns input1 state delta output1 recordInput, restFns ) -> ( Control.Delta delta -> recordDelta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol ( Control.Delta delta, restDeltas ))) -> Control.AdvancedControl input ( Control.State state, restStates ) ( Control.Delta delta, restDeltas ) output"},{"name":"enum","comment":" A control that produces a custom type where none of the\nvariants have any payload. Renders as an HTML radio input.\n\n    type Colour\n        = Red\n        | Green\n        | Blue\n\n    colourControl : Control Colour Colour Colour\n    colourControl =\n        enum\n            ( \"Red\", Red )\n            ( \"Green\", Green )\n            [ ( \"Blue\", Blue ) ]\n\n","type":"( String.String, enum ) -> ( String.String, enum ) -> List.List ( String.String, enum ) -> Control.Control enum enum enum"},{"name":"failIf","comment":" Display an error on a `Control` if its output fails to meet the predicate.\n\nThis causes the `Control` to fail validation.\n\n    positiveInt =\n        int\n            |> failIf\n                (\\x -> x < 1)\n                \"This must be greater than zero!\"\n\n","type":"(output -> Basics.Bool) -> String.String -> Control.Control state delta output -> Control.Control state delta output"},{"name":"field","comment":" Add a field to a `record` combinator.\n\n    type alias Hello =\n        { hello : String }\n\n    helloControl =\n        record Hello\n            |> field string\n            |> endRecord\n\n","type":"(recordOutput8 -> output7) -> Control.AdvancedControl input8 state9 delta12 output7 -> Control.RecordBuilder after1 afters1 (( Control.Delta delta13, a18 ) -> c5) (( ( Control.Delta delta13, a18 ) -> c5, a17 ) -> c4) (a16 -> List.List Control.Alert -> restFns7 -> restStates7 -> List.List Control.Alert) (a15 -> List.List (Platform.Cmd.Cmd delta1_1) -> restDeltaSetters2 -> restDeltas2 -> List.List (Platform.Cmd.Cmd delta1_1)) (a14 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates6 -> List.List Control.Feedback) (a13 -> List.List Control.Alert -> restFns5 -> restStates5 -> List.List Control.Alert) (Path.Path -> ( Control.RecordFns input8 state9 delta12 output7 recordOutput8, a12 ) -> c3) (a11 -> restFns4 -> restStates4 -> restStates4) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta delta12), a10 ) -> c2) (Path.Path -> ( Control.State state9, a9 ) -> c1) (a8 -> (a7 -> c) -> List.List (Platform.Cmd.Cmd msg1) -> a5 -> b -> d -> e) (a4 -> befores -> afters -> next) (a3 -> Result.Result (List.List Control.Feedback) output1_1 -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output2_1) (a2 -> List.List (Platform.Sub.Sub msg) -> restDeltas1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub msg)) toOutput (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters1 -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : recordState }) (a -> List.List (Control.Subcontrol recordDelta) -> List.List Control.Alert -> restFns -> restDeltaSetters -> restStates -> List.List (Control.Subcontrol recordDelta)) -> Control.RecordBuilder ( Control.Delta delta11, after1 ) ( after1, afters1 ) (a18 -> c5) (a17 -> c4) (a16 -> List.List Control.Alert -> ( Control.RecordFns input7 state8 delta10 output6 recordOutput7, restFns7 ) -> ( Control.State state8, restStates7 ) -> List.List Control.Alert) (a15 -> List.List (Platform.Cmd.Cmd delta1_1) -> ( delta9 -> delta1_1, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta9, restDeltas2 ) -> List.List (Platform.Cmd.Cmd delta1_1)) (a14 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.RecordFns input6 state7 delta8 output5 recordOutput6, restFns6 ) -> ( Control.State state7, restStates6 ) -> List.List Control.Feedback) (a13 -> List.List Control.Alert -> ( Control.RecordFns input5 state6 delta7 output4 recordOutput5, restFns5 ) -> ( Control.State state6, restStates5 ) -> List.List Control.Alert) (Path.Path -> a12 -> c3) (a11 -> ( Control.RecordFns input4 state5 delta6 output3 recordOutput4, restFns4 ) -> ( Control.State state5, restStates4 ) -> ( Control.State state5, restStates4 )) (Path.Path -> a10 -> c2) (Path.Path -> a9 -> c1) (a8 -> (( Control.State state4, a7 ) -> c) -> List.List (Platform.Cmd.Cmd msg1) -> a5 -> ( Control.RecordFns a6 state4 delta5 a6 a5, b ) -> ( Control.Delta delta5 -> msg1, d ) -> e) (a4 -> ( ( value, after ) -> delta4, befores ) -> ( after, afters ) -> ( value -> delta4, next )) (a3 -> Result.Result (List.List Control.Feedback) (output0 -> output1_1) -> ( Control.RecordFns input3 state3 delta3 output0 recordOutput3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output2_1) (a2 -> List.List (Platform.Sub.Sub msg) -> ( Control.Delta delta2 -> msg, restDeltas1 ) -> ( Control.RecordFns input2 state2 delta2 output2 recordOutput2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub msg)) toOutput (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.RecordFns input1 state1 delta1 output1 recordOutput1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta1, restDeltaSetters1 ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : recordState }) (a -> List.List (Control.Subcontrol recordDelta) -> List.List Control.Alert -> ( Control.RecordFns input state delta output recordOutput, restFns ) -> ( Control.Delta delta -> recordDelta, restDeltaSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol recordDelta))"},{"name":"float","comment":" A control that produces a `Float`. Renders as an HTML number input.\n","type":"Control.Control String.String String.String Basics.Float"},{"name":"form","comment":" Convert a `Control` into a `Form`, and render the form however you like.\n\nYou will need to supply a variant from your app's `Msg` type to handle updates of the form's state.\nYou will also need to supply a `view` function that takes the `List (Html msg)` produced by the\nsupplied `Control` and returns an `Html msg`, as follows:\n\n    type alias Msg\n        = FormUpdated (Delta String)\n        | FormSubmitted\n\n    myForm : Form (State String) (Delta String) Int Msg\n    myForm =\n        form\n            { control = int\n            , onUpdate = FormUpdated\n            , view =\n                \\controlView ->\n                    H.form\n                        [ HE.onSubmit FormSubmitted ]\n                        (controlView ++ [ H.button [ HA.type_ \"submit\" ] [ H.text \"Submit\" ] ])\n            }\n\nNow you can integrate your `Form` into a larger Elm app:\n\n1.  Call `myForm.blank` or `myForm.prefill` in your `init` function.\n2.  Call `myForm.update` in the `FormUpdated` branch of your `update` function.\n3.  Call `myForm.submit` in the `FormSubmitted` branch of your `update` function.\n4.  Call `myForm.view` in your `view` function.\n5.  Call `myForm.subscriptions` in your `subscriptions` function.\n\n","type":"{ control : Control.Control state delta output, onUpdate : Control.Delta delta -> msg, view : List.List (Html.Html msg) -> Html.Html msg } -> Control.Form state delta output msg"},{"name":"id","comment":" Set an id for a `Control`.\n\n    myStringControlHasAnId =\n        string\n            |> id \"my-string\"\n\n","type":"String.String -> Control.Control state delta output -> Control.Control state delta output"},{"name":"int","comment":" A control that produces an `Int`. Renders as an HTML number input.\n","type":"Control.Control String.String String.String Basics.Int"},{"name":"label","comment":" Set a label for a `Control`.\n\n    myStringControlHasALabel =\n        string\n            |> label \"Enter your name\"\n\n","type":"String.String -> Control.AdvancedControl input state delta output -> Control.AdvancedControl input state delta output"},{"name":"layout","comment":" Define the HTML output for a combinator.\n\nThis is useful if you want to alter the way that the combinator's subcontrols\nare laid out on the screen.\n\nFor example, you could use it to present a record control as a wizard, rather\nthan a list. The wizard example below is very naive, but hopefully gives you the\nidea.\n\n    type alias MyRecord =\n        { name : String\n        , age : Int\n        }\n\n    myRecordControl =\n        record\n            (\\name age ->\n                { name = name\n                , age = age\n                }\n            )\n            |> field string\n            |> field int\n            |> endRecord\n            |> layout wizard\n\n    wizard config subcontrols =\n        let\n            currentPage =\n                config.selected\n\n            totalPages =\n                List.length subcontrols\n\n            currentPageView =\n                subcontrols\n                    |> List.filter (\\{ index } -> index == currentPage)\n                    |> List.map .html\n                    |> List.concat\n\n            nextClicked =\n                config.selectMsg (currentPage + 1)\n\n            backClicked =\n                config.selectMsg (currentPage - 1)\n\n            navigationButton txt msg =\n                Html.button\n                    [ Html.Attributes.type_ \"button\"\n                    , Html.Events.onClick msg\n                    ]\n                    [ Html.text txt ]\n        in\n        Html.div\n            [ Html.Attributes.id config.id\n            , Html.Attributes.class config.class\n            ]\n            ([ Html.h1 [] [ Html.text \"Wizard!\" ]\n             , navigationButton \"Back\" backClicked\n             , Html.text\n                (String.join \" \"\n                    [ \"page\"\n                    , String.fromInt currentPage\n                    , \"of\"\n                    , String.fromInt totalPages\n                    ]\n                )\n             , navigationButton \"Next\" nextClicked\n             ]\n                ++ currentPageView\n            )\n\n","type":"(Control.LayoutConfig delta -> List.List (Control.Subcontrol delta) -> List.List (Html.Html (Control.Delta delta))) -> Control.Control state delta output -> Control.Control state delta output"},{"name":"list","comment":" A combinator that produces a `List` of controls of a given type.\n\n    myListControl =\n        list int\n\n","type":"Control.Control state delta output -> Control.Control (List.List (Control.State state)) (Control.ListDelta delta) (List.List output)"},{"name":"map","comment":" A combinator that converts a `Control` whose `output` is of type `a` to a `Control` whose `output` is of type `b`.\n\nThis is particularly useful for implementing \"wrapper\" types, such as `Id`s.\n\nNote: with most common map functions, such as `List.map`, we only need to supply a function from `a -> b`. In this case,\nhowever, we need to supply two functions that will allow us to both `convert` the type from `a -> b` and\n`revert` it back from `b -> a`.\n\n    type Id\n        = Id Int\n\n    idControl =\n        map\n            { convert = \\i -> Id i\n            , revert = \\(Id i) -> i\n            }\n            int\n\n","type":"{ convert : a -> b, revert : b -> a } -> Control.Control state delta a -> Control.Control ( Control.State state, Control.End ) ( Control.Delta delta, Control.End ) b"},{"name":"maybe","comment":" A combinator that produces a `Maybe` of a control of a given type.\n\n    myMaybeControl =\n        maybe int\n\n","type":"Control.Control state delta output -> Control.Control ( Control.State (), ( Control.State ( Control.State state, Control.End ), Control.End ) ) ( Control.Delta (), ( Control.Delta ( Control.Delta delta, Control.End ), Control.End ) ) (Maybe.Maybe output)"},{"name":"name","comment":" Set a name for a `Control`.\n\n    myStringControlHasAName =\n        string\n            |> name \"My string\"\n\n","type":"String.String -> Control.Control state delta output -> Control.Control state delta output"},{"name":"noteIf","comment":" Display an note on a `Control` if its output fails to meet the predicate.\n\nThis just shows the user a message - it doesn't cause the `Control` to fail\nvalidation.\n\n    positiveInt =\n        int\n            |> noteIf\n                (\\x -> x < 1)\n                \"Should this be greater than zero?\"\n\n","type":"(output -> Basics.Bool) -> String.String -> Control.Control state delta output -> Control.Control state delta output"},{"name":"record","comment":" A combinator that produces a record type, or any 'product' type that needs to\nbe constructed from multiple controls. (For example, the `tuple` combinator in\nthis library is built using the `record` combinator).\n\n    type alias MyRecord =\n        { name : String\n        , age : Int\n        }\n\n    myRecordControl =\n        record\n            (\\name age ->\n                { name = name\n                , age = age\n                }\n            )\n            |> field string\n            |> field int\n            |> endRecord\n\n","type":"toOutput -> Control.RecordBuilder Control.End Control.End (a12 -> a12) (a11 -> a11) (a10 -> a10) (a9 -> a9) (a8 -> a8) (a7 -> a7) (b -> c -> c) (a6 -> a6) (d -> e -> e) (f -> g -> g) (a5 -> a5) (a4 -> a4) (a3 -> a3) (a2 -> a2) toOutput (a1 -> a1) (a -> a)"},{"name":"respond","comment":" Respond to an alert emitted by another `Control`, display an error or\nnotification message on this control, and if desired, cause validation to fail.\n\nThis is meant to be used in combination with `alertIf`, which emits the alert.\n\n","type":"{ alert : String.String, fail : Basics.Bool, message : String.String } -> Control.Control state delta output -> Control.Control state delta output"},{"name":"result","comment":" A combinator that produces a `Result` with a given error and\nsuccess type.\n\n    myResultControl =\n        result string int\n\n","type":"Control.Control failureState failureDelta failureOutput -> Control.Control successState successDelta successOutput -> Control.Control ( Control.State ( Control.State failureState, Control.End ), ( Control.State ( Control.State successState, Control.End ), Control.End ) ) ( Control.Delta ( Control.Delta failureDelta, Control.End ), ( Control.Delta ( Control.Delta successDelta, Control.End ), Control.End ) ) (Result.Result failureOutput successOutput)"},{"name":"sandbox","comment":" Test and debug a `Control` by turning it into a `Program` that you can run as a standalone Elm application.\n\nThis is useful when you're rapidly iterating on designing a form, and you don't yet want the hassle of plumbing it into\nyour main Elm application's `Model`and `Msg` types.\n\nOnce you're happy with the form, you can then ask the Elm repl (or your editor's Elm plugin) to tell you the type\nsignature of the `Program`, which will give you the form's `State` and `Delta` types. You can then plug these into your\nmain `Model`and `Msg` types wherever appropriate.\n\n    main : Program () (State String) (Delta String)\n    main =\n        sandbox\n            { control = int\n            , outputToString = Debug.toString\n            }\n\n","type":"{ outputToString : output -> String.String, control : Control.Control state delta output } -> Platform.Program () (Control.State state) (Control.Delta delta)"},{"name":"set","comment":" A combinator that produces a `Set` from controls of a given member\ntypes. The member type must be `comparable`.\n\n    mySetControl =\n        set string\n\n","type":"Control.Control state delta comparable -> Control.Control ( Control.State (List.List (Control.State state)), Control.End ) ( Control.Delta (Control.ListDelta delta), Control.End ) (Set.Set comparable)"},{"name":"simpleForm","comment":" Convert a `Control` into a simple `Form`, rendered as a list of controls\nwrapped in an HTML `<form>` element, with a submit button at the bottom.\n\nYou will need to supply a couple of variants from your app's `Msg` type: one to\nhandle updates of the form's state, and one to handle the submission of the\nform, as follows:\n\n    type alias Msg\n        = FormUpdated (Delta String)\n        | FormSubmitted\n\n    mySimpleForm : Form (State String) (Delta String) Int Msg\n    mySimpleForm =\n        form\n            { control = int\n            , onUpdate = FormUpdated\n            , onSubmit = FormSubmitted\n            }\n\nNow you can integrate your `Form` into a larger Elm app:\n\n1.  Call `mySimpleForm.blank` or `mySimpleForm.prefill` in your `init` function.\n2.  Call `mySimpleForm.update` in the `FormUpdated` branch of your `update` function.\n3.  Call `mySimpleForm.submit` in the `FormSubmitted` branch of your `update` function.\n4.  Call `mySimpleForm.view` in your `view` function.\n5.  Call `mySimpleForm.subscriptions` in your `subscriptions` function.\n\n","type":"{ control : Control.Control state delta output, onUpdate : Control.Delta delta -> msg, onSubmit : msg } -> Control.Form state delta output msg"},{"name":"string","comment":" A control that produces a `String`. Renders as an HTML text input.\n","type":"Control.Control String.String String.String String.String"},{"name":"tag0","comment":" Add a tag with no arguments to a custom type.\n\n    type Unit\n        = Unit\n\n    unitControl =\n        customType\n            (\\unit tag ->\n                case tag of\n                    Unit ->\n                        unit\n            )\n            |> tag0 \"Unit\" Unit\n            |> endCustomType\n\n","type":"String.String -> output9 -> Control.CustomTypeBuilder (a21 -> destructor1 -> restInputToStateConverters -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> restFns7 -> restStates8 -> List.List Control.Alert) deltaAfter deltaAfters (( Control.Delta delta14, a19 ) -> c7) (( ( Control.Delta delta14, a19 ) -> c7, a18 ) -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates7 -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> restFns5 -> restStates6 -> List.List Control.Alert) (Path.Path -> ( Control.ControlFns output9 () () output9, a15 ) -> c5) (a14 -> Basics.Int -> restFns4 -> restStates5 -> restStates5) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta ()), a13 ) -> c4) (Path.Path -> ( Control.State (), a12 ) -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> restDeltaSetters2 -> restDeltas1 -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> befores -> afters -> next) (a9 -> { controlFns : restControlFns, deltaSetters : restDeltaSetters1, finalTagStates : nextFinalTagState -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : restInputTuplizers, maybeOverridesAfter : restMaybeOverridesAfter, maybeOverridesBefore : restMaybeOverridesBefore, tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output3) stateAfter stateAfters (( Maybe.Maybe a23, a6 ) -> c2) (( ( Maybe.Maybe a23, a6 ) -> c2, a5 ) -> c1) (a4 -> Basics.Int -> Basics.Int -> (restArgStates -> tagStates) -> restMaybeArgStates -> restArgStates -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> restSetters1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub delta1_1)) (( (output9 -> b) -> b, a2 ) -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> restFns -> restSetters -> restStates -> List.List (Control.Subcontrol delta)) -> Control.CustomTypeBuilder (a21 -> (inputToStateConverter -> destructor1) -> ( inputToStateConverter, restInputToStateConverters ) -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> ( Control.ControlFns input8 state8 delta11 output8, restFns7 ) -> ( Control.State state8, restStates8 ) -> List.List Control.Alert) ( Control.Delta delta10, deltaAfter ) ( deltaAfter, deltaAfters ) (a19 -> c7) (a18 -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input7 state7 delta9 output7, restFns6 ) -> ( Control.State state7, restStates7 ) -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input6 state6 delta8 output6, restFns5 ) -> ( Control.State state6, restStates6 ) -> List.List Control.Alert) (Path.Path -> a15 -> c5) (a14 -> Basics.Int -> ( Control.ControlFns input5 state5 delta7 output5, restFns4 ) -> ( Control.State state5, restStates5 ) -> ( Control.State state5, restStates5 )) (Path.Path -> a13 -> c4) (Path.Path -> a12 -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> ( delta6 -> delta1_2, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta6, restDeltas1 ) -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> ( ( value, after ) -> delta5, befores ) -> ( after, afters ) -> ( value -> delta5, next )) (a9 -> { controlFns : ( Control.ControlFns input4 state1_1 delta4 output4, restControlFns ), deltaSetters : ( Control.Delta delta4 -> tagDelta, restDeltaSetters1 ), finalTagStates : ( finalTagState, nextFinalTagState ) -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : ( (input4 -> ( Control.State tagStates1, Platform.Cmd.Cmd (Control.Delta tagDelta) )) -> finalTagState, restInputTuplizers ), maybeOverridesAfter : ( maybeOverrideAfter, restMaybeOverridesAfter ), maybeOverridesBefore : ( ( Maybe.Maybe (Control.State state1_1), maybeOverrideAfter ) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ), restMaybeOverridesBefore ), tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> ( Control.ControlFns input3 state3 delta3 output3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output3) ( Maybe.Maybe a7, stateAfter ) ( stateAfter, stateAfters ) (a6 -> c2) (a5 -> c1) (a4 -> Basics.Int -> Basics.Int -> (( Control.State argState, restArgStates ) -> tagStates) -> ( Maybe.Maybe (Control.State argState), restMaybeArgStates ) -> ( Control.State argState, restArgStates ) -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> ( Control.Delta delta2 -> delta1_1, restSetters1 ) -> ( Control.ControlFns input2 state2 delta2 output2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub delta1_1)) (a2 -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.ControlFns input1 state1 delta1 output1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta, restDeltaSetters ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> ( Control.ControlFns input state e output, restFns ) -> ( Control.Delta e -> delta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol delta))"},{"name":"tag1","comment":" Add a tag with one argument to a custom type.\n\n    type alias MyResult =\n        Result String Int\n\n    myResultControl =\n        customType\n            (\\ok err tag ->\n                case tag of\n                    Ok value ->\n                        ok value\n\n                    Err error ->\n                        err error\n            )\n            |> tag1 \"Ok\" Ok int\n            |> tag1 \"Err\" Err string\n            |> endCustomType\n\n","type":"String.String -> (output10 -> output9) -> Control.AdvancedControl output10 state9 delta13 output10 -> Control.CustomTypeBuilder (a21 -> destructor1 -> restInputToStateConverters -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> restFns7 -> restStates8 -> List.List Control.Alert) deltaAfter deltaAfters (( Control.Delta delta14, a19 ) -> c7) (( ( Control.Delta delta14, a19 ) -> c7, a18 ) -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates7 -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> restFns5 -> restStates6 -> List.List Control.Alert) (Path.Path -> ( Control.ControlFns ( output10, b ) ( Control.State state9, Control.End ) ( Control.Delta delta13, Control.End ) output9, a15 ) -> c5) (a14 -> Basics.Int -> restFns4 -> restStates5 -> restStates5) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta13, Control.End )), a13 ) -> c4) (Path.Path -> ( Control.State ( Control.State state9, Control.End ), a12 ) -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> restDeltaSetters2 -> restDeltas1 -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> befores -> afters -> next) (a9 -> { controlFns : restControlFns, deltaSetters : restDeltaSetters1, finalTagStates : nextFinalTagState -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : restInputTuplizers, maybeOverridesAfter : restMaybeOverridesAfter, maybeOverridesBefore : restMaybeOverridesBefore, tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output3) stateAfter stateAfters (( Maybe.Maybe a23, a6 ) -> c2) (( ( Maybe.Maybe a23, a6 ) -> c2, a5 ) -> c1) (a4 -> Basics.Int -> Basics.Int -> (restArgStates -> tagStates) -> restMaybeArgStates -> restArgStates -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> restSetters1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub delta1_1)) (( (( d, Control.End ) -> f) -> d -> f, a2 ) -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> restFns -> restSetters -> restStates -> List.List (Control.Subcontrol delta)) -> Control.CustomTypeBuilder (a21 -> (inputToStateConverter -> destructor1) -> ( inputToStateConverter, restInputToStateConverters ) -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> ( Control.ControlFns input8 state8 delta11 output8, restFns7 ) -> ( Control.State state8, restStates8 ) -> List.List Control.Alert) ( Control.Delta delta10, deltaAfter ) ( deltaAfter, deltaAfters ) (a19 -> c7) (a18 -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input7 state7 delta9 output7, restFns6 ) -> ( Control.State state7, restStates7 ) -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input6 state6 delta8 output6, restFns5 ) -> ( Control.State state6, restStates6 ) -> List.List Control.Alert) (Path.Path -> a15 -> c5) (a14 -> Basics.Int -> ( Control.ControlFns input5 state5 delta7 output5, restFns4 ) -> ( Control.State state5, restStates5 ) -> ( Control.State state5, restStates5 )) (Path.Path -> a13 -> c4) (Path.Path -> a12 -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> ( delta6 -> delta1_2, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta6, restDeltas1 ) -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> ( ( value, after ) -> delta5, befores ) -> ( after, afters ) -> ( value -> delta5, next )) (a9 -> { controlFns : ( Control.ControlFns input4 state1_1 delta4 output4, restControlFns ), deltaSetters : ( Control.Delta delta4 -> tagDelta, restDeltaSetters1 ), finalTagStates : ( finalTagState, nextFinalTagState ) -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : ( (input4 -> ( Control.State tagStates1, Platform.Cmd.Cmd (Control.Delta tagDelta) )) -> finalTagState, restInputTuplizers ), maybeOverridesAfter : ( maybeOverrideAfter, restMaybeOverridesAfter ), maybeOverridesBefore : ( ( Maybe.Maybe (Control.State state1_1), maybeOverrideAfter ) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ), restMaybeOverridesBefore ), tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> ( Control.ControlFns input3 state3 delta3 output3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output3) ( Maybe.Maybe a7, stateAfter ) ( stateAfter, stateAfters ) (a6 -> c2) (a5 -> c1) (a4 -> Basics.Int -> Basics.Int -> (( Control.State argState, restArgStates ) -> tagStates) -> ( Maybe.Maybe (Control.State argState), restMaybeArgStates ) -> ( Control.State argState, restArgStates ) -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> ( Control.Delta delta2 -> delta1_1, restSetters1 ) -> ( Control.ControlFns input2 state2 delta2 output2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub delta1_1)) (a2 -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.ControlFns input1 state1 delta1 output1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta, restDeltaSetters ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> ( Control.ControlFns input state e output, restFns ) -> ( Control.Delta e -> delta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol delta))"},{"name":"tag2","comment":" Add a tag with two arguments to a custom type.\n\n    type Point\n        = Point Float Float\n\n    pointControl =\n        customType\n            (\\point tag ->\n                case tag of\n                    Point x y ->\n                        point x y\n            )\n            |> tag2 \"Point\" Point float float\n\n","type":"String.String -> (output11 -> output10 -> output9) -> Control.AdvancedControl output11 state10 delta14 output11 -> Control.AdvancedControl output10 state9 delta13 output10 -> Control.CustomTypeBuilder (a21 -> destructor1 -> restInputToStateConverters -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> restFns7 -> restStates8 -> List.List Control.Alert) deltaAfter deltaAfters (( Control.Delta delta14_1, a19 ) -> c7) (( ( Control.Delta delta14_1, a19 ) -> c7, a18 ) -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates7 -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> restFns5 -> restStates6 -> List.List Control.Alert) (Path.Path -> ( Control.ControlFns ( output11, ( output10, b ) ) ( Control.State state10, ( Control.State state9, Control.End ) ) ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) output9, a15 ) -> c5) (a14 -> Basics.Int -> restFns4 -> restStates5 -> restStates5) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) )), a13 ) -> c4) (Path.Path -> ( Control.State ( Control.State state10, ( Control.State state9, Control.End ) ), a12 ) -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> restDeltaSetters2 -> restDeltas1 -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> befores -> afters -> next) (a9 -> { controlFns : restControlFns, deltaSetters : restDeltaSetters1, finalTagStates : nextFinalTagState -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : restInputTuplizers, maybeOverridesAfter : restMaybeOverridesAfter, maybeOverridesBefore : restMaybeOverridesBefore, tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output3) stateAfter stateAfters (( Maybe.Maybe a23, a6 ) -> c2) (( ( Maybe.Maybe a23, a6 ) -> c2, a5 ) -> c1) (a4 -> Basics.Int -> Basics.Int -> (restArgStates -> tagStates) -> restMaybeArgStates -> restArgStates -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> restSetters1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub delta1_1)) (( (( d, ( f, Control.End ) ) -> g) -> d -> f -> g, a2 ) -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> restFns -> restSetters -> restStates -> List.List (Control.Subcontrol delta)) -> Control.CustomTypeBuilder (a21 -> (inputToStateConverter -> destructor1) -> ( inputToStateConverter, restInputToStateConverters ) -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> ( Control.ControlFns input8 state8 delta11 output8, restFns7 ) -> ( Control.State state8, restStates8 ) -> List.List Control.Alert) ( Control.Delta delta10, deltaAfter ) ( deltaAfter, deltaAfters ) (a19 -> c7) (a18 -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input7 state7 delta9 output7, restFns6 ) -> ( Control.State state7, restStates7 ) -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input6 state6 delta8 output6, restFns5 ) -> ( Control.State state6, restStates6 ) -> List.List Control.Alert) (Path.Path -> a15 -> c5) (a14 -> Basics.Int -> ( Control.ControlFns input5 state5 delta7 output5, restFns4 ) -> ( Control.State state5, restStates5 ) -> ( Control.State state5, restStates5 )) (Path.Path -> a13 -> c4) (Path.Path -> a12 -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> ( delta6 -> delta1_2, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta6, restDeltas1 ) -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> ( ( value, after ) -> delta5, befores ) -> ( after, afters ) -> ( value -> delta5, next )) (a9 -> { controlFns : ( Control.ControlFns input4 state1_1 delta4 output4, restControlFns ), deltaSetters : ( Control.Delta delta4 -> tagDelta, restDeltaSetters1 ), finalTagStates : ( finalTagState, nextFinalTagState ) -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : ( (input4 -> ( Control.State tagStates1, Platform.Cmd.Cmd (Control.Delta tagDelta) )) -> finalTagState, restInputTuplizers ), maybeOverridesAfter : ( maybeOverrideAfter, restMaybeOverridesAfter ), maybeOverridesBefore : ( ( Maybe.Maybe (Control.State state1_1), maybeOverrideAfter ) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ), restMaybeOverridesBefore ), tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> ( Control.ControlFns input3 state3 delta3 output3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output3) ( Maybe.Maybe a7, stateAfter ) ( stateAfter, stateAfters ) (a6 -> c2) (a5 -> c1) (a4 -> Basics.Int -> Basics.Int -> (( Control.State argState, restArgStates ) -> tagStates) -> ( Maybe.Maybe (Control.State argState), restMaybeArgStates ) -> ( Control.State argState, restArgStates ) -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> ( Control.Delta delta2 -> delta1_1, restSetters1 ) -> ( Control.ControlFns input2 state2 delta2 output2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub delta1_1)) (a2 -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.ControlFns input1 state1 delta1 output1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta, restDeltaSetters ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> ( Control.ControlFns input state e output, restFns ) -> ( Control.Delta e -> delta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol delta))"},{"name":"tag3","comment":" Add a tag with three arguments to a custom type.\n\n    type Point3D\n        = Point3D Float Float Float\n\n    point3DControl =\n        customType\n            (\\point3D tag ->\n                case tag of\n                    Point3D x y z ->\n                        point3D x y z\n            )\n            |> tag3 \"Point3D\" Point3D float float float\n\n","type":"String.String -> (output12 -> output11 -> output10 -> output9) -> Control.AdvancedControl output12 state11 delta15 output12 -> Control.AdvancedControl output11 state10 delta14 output11 -> Control.AdvancedControl output10 state9 delta13 output10 -> Control.CustomTypeBuilder (a21 -> destructor1 -> restInputToStateConverters -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> restFns7 -> restStates8 -> List.List Control.Alert) deltaAfter deltaAfters (( Control.Delta delta14_1, a19 ) -> c7) (( ( Control.Delta delta14_1, a19 ) -> c7, a18 ) -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates7 -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> restFns5 -> restStates6 -> List.List Control.Alert) (Path.Path -> ( Control.ControlFns ( output12, ( output11, ( output10, b ) ) ) ( Control.State state11, ( Control.State state10, ( Control.State state9, Control.End ) ) ) ( Control.Delta delta15, ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) ) output9, a15 ) -> c5) (a14 -> Basics.Int -> restFns4 -> restStates5 -> restStates5) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta15, ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) )), a13 ) -> c4) (Path.Path -> ( Control.State ( Control.State state11, ( Control.State state10, ( Control.State state9, Control.End ) ) ), a12 ) -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> restDeltaSetters2 -> restDeltas1 -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> befores -> afters -> next) (a9 -> { controlFns : restControlFns, deltaSetters : restDeltaSetters1, finalTagStates : nextFinalTagState -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : restInputTuplizers, maybeOverridesAfter : restMaybeOverridesAfter, maybeOverridesBefore : restMaybeOverridesBefore, tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output3) stateAfter stateAfters (( Maybe.Maybe a23, a6 ) -> c2) (( ( Maybe.Maybe a23, a6 ) -> c2, a5 ) -> c1) (a4 -> Basics.Int -> Basics.Int -> (restArgStates -> tagStates) -> restMaybeArgStates -> restArgStates -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> restSetters1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub delta1_1)) (( (( d, ( f, ( g, Control.End ) ) ) -> h) -> d -> f -> g -> h, a2 ) -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> restFns -> restSetters -> restStates -> List.List (Control.Subcontrol delta)) -> Control.CustomTypeBuilder (a21 -> (inputToStateConverter -> destructor1) -> ( inputToStateConverter, restInputToStateConverters ) -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> ( Control.ControlFns input8 state8 delta11 output8, restFns7 ) -> ( Control.State state8, restStates8 ) -> List.List Control.Alert) ( Control.Delta delta10, deltaAfter ) ( deltaAfter, deltaAfters ) (a19 -> c7) (a18 -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input7 state7 delta9 output7, restFns6 ) -> ( Control.State state7, restStates7 ) -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input6 state6 delta8 output6, restFns5 ) -> ( Control.State state6, restStates6 ) -> List.List Control.Alert) (Path.Path -> a15 -> c5) (a14 -> Basics.Int -> ( Control.ControlFns input5 state5 delta7 output5, restFns4 ) -> ( Control.State state5, restStates5 ) -> ( Control.State state5, restStates5 )) (Path.Path -> a13 -> c4) (Path.Path -> a12 -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> ( delta6 -> delta1_2, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta6, restDeltas1 ) -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> ( ( value, after ) -> delta5, befores ) -> ( after, afters ) -> ( value -> delta5, next )) (a9 -> { controlFns : ( Control.ControlFns input4 state1_1 delta4 output4, restControlFns ), deltaSetters : ( Control.Delta delta4 -> tagDelta, restDeltaSetters1 ), finalTagStates : ( finalTagState, nextFinalTagState ) -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : ( (input4 -> ( Control.State tagStates1, Platform.Cmd.Cmd (Control.Delta tagDelta) )) -> finalTagState, restInputTuplizers ), maybeOverridesAfter : ( maybeOverrideAfter, restMaybeOverridesAfter ), maybeOverridesBefore : ( ( Maybe.Maybe (Control.State state1_1), maybeOverrideAfter ) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ), restMaybeOverridesBefore ), tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> ( Control.ControlFns input3 state3 delta3 output3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output3) ( Maybe.Maybe a7, stateAfter ) ( stateAfter, stateAfters ) (a6 -> c2) (a5 -> c1) (a4 -> Basics.Int -> Basics.Int -> (( Control.State argState, restArgStates ) -> tagStates) -> ( Maybe.Maybe (Control.State argState), restMaybeArgStates ) -> ( Control.State argState, restArgStates ) -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> ( Control.Delta delta2 -> delta1_1, restSetters1 ) -> ( Control.ControlFns input2 state2 delta2 output2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub delta1_1)) (a2 -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.ControlFns input1 state1 delta1 output1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta, restDeltaSetters ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> ( Control.ControlFns input state e output, restFns ) -> ( Control.Delta e -> delta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol delta))"},{"name":"tag4","comment":" Add a tag with four arguments to a custom type.\n","type":"String.String -> (output13 -> output12 -> output11 -> output10 -> output9) -> Control.AdvancedControl output13 state12 delta16 output13 -> Control.AdvancedControl output12 state11 delta15 output12 -> Control.AdvancedControl output11 state10 delta14 output11 -> Control.AdvancedControl output10 state9 delta13 output10 -> Control.CustomTypeBuilder (a21 -> destructor1 -> restInputToStateConverters -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> restFns7 -> restStates8 -> List.List Control.Alert) deltaAfter deltaAfters (( Control.Delta delta14_1, a19 ) -> c7) (( ( Control.Delta delta14_1, a19 ) -> c7, a18 ) -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates7 -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> restFns5 -> restStates6 -> List.List Control.Alert) (Path.Path -> ( Control.ControlFns ( output13, ( output12, ( output11, ( output10, b ) ) ) ) ( Control.State state12, ( Control.State state11, ( Control.State state10, ( Control.State state9, Control.End ) ) ) ) ( Control.Delta delta16, ( Control.Delta delta15, ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) ) ) output9, a15 ) -> c5) (a14 -> Basics.Int -> restFns4 -> restStates5 -> restStates5) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta16, ( Control.Delta delta15, ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) ) )), a13 ) -> c4) (Path.Path -> ( Control.State ( Control.State state12, ( Control.State state11, ( Control.State state10, ( Control.State state9, Control.End ) ) ) ), a12 ) -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> restDeltaSetters2 -> restDeltas1 -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> befores -> afters -> next) (a9 -> { controlFns : restControlFns, deltaSetters : restDeltaSetters1, finalTagStates : nextFinalTagState -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : restInputTuplizers, maybeOverridesAfter : restMaybeOverridesAfter, maybeOverridesBefore : restMaybeOverridesBefore, tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output3) stateAfter stateAfters (( Maybe.Maybe a23, a6 ) -> c2) (( ( Maybe.Maybe a23, a6 ) -> c2, a5 ) -> c1) (a4 -> Basics.Int -> Basics.Int -> (restArgStates -> tagStates) -> restMaybeArgStates -> restArgStates -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> restSetters1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub delta1_1)) (( (( d, ( f, ( g, ( h, Control.End ) ) ) ) -> i) -> d -> f -> g -> h -> i, a2 ) -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> restFns -> restSetters -> restStates -> List.List (Control.Subcontrol delta)) -> Control.CustomTypeBuilder (a21 -> (inputToStateConverter -> destructor1) -> ( inputToStateConverter, restInputToStateConverters ) -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> ( Control.ControlFns input8 state8 delta11 output8, restFns7 ) -> ( Control.State state8, restStates8 ) -> List.List Control.Alert) ( Control.Delta delta10, deltaAfter ) ( deltaAfter, deltaAfters ) (a19 -> c7) (a18 -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input7 state7 delta9 output7, restFns6 ) -> ( Control.State state7, restStates7 ) -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input6 state6 delta8 output6, restFns5 ) -> ( Control.State state6, restStates6 ) -> List.List Control.Alert) (Path.Path -> a15 -> c5) (a14 -> Basics.Int -> ( Control.ControlFns input5 state5 delta7 output5, restFns4 ) -> ( Control.State state5, restStates5 ) -> ( Control.State state5, restStates5 )) (Path.Path -> a13 -> c4) (Path.Path -> a12 -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> ( delta6 -> delta1_2, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta6, restDeltas1 ) -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> ( ( value, after ) -> delta5, befores ) -> ( after, afters ) -> ( value -> delta5, next )) (a9 -> { controlFns : ( Control.ControlFns input4 state1_1 delta4 output4, restControlFns ), deltaSetters : ( Control.Delta delta4 -> tagDelta, restDeltaSetters1 ), finalTagStates : ( finalTagState, nextFinalTagState ) -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : ( (input4 -> ( Control.State tagStates1, Platform.Cmd.Cmd (Control.Delta tagDelta) )) -> finalTagState, restInputTuplizers ), maybeOverridesAfter : ( maybeOverrideAfter, restMaybeOverridesAfter ), maybeOverridesBefore : ( ( Maybe.Maybe (Control.State state1_1), maybeOverrideAfter ) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ), restMaybeOverridesBefore ), tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> ( Control.ControlFns input3 state3 delta3 output3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output3) ( Maybe.Maybe a7, stateAfter ) ( stateAfter, stateAfters ) (a6 -> c2) (a5 -> c1) (a4 -> Basics.Int -> Basics.Int -> (( Control.State argState, restArgStates ) -> tagStates) -> ( Maybe.Maybe (Control.State argState), restMaybeArgStates ) -> ( Control.State argState, restArgStates ) -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> ( Control.Delta delta2 -> delta1_1, restSetters1 ) -> ( Control.ControlFns input2 state2 delta2 output2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub delta1_1)) (a2 -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.ControlFns input1 state1 delta1 output1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta, restDeltaSetters ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> ( Control.ControlFns input state e output, restFns ) -> ( Control.Delta e -> delta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol delta))"},{"name":"tag5","comment":" Add a tag with five arguments to a custom type.\n","type":"String.String -> (output14 -> output13 -> output12 -> output11 -> output10 -> output9) -> Control.AdvancedControl output14 state13 delta17 output14 -> Control.AdvancedControl output13 state12 delta16 output13 -> Control.AdvancedControl output12 state11 delta15 output12 -> Control.AdvancedControl output11 state10 delta14 output11 -> Control.AdvancedControl output10 state9 delta13 output10 -> Control.CustomTypeBuilder (a21 -> destructor1 -> restInputToStateConverters -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> restFns7 -> restStates8 -> List.List Control.Alert) deltaAfter deltaAfters (( Control.Delta delta14_1, a19 ) -> c7) (( ( Control.Delta delta14_1, a19 ) -> c7, a18 ) -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> restFns6 -> restStates7 -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> restFns5 -> restStates6 -> List.List Control.Alert) (Path.Path -> ( Control.ControlFns ( output14, ( output13, ( output12, ( output11, ( output10, b ) ) ) ) ) ( Control.State state13, ( Control.State state12, ( Control.State state11, ( Control.State state10, ( Control.State state9, Control.End ) ) ) ) ) ( Control.Delta delta17, ( Control.Delta delta16, ( Control.Delta delta15, ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) ) ) ) output9, a15 ) -> c5) (a14 -> Basics.Int -> restFns4 -> restStates5 -> restStates5) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta ( Control.Delta delta17, ( Control.Delta delta16, ( Control.Delta delta15, ( Control.Delta delta14, ( Control.Delta delta13, Control.End ) ) ) ) )), a13 ) -> c4) (Path.Path -> ( Control.State ( Control.State state13, ( Control.State state12, ( Control.State state11, ( Control.State state10, ( Control.State state9, Control.End ) ) ) ) ), a12 ) -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> restDeltaSetters2 -> restDeltas1 -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> befores -> afters -> next) (a9 -> { controlFns : restControlFns, deltaSetters : restDeltaSetters1, finalTagStates : nextFinalTagState -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : restInputTuplizers, maybeOverridesAfter : restMaybeOverridesAfter, maybeOverridesBefore : restMaybeOverridesBefore, tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> restFns3 -> restStates3 -> Result.Result (List.List Control.Feedback) output3) stateAfter stateAfters (( Maybe.Maybe a23, a6 ) -> c2) (( ( Maybe.Maybe a23, a6 ) -> c2, a5 ) -> c1) (a4 -> Basics.Int -> Basics.Int -> (restArgStates -> tagStates) -> restMaybeArgStates -> restArgStates -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> restSetters1 -> restFns2 -> restStates2 -> List.List (Platform.Sub.Sub delta1_1)) (( (( d, ( f, ( g, ( h, ( i, Control.End ) ) ) ) ) -> j) -> d -> f -> g -> h -> i -> j, a2 ) -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : restStates1 -> recordState0 } -> restFns1 -> restDeltaSetters -> restDeltas -> restStates1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> restFns -> restSetters -> restStates -> List.List (Control.Subcontrol delta)) -> Control.CustomTypeBuilder (a21 -> (inputToStateConverter -> destructor1) -> ( inputToStateConverter, restInputToStateConverters ) -> tag -> ( Control.State tagStates2, Platform.Cmd.Cmd delta12 )) (a20 -> List.List Control.Alert -> ( Control.ControlFns input8 state8 delta11 output8, restFns7 ) -> ( Control.State state8, restStates8 ) -> List.List Control.Alert) ( Control.Delta delta10, deltaAfter ) ( deltaAfter, deltaAfters ) (a19 -> c7) (a18 -> c6) destructor (a17 -> List.List Control.Alert -> List.List Control.Feedback -> ( Control.ControlFns input7 state7 delta9 output7, restFns6 ) -> ( Control.State state7, restStates7 ) -> List.List Control.Feedback) (a16 -> List.List Control.Alert -> Basics.Int -> ( Control.ControlFns input6 state6 delta8 output6, restFns5 ) -> ( Control.State state6, restStates6 ) -> List.List Control.Alert) (Path.Path -> a15 -> c5) (a14 -> Basics.Int -> ( Control.ControlFns input5 state5 delta7 output5, restFns4 ) -> ( Control.State state5, restStates5 ) -> ( Control.State state5, restStates5 )) (Path.Path -> a13 -> c4) (Path.Path -> a12 -> c3) (a11 -> List.List (Platform.Cmd.Cmd delta1_2) -> ( delta6 -> delta1_2, restDeltaSetters2 ) -> ( Platform.Cmd.Cmd delta6, restDeltas1 ) -> List.List (Platform.Cmd.Cmd delta1_2)) (a10 -> ( ( value, after ) -> delta5, befores ) -> ( after, afters ) -> ( value -> delta5, next )) (a9 -> { controlFns : ( Control.ControlFns input4 state1_1 delta4 output4, restControlFns ), deltaSetters : ( Control.Delta delta4 -> tagDelta, restDeltaSetters1 ), finalTagStates : ( finalTagState, nextFinalTagState ) -> restFinalTagStates, initialTagStates : ( Control.State state4, restStates4 ), inputTuplizers : ( (input4 -> ( Control.State tagStates1, Platform.Cmd.Cmd (Control.Delta tagDelta) )) -> finalTagState, restInputTuplizers ), maybeOverridesAfter : ( maybeOverrideAfter, restMaybeOverridesAfter ), maybeOverridesBefore : ( ( Maybe.Maybe (Control.State state1_1), maybeOverrideAfter ) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ), restMaybeOverridesBefore ), tagStateOverrider : (Basics.Int -> Basics.Int -> (Control.End -> tagStates1) -> Control.End -> Control.End -> Control.State tagStates1) -> Basics.Int -> Basics.Int -> (identity -> identity) -> ( Maybe.Maybe (Control.State state4), restMaybeStates ) -> ( Control.State state4, restStates4 ) -> Control.State tagStates1 } -> toFinalTagStates) (a8 -> Result.Result (List.List Control.Feedback) output3 -> Basics.Int -> ( Control.ControlFns input3 state3 delta3 output3, restFns3 ) -> ( Control.State state3, restStates3 ) -> Result.Result (List.List Control.Feedback) output3) ( Maybe.Maybe a7, stateAfter ) ( stateAfter, stateAfters ) (a6 -> c2) (a5 -> c1) (a4 -> Basics.Int -> Basics.Int -> (( Control.State argState, restArgStates ) -> tagStates) -> ( Maybe.Maybe (Control.State argState), restMaybeArgStates ) -> ( Control.State argState, restArgStates ) -> Control.State tagStates) (a3 -> List.List (Platform.Sub.Sub delta1_1) -> ( Control.Delta delta2 -> delta1_1, restSetters1 ) -> ( Control.ControlFns input2 state2 delta2 output2, restFns2 ) -> ( Control.State state2, restStates2 ) -> List.List (Platform.Sub.Sub delta1_1)) (a2 -> c) (a1 -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : ( Control.State state1, restStates1 ) -> recordState0 } -> ( Control.ControlFns input1 state1 delta1 output1, restFns1 ) -> ( Control.Delta delta1 -> recordDelta, restDeltaSetters ) -> ( Control.Delta delta1, restDeltas ) -> ( Control.State state1, restStates1 ) -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta), newStates : recordState }) (a -> List.List (Control.Subcontrol delta) -> List.List Control.Alert -> ( Control.ControlFns input state e output, restFns ) -> ( Control.Delta e -> delta, restSetters ) -> ( Control.State state, restStates ) -> List.List (Control.Subcontrol delta))"},{"name":"triple","comment":" A combinator that produces a triple of three controls of given types.\n\n    myTripleControl =\n        triple string int float\n\n","type":"Control.Control state1 delta1 output1 -> Control.Control state2 delta2 output2 -> Control.Control state3 delta3 output3 -> Control.Control ( Control.State state1, ( Control.State state2, ( Control.State state3, Control.End ) ) ) ( Control.Delta delta1, ( Control.Delta delta2, ( Control.Delta delta3, Control.End ) ) ) ( output1, output2, output3 )"},{"name":"tuple","comment":" A combinator that produces a tuple of two controls of given types.\n\n    myTupleControl =\n        tuple string int\n\n","type":"Control.Control state1 delta1 output1 -> Control.Control state2 delta2 output2 -> Control.Control ( Control.State state1, ( Control.State state2, Control.End ) ) ( Control.Delta delta1, ( Control.Delta delta2, Control.End ) ) ( output1, output2 )"},{"name":"wrapView","comment":" Transform the HTML output of a `Control`'s view function.\n\n    wrappedInt =\n        int\n            |> wrapView (\\view -> [ Html.div [] view ])\n\n","type":"(List.List (Html.Html (Control.Delta delta)) -> List.List (Html.Html (Control.Delta delta))) -> Control.Control state delta output -> Control.Control state delta output"}],"binops":[]}]