[{"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, tuple, Triple, triple, Maybe_, maybe, Result_, result, List_, list, Dict_, dict, Set_, set, Array_, array, Mapping, map\n\n\n# Building record combinators\n\n@docs Record, Field, EndRecord, RecordBuilder, record, field, endRecord, LayoutConfig, Subcontrol, layout\n\n\n# Building custom type combinators\n\n@docs CustomType, Variant, Arg, EndVariant, EndCustomType, CustomTypeBuilder, customType, variant0, variant1, variant2, variant3, variant4, variant5, endCustomType\n\n\n# Creating a new control\n\n@docs Definition, define\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 import Control exposing (Control, Record, Field, EndRecord, record, field, endRecord, string, alertIf, respond)\n\n record\n (\\password confirmation ->\n { password = password\n , confirmation = confirmation\n }\n )\n |> field .password string\n |> field .confirmation\n (string\n |> respond\n { alert = \"passwords-do-not-match\"\n , fail = True\n , message = \"Passwords must match\"\n , class = \"control-feedback-fail\"\n }\n )\n |> endRecord\n |> alertIf\n (\\{ password, confirmation } ->\n password /= confirmation\n )\n \"passwords-do-not-match\"\n\n --: Control context (Record (Field String (Field String EndRecord))) (Record (Field String (Field String EndRecord))) { password : String, confirmation : String }\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# Forms with context\n\nFor some advanced use cases, you may want to create a form that knows about more\nthan its own internal state. It may also need to know about some state that \nlives elsewhere in your app's `Model`.\n\nThis is where the `...WithContext` family of types and functions come into play.\nThey allow you to inject some external state into your form controls by\npassing a `context` value as an additional argument to the form's `update`,\n`view`, `subscriptions` and `submit` functions. \n\nYou can also pass `context` into any validations you apply to your `Controls` \nusing `failIfWithContext`, `noteIfWithContext` etc.\n\n@docs FormWithContext, simpleFormWithContext, formWithContext, DefinitionWithContext, defineWithContext, failIfWithContext, noteIfWithContext, alertIfWithContext, alertAtIndexesWithContext\n\n\n# State and Delta types\n\nThese are types that you will see in your form's `State` and `Delta` type signatures.\n\n@docs State, Delta\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, End\n\n","unions":[{"name":"AdvancedControl","comment":" A slightly more flexible version of `Control`, which is only used\ninternally. As a user of the package, you shouldn't need to worry about this\ntype.\n","args":["context","input","state","delta","output"],"cases":[]},{"name":"Alert","comment":" Some internal stuff needed to handle validations\n","args":[],"cases":[]},{"name":"Arg","comment":" A type that can contain the `state` or `delta` of an argument for a variant within a custom type control.\n","args":["arg","restArgs"],"cases":[]},{"name":"Array_","comment":" A type used to contain the `state` or `delta` of an `array` control.\n","args":["a"],"cases":[]},{"name":"ControlFns","comment":" Some internal stuff needed to build up record and custom type controls\n","args":["context","input","state","delta","output"],"cases":[]},{"name":"CustomType","comment":" A type used to contain the `state` or `delta` of a custom type control.\n","args":["customType"],"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","initialCmds","initialStates","initialiseDeltas","makeDeltaSetters","makeStateSetters","parser","stateAfter","stateAfters","stateBefore","stateBefores","stateInserter","subscriptionCollector","toArgStates","updater","viewer","stateWrapper","stateUnwrapper","deltaWrapper","deltaUnwrapper","emptyDeltas"],"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":[["NoDelta",[]],["StateChangedByInput",["delta"]],["StateChangedInternally",["delta"]],["DebounceTimerSet",["Time.Posix"]],["DebounceTimerExpired",["Time.Posix"]],["TagSelected",["Basics.Int"]]]},{"name":"Dict_","comment":" A type used to contain the `state` or `delta` of a `dict` control.\n","args":["k","v"],"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":"EndCustomType","comment":" A type used to mark the end of the type annotation for a custom type control.\n","args":[],"cases":[]},{"name":"EndRecord","comment":" A type used to mark the end of the type annotation for a custom type control.\n","args":[],"cases":[]},{"name":"EndVariant","comment":" A type used to mark the end of the type annotation for a variant within a custom type control.\n","args":[],"cases":[]},{"name":"Field","comment":" A type used to contain the `state` or `delta` of a `field` within a `record` control.\n","args":["field","restFields"],"cases":[]},{"name":"List_","comment":" A type used to contain the `state` or `delta` of a `list` control.\n","args":["a"],"cases":[]},{"name":"Mapping","comment":" A type used to contain the `state` or `delta` type for a control whose output has been converted using `map`.\n","args":["a"],"cases":[]},{"name":"Maybe_","comment":" A type used to contain the `state` or `delta` types for a `maybe` control.\n","args":["a"],"cases":[]},{"name":"Record","comment":" A type used to contain the `state` or `delta` of a `record` control.\n","args":["record"],"cases":[]},{"name":"RecordBuilder","comment":" A data structure used to build records\n","args":["after","afters","before","befores","debouncingReceiverCollector","deltaInitialiser","errorCollector","alertEmitter","fns","idleSetter","initialCmds","initialStates","initialiser","makeSetters","parser","subscriptionCollector","toOutput","updater","viewer","stateWrapper","stateUnwrapper","deltaWrapper","deltaUnwrapper","emptyDeltas"],"cases":[]},{"name":"RecordFns","comment":" Some internal stuff needed to build up a record control\n","args":["context","input","state","delta","output","recordOutput"],"cases":[]},{"name":"Result_","comment":" A type used to contain the `state` or `delta` types for a `result` control.\n","args":["err","ok"],"cases":[]},{"name":"Set_","comment":" A type used to contain the `state` or `delta` of a `set` control.\n","args":["a"],"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":[]},{"name":"Triple","comment":" A type used to contain the `state`s or `delta`s of a `triple` control.\n","args":["a","b","c"],"cases":[]},{"name":"Tuple","comment":" A type used to contain the `state`s or `delta`s of a `tuple` control.\n","args":["fst","snd"],"cases":[]},{"name":"Variant","comment":" A type used to contain the `state` or `delta` of a variant for a custom type control.\n","args":["args","restTags"],"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":["context","state","delta","output"],"type":"Control.AdvancedControl context output state delta output"},{"name":"Definition","comment":" Definition for a custom control. You need to supply the following fields:\n\n - `blank`: an initial \"empty\" value for the `state` of the control, plus an initial (optional) `Cmd` to run. For a control whose `state` is of type `String`, the state value might be `\"\"`, for a number it might be `0`.\n - `prefill`: a function that uses a value of the control's `output` type to initialise the control's `state` and (optionally) run an initial `Cmd`. For a control that outputs an `Int`, but whose `state` is a `String`, you might use `String.fromInt` to convert the `output` value into a `state` value.\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 - `label`: a default label for the control.\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":"DefinitionWithContext","comment":" Definition for a custom control that is aware of its context.\n\nThis is exactly like the standard `Definition` type, except that the `update`,\n`view`, `subscriptions` and `parse` functions all take an additional `context`\nas their first argument.\n\n","args":["context","state","delta","output"],"type":"{ blank : ( state, Platform.Cmd.Cmd delta ), prefill : output -> ( state, Platform.Cmd.Cmd delta ), update : context -> delta -> state -> ( state, Platform.Cmd.Cmd delta ), view : context -> { label : String.String, id : String.String, name : String.String, class : String.String, state : state } -> List.List (Html.Html delta), subscriptions : context -> state -> Platform.Sub.Sub delta, parse : context -> 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, class : String.String, fail : Basics.Bool }"},{"name":"Form","comment":" A `Form` is a record which contains 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":"FormWithContext","comment":" A `FormWithContext` is a record which contains functions that you can use in your\nElm `Program` to initialise, view, update, subscribe, and submit your form.\n\nUnlike the standard `Form`, several of the functions provided by `FormWithContext`\ntake an extra `context` parameter, which allows you to feed external data (e.g. from\nyour app's `Model`) into your form and allow the form to respond accordingly.\n\nFor example, imagine your app's `Model` contains a list of users, and you build\na form to create a new user. The new user should only be valid if their name \nhasn't already been chosen by another user. \n\nWe can ensure this by passing the set of existing user names into the form's \nupdate and submit functions as `context`:\n\n import Control exposing (Control, FormWithContext, State, Delta, string, failIfWithContext, simpleFormWithContext)\n import Set\n\n type alias User =\n String\n\n type alias Model =\n { formState : State String\n , existingUsers : Set.Set String\n }\n\n type alias Context = \n Set.Set String\n\n type Msg\n = FormUpdated (Delta String)\n | FormSubmitted\n\n userControl =\n string\n |> failIfWithContext\n (\\existingUsers newUser ->\n Set.member newUser existingUsers\n )\n \"User already exists\"\n\n userControl \n\n --: Control Context String String String\n\n form =\n simpleFormWithContext\n { control = userControl\n , onUpdate = FormUpdated\n , onSubmit = FormSubmitted\n }\n\n form\n \n --: FormWithContext Context String String String Msg\n\n update msg model =\n let\n context = \n model.existingUsers\n in\n case msg of\n FormUpdated delta ->\n let\n (formState, cmd) =\n form.update context delta model.formState\n in\n ( { model | formState = formState }, cmd )\n\n FormSubmitted -> \n let\n (newFormState, formResult) = \n form.submit context model.formState\n in\n case formResult of\n Ok user -> \n let \n ( blankFormState, cmd ) =\n form.blank\n in\n ( { model \n | existingUsers = Set.insert user model.existingUsers \n , formState = blankFormState\n }\n , cmd\n )\n\n Err err ->\n ( { model | formState = newFormState }\n , Cmd.none \n )\n","args":["context","state","delta","output","msg"],"type":"{ blank : ( Control.State state, Platform.Cmd.Cmd msg ), prefill : output -> ( Control.State state, Platform.Cmd.Cmd msg ), update : context -> Control.Delta delta -> Control.State state -> ( Control.State state, Platform.Cmd.Cmd msg ), view : context -> Control.State state -> Html.Html msg, subscriptions : context -> Control.State state -> Platform.Sub.Sub msg, submit : context -> 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 import Control exposing (Control, List_, alertAtIndexes, list, respond, string)\n\n myString =\n string\n |> respond\n { alert = \"no-hello-world\"\n , fail = True\n , message = \"List can't start with \\\"hello\\\" and \\\"world\\\".\"\n , class = \"control-feedback-fail\"\n }\n\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 --: Control context (List_ String) (List_ String) (List String)\n\n","type":"(output -> List.List Basics.Int) -> String.String -> Control.Control context (Control.List_ state) (Control.List_ delta) output -> Control.Control context (Control.List_ state) (Control.List_ delta) output"},{"name":"alertAtIndexesWithContext","comment":" Conditionally display an error on one or more items in a `list` control,\nbased on the output of the `list` control and the supplied `context`.\n","type":"(context -> output -> List.List Basics.Int) -> String.String -> Control.Control context (Control.List_ state) (Control.List_ delta) output -> Control.Control context (Control.List_ state) (Control.List_ delta) output"},{"name":"alertIf","comment":" Emit an alert from a `Control` if the supplied predicate function returns\n`True`.\n\nThis is most useful with control combinators such as `tuple` or `record`,\nbecause it enables you to perform validations that involve multiple fields\nwithin the tuple or record.\n\n import Control exposing (Control, Tuple, alertIf, tuple, int, string)\n\n tuple int string\n |> alertIf (\\( x, y ) -> x > 0) \"int-greater-than-zero\"\n\n --: Control context (Tuple String String) (Tuple String String) ( Int, String )\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 context state delta output -> Control.Control context state delta output"},{"name":"alertIfWithContext","comment":" Emit an alert from a `Control` if the supplied predicate function returns\n`True`; another control can then react to this alert by using `respond`.\n\n`alertIfWithContext` works exactly like `alertIf`, except that its predicate\nfunction takes a `context` as its first argument.\n\n","type":"(context -> output -> Basics.Bool) -> String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"array","comment":" A combinator that produces an `Array` from a control of a given type.\n\n import Control exposing (Control, Array_, array, int)\n import Array\n\n array int\n\n --: Control context (Array_ String) (Array_ String) (Array.Array Int)\n\n","type":"Control.Control context state delta output -> Control.Control context (Control.Array_ state) (Control.Array_ delta) (Array.Array output)"},{"name":"bool","comment":" A control that produces a `Bool`. Renders as an HTML checkbox. Default output is `False`.\n\n import Control exposing (Control, bool)\n\n bool\n\n --: Control context Bool Bool Bool\n\n","type":"Control.Control context Basics.Bool Basics.Bool Basics.Bool"},{"name":"char","comment":" A control that produces a `Char`. Renders as an HTML text input.\n\n import Control exposing (Control, char)\n\n char\n\n --: Control context String String Char\n\n","type":"Control.Control context 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 import Control exposing (Control, string, class)\n\n string\n |> class \"important\"\n |> class \"no-really\"\n\n --: Control context String String String\n\n","type":"String.String -> Control.Control context state delta output -> Control.Control context 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 import Control exposing (Control, string, classList)\n\n string\n |> classList\n [ ( \"important\", True )\n , ( \"no-really\", True )\n , ( \"ignore-me\", False )\n ]\n\n --: Control context String String String\n\n","type":"List.List ( String.String, Basics.Bool ) -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"customType","comment":" A combinator that produces a custom type.\n\n import Control exposing (Control, CustomType, Variant, Arg, EndVariant, EndCustomType, customType, variant0, variant1, variant2, endCustomType, string, int, float)\n\n type MyCustomType\n = NoArgs\n | OneArg String\n | TwoArgs Int Float\n\n\n customType\n (\\noArgs oneArg twoArgs variant ->\n case variant of\n NoArgs ->\n noArgs\n\n OneArg arg1 ->\n oneArg arg1\n\n TwoArgs arg1 arg2 ->\n twoArgs arg1 arg2\n )\n |> variant0 \"NoArgs\" NoArgs\n |> variant1 \"OneArg\" OneArg string\n |> variant2 \"TwoArgs\" TwoArgs int float\n |> endCustomType\n\n --: Control context (Control.CustomType (Control.Variant Control.EndVariant (Control.Variant (Control.Arg String Control.EndVariant) (Control.Variant (Control.Arg String (Control.Arg String Control.EndVariant)) Control.EndCustomType)))) (Control.CustomType (Control.Variant Control.EndVariant (Control.Variant (Control.Arg String Control.EndVariant) (Control.Variant (Control.Arg String (Control.Arg String Control.EndVariant)) Control.EndCustomType)))) MyCustomType\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) (stateWrapper -> stateWrapper) (stateUnwrapper -> stateUnwrapper) (deltaWrapper -> deltaWrapper) (deltaUnwrapper -> deltaUnwrapper) Control.End"},{"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 import Control exposing (Control, string, debounce)\n\n string\n |> debounce 2000\n\n --: Control context String String String\n\n","type":"Basics.Float -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"default","comment":" Set a default `output` value for a `Control`.\n\n import Control exposing (Control, Tuple, default, int, string, tuple)\n\n tuple int string\n |> default ( 1, \"hello\" )\n\n --: Control context (Tuple String String) (Tuple String String) ( Int, String )\n\n","type":"output -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"define","comment":" Define a new type of `Control`, with any arbitrary `state` and `delta` types,\nand producing any arbitrary `output` type.\n\nHere's how we could define a control like the famous\n[counter example](https://elm-lang.org/examples/buttons) from the Elm Guide\n\n import Control exposing (Control, define)\n import Html\n import Html.Attributes\n import Html.Events\n\n type CounterDelta\n = Increment\n | Decrement\n\n define\n { blank = ( 0, Cmd.none )\n , prefill = \\n -> ( n, Cmd.none )\n , update =\n \\delta state ->\n case delta of\n Increment ->\n ( state + 1, Cmd.none )\n\n Decrement ->\n ( state - 1, Cmd.none )\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 ]\n , subscriptions = \\state -> Sub.none\n , parse = Ok\n , label = \"Counter\"\n }\n\n --: Control context Int CounterDelta Int\n\n","type":"Control.Definition state delta output -> Control.Control context state delta output"},{"name":"defineWithContext","comment":" Define a new type of `Control`, with any arbitrary `state`, `delta` and\n`output` types, and that is aware of whatever `context` you choose to supply.\n\nHere's a silly version of the [counter example](https://elm-lang.org/examples/buttons) \nwhere we use a `context` to supply maximum and minimum bounds that the counter\nshould stay within. We then implement various measures in the update, view, parse \nand subscriptions functions to try to prevent the count from going outside those \nbounds.\n\n import Control exposing (Control, defineWithContext)\n import Html\n import Html.Attributes\n import Html.Events\n import Time\n\n type CounterDelta\n = Increment\n | Decrement\n\n type alias Context =\n { maxCount : Int, minCount : Int }\n\n defineWithContext\n { blank = ( 0, Cmd.none )\n , prefill = \\x -> ( x, Cmd.none )\n , update =\n \\context delta state ->\n -- When an increment/decrement message comes in, check whether\n -- it would cause the count to go beyond the bounds set by the\n -- context\n (case delta of\n Increment -> if state < context.maxCount then state + 1 else state\n Decrement -> if state > context.minCount then state - 1 else state\n , Cmd.none\n )\n , view =\n \\context { state, name, id, label, class } ->\n -- Disable the increment/decrement buttons if they would \n -- cause the count to go beyond the bounds set by the context\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 , Html.Attributes.disabled (state >= context.maxCount)\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 , Html.Attributes.disabled (state <= context.minCount)\n ]\n [ Html.text \"-\" ]\n ]\n ]\n ]\n , subscriptions =\n \\context state ->\n -- Every 1 second, increment or decrement the count until \n -- it's back within the bounds set by the context\n if state > context.maxCount then\n Time.every 1000 (\\_ -> Decrement)\n else if state < context.minCount then\n Time.every 1000 (\\_ -> Increment)\n else \n Sub.none\n , parse =\n \\context state ->\n -- Fail validation if the count is outside the bounds set\n -- by the context\n if state > context.maxCount || state < context.minCount then\n Err [ \"count is out of bounds!\" ]\n\n else\n Ok state\n , label = \"Counter\"\n }\n\n --: Control Context Int CounterDelta Int\n","type":"Control.DefinitionWithContext context state delta output -> Control.Control context 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 import Control exposing (Control, Dict_, dict, string, bool)\n import Dict\n\n dict string bool\n\n --: Control context (Dict_ String Bool) (Dict_ String Bool) (Dict.Dict String Bool)\n\n","type":"Control.Control context keyState keyDelta comparable -> Control.Control context valueState valueDelta value -> Control.Control context (Control.Dict_ keyState valueState) (Control.Dict_ keyDelta valueDelta) (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 helloControl =\n customType\n (\\bar baz variant ->\n case variant of\n Bar -> bar\n Baz -> baz\n )\n |> variant0 \"Bar\" Bar\n |> variant0 \"Baz\" Baz\n |> endCustomType\n\n","type":"Control.CustomTypeBuilder (({ destructor : input -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta (Control.CustomType (Control.Variant tagDelta restDeltaTags))) ), inputToStateConverters : Control.End } -> input -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta (Control.CustomType (Control.Variant tagDelta restDeltaTags))) )) -> { destructor : inputToStateConverter -> destructor, inputToStateConverters : ( inputToStateConverter, restInputToStateConverters ) } -> input -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Delta (Control.CustomType (Control.Variant tagDelta restDeltaTags))) )) (({ fns : Control.End, receivers : List.List Control.Alert, states : Control.End } -> List.List Control.Alert) -> { fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), receivers : List.List Control.Alert, states : ( Control.State state, restStates ) } -> List.List Control.Alert) deltaAfter deltaAfters deltaBefore (Control.End -> b) (inputToStateConverter -> destructor) (({ alerts : List.List Control.Alert, feedback : List.List Control.Feedback, fns : Control.End, states : Control.End } -> List.List Control.Feedback) -> { alerts : List.List Control.Alert, feedback : List.List Control.Feedback, fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), states : ( Control.State state, restStates ) } -> List.List Control.Feedback) (({ alerts : List.List Control.Alert, context : context, fns : Control.End, selectedTag : Basics.Int, states : Control.End } -> List.List Control.Alert) -> { alerts : List.List Control.Alert, context : context, fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), selectedTag : Basics.Int, states : ( Control.State state, restStates ) } -> List.List Control.Alert) (Control.Path -> Control.End -> ( Control.ControlFns context input1 state tagDelta output, restFns )) (({ fns : Control.End, initialStates : Control.End, selectedTag : Basics.Int, toFinalStates : Control.End -> ( Control.State state, restStates ) } -> ( Control.State state, restStates )) -> { fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), initialStates : ( Control.State state, restStates ), selectedTag : Basics.Int, toFinalStates : identity2 -> identity2 } -> ( Control.State state, restStates )) (Control.Path -> Control.End -> ( Platform.Cmd.Cmd (Control.Delta tagDelta), restDeltas1 )) (Control.Path -> Control.End -> ( Control.State state, restStates )) (({ cmds : List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags))), deltaSetters : Control.End, deltas : Control.End } -> List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags)))) -> { cmds : List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags))), deltaSetters : ( Control.Delta tagDelta -> Control.CustomType (Control.Variant tagDelta restDeltaTags), restDeltaSetters ), deltas : ( Platform.Cmd.Cmd (Control.Delta tagDelta), restDeltas1 ) } -> List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags)))) (({ e | output : Control.End -> d } -> d) -> { afters : deltaAfters, befores : b, output : a -> a, wrapDeltas : ( Control.Delta delta, restDeltaTuples ) -> Control.CustomType (Control.Variant delta restDeltaTags1) } -> ( Control.Delta tagDelta -> Control.CustomType (Control.Variant tagDelta restDeltaTags), restDeltaSetters )) (({ c | finalTagStates : Control.End -> ( inputToStateConverter, restInputToStateConverters ) } -> ( inputToStateConverter, restInputToStateConverters )) -> { controlFns : ( Control.ControlFns context input1 state tagDelta output, restFns ), deltaSetters : ( Control.Delta tagDelta -> Control.CustomType (Control.Variant tagDelta restDeltaTags), restDeltaSetters ), finalTagStates : identity1 -> identity1, initialTagStates : ( Control.State state, restStates ), inputTuplizers : inputTuplizers, maybeOverridesAfter : maybeOverridesAfter, maybeOverridesBefore : maybeOverridesBefore, tagStateOverrider : tagStateOverrider } -> ( inputToStateConverter, restInputToStateConverters )) (({ context : context, fns : Control.End, parsedResult : Result.Result (List.List Control.Feedback) output, selectedTag : Basics.Int, states : Control.End } -> Result.Result (List.List Control.Feedback) output) -> { context : context, fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), parsedResult : Result.Result (List.List Control.Feedback) output, selectedTag : Basics.Int, states : ( Control.State state, restStates ) } -> Result.Result (List.List Control.Feedback) output) stateAfter maybeOverridesAfter stateBefore (Control.End -> maybeOverridesBefore) tagStateOverrider (({ context : context, deltaSetters : Control.End, fns : Control.End, states : Control.End, subs : List.List (Platform.Sub.Sub (Control.CustomType (Control.Variant tagDelta restDeltaTags))) } -> List.List (Platform.Sub.Sub (Control.CustomType (Control.Variant tagDelta restDeltaTags)))) -> { context : context, deltaSetters : ( Control.Delta tagDelta -> Control.CustomType (Control.Variant tagDelta restDeltaTags), restDeltaSetters ), fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), states : ( Control.State state, restStates ), subs : List.List (Platform.Sub.Sub (Control.CustomType (Control.Variant tagDelta restDeltaTags))) } -> List.List (Platform.Sub.Sub (Control.CustomType (Control.Variant tagDelta restDeltaTags)))) (Control.End -> inputTuplizers) (({ context : context, deltaSetters : Control.End, deltas : Control.End, fns : Control.End, newCmds : List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags))), newStates : Control.End -> ( Control.State state, restStates ), states : Control.End } -> { newCmds : List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags))), newStates : Control.End -> ( Control.State state, restStates ) }) -> { context : context, deltaSetters : ( Control.Delta tagDelta -> Control.CustomType (Control.Variant tagDelta restDeltaTags), restDeltaSetters ), deltas : ( Control.Delta tagDelta, restDeltas ), fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), newCmds : List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags))), newStates : identity -> identity, states : ( Control.State state, restStates ) } -> { newCmds : List.List (Platform.Cmd.Cmd (Control.CustomType (Control.Variant tagDelta restDeltaTags))), newStates : Control.End -> ( Control.State state, restStates ) }) (({ g | subcontrols : f } -> f) -> { alerts : List.List Control.Alert, context : context, deltaSetters : ( Control.Delta tagDelta -> Control.CustomType (Control.Variant tagDelta restDeltaTags), restDeltaSetters ), fns : ( Control.ControlFns context input1 state tagDelta output, restFns ), states : ( Control.State state, restStates ), subcontrols : List.List h } -> List.List { i | html : List.List (Html.Html (Control.CustomType (Control.Variant tagDelta restDeltaTags))), index : Basics.Int, label : String.String }) ((Control.End -> Control.EndCustomType) -> ( Control.State state, restStates ) -> Control.Variant state restStateTags) ((Control.EndCustomType -> Maybe.Maybe Control.End) -> Control.Variant state restStateTags -> Maybe.Maybe ( Control.State state, restStates )) ((Control.End -> Control.EndCustomType) -> ( Control.Delta delta, restDeltaTuples ) -> Control.Variant delta restDeltaTags1) ((Control.EndCustomType -> Maybe.Maybe Control.End) -> Control.Variant tagDelta restDeltaTags -> Maybe.Maybe ( Control.Delta tagDelta, restDeltas )) ( Control.Delta tagDelta, restDeltas ) -> Control.AdvancedControl context input (Control.CustomType (Control.Variant state restStateTags)) (Control.CustomType (Control.Variant tagDelta restDeltaTags)) output"},{"name":"endRecord","comment":" Finalise the construction of a `record` combinator.\n\n import Control exposing (Control, Record, Field, EndRecord, record, field, endRecord, string)\n\n type alias Hello =\n { hello : String }\n\n record Hello\n |> field .hello string\n |> endRecord\n\n --: Control context (Record (Field String EndRecord)) (Record (Field String EndRecord)) Hello\n\n","type":"Control.RecordBuilder after afters before (Control.End -> b) (({ alerts : List.List Control.Alert, fns : Control.End, states : Control.End } -> List.List Control.Alert) -> { alerts : List.List Control.Alert, fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), states : ( Control.State state, restStates ) } -> List.List Control.Alert) (({ cmds : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), deltaSetters : Control.End, fieldDeltas : Control.End } -> List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields)))) -> { cmds : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), deltaSetters : ( Control.Delta delta -> Control.Record (Control.Field delta restDeltaFields), restDeltaSetters ), fieldDeltas : a1 } -> List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields)))) (({ alerts : List.List Control.Alert, feedback : List.List Control.Feedback, fns : Control.End, states : Control.End } -> List.List Control.Feedback) -> { alerts : List.List Control.Alert, feedback : List.List Control.Feedback, fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), states : ( Control.State state, restStates ) } -> List.List Control.Feedback) (({ alerts : List.List Control.Alert, context : context, fns : Control.End, states : Control.End } -> List.List Control.Alert) -> { alerts : List.List Control.Alert, context : context, fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), states : ( Control.State state, restStates ) } -> List.List Control.Alert) (Control.Path -> Control.End -> ( Control.RecordFns context input1 state delta output1 recordInput, restFns )) (({ fns : Control.End, inputStates : Control.End, outputStates : Control.End -> ( Control.State state, restStates ) } -> ( Control.State state, restStates )) -> { fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), inputStates : ( Control.State state, restStates ), outputStates : identity1 -> identity1 } -> ( Control.State state, restStates )) (Control.Path -> Control.End -> a1) (Control.Path -> Control.End -> ( Control.State state, restStates )) (({ deltaSetters : Control.End, deltas : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), fns : Control.End, recordInput : input, states : Control.End -> ( Control.State state, restStates ) } -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields)) )) -> { deltaSetters : ( Control.Delta delta -> Control.Record (Control.Field delta restDeltaFields), restDeltaSetters ), deltas : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), recordInput : input, states : identity -> identity } -> ( Control.State ( Control.State state, restStates ), Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields)) )) (({ f | output : Control.End -> c } -> c) -> { afters : afters, befores : b, output : a -> a, wrapDeltas : ( Control.Delta delta, restDeltas ) -> Control.Record (Control.Field delta restDeltaFields) } -> ( Control.Delta delta -> Control.Record (Control.Field delta restDeltaFields), restDeltaSetters )) (({ context : context, fns : Control.End, states : Control.End, toOutputResult : Result.Result (List.List Control.Feedback) output } -> Result.Result (List.List Control.Feedback) output) -> { context : context, fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), states : ( Control.State state, restStates ), toOutputResult : Result.Result (List.List Control.Feedback) output1_1 } -> Result.Result (List.List Control.Feedback) output) (({ context : context, fns : Control.End, listSubs : List.List (Platform.Sub.Sub (Control.Record (Control.Field delta restDeltaFields))), setters : Control.End, states : Control.End } -> List.List (Platform.Sub.Sub (Control.Record (Control.Field delta restDeltaFields)))) -> { context : context, fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), listSubs : List.List (Platform.Sub.Sub (Control.Record (Control.Field delta restDeltaFields))), setters : ( Control.Delta delta -> Control.Record (Control.Field delta restDeltaFields), restDeltaSetters ), states : ( Control.State state, restStates ) } -> List.List (Platform.Sub.Sub (Control.Record (Control.Field delta restDeltaFields)))) output1_1 (({ context : context, deltaSetters : Control.End, deltas : Control.End, fns : Control.End, newCmds : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), newStates : Control.End -> ( Control.State state, restStates ), states : Control.End } -> { newCmds : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), newStates : Control.End -> ( Control.State state, restStates ) }) -> { context : context, deltaSetters : ( Control.Delta delta -> Control.Record (Control.Field delta restDeltaFields), restDeltaSetters ), deltas : ( Control.Delta delta, restDeltas ), fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), newCmds : List.List e, newStates : d -> d, states : ( Control.State state, restStates ) } -> { newCmds : List.List (Platform.Cmd.Cmd (Control.Record (Control.Field delta restDeltaFields))), newStates : Control.End -> ( Control.State state, restStates ) }) (({ alerts : List.List Control.Alert, context : context, deltaSetters : Control.End, fns : Control.End, states : Control.End, views : List.List (Control.Subcontrol (Control.Record (Control.Field delta restDeltaFields))) } -> List.List (Control.Subcontrol (Control.Record (Control.Field delta restDeltaFields)))) -> { alerts : List.List Control.Alert, context : context, deltaSetters : ( Control.Delta delta -> Control.Record (Control.Field delta restDeltaFields), restDeltaSetters ), fns : ( Control.RecordFns context input1 state delta output1 recordInput, restFns ), states : ( Control.State state, restStates ), views : List.List (Control.Subcontrol (Control.Record (Control.Field delta restDeltaFields))) } -> List.List (Control.Subcontrol (Control.Record (Control.Field delta restDeltaFields)))) ((Control.End -> Control.EndRecord) -> ( Control.State state, restStates ) -> Control.Field state restStateFields) ((Control.EndRecord -> Maybe.Maybe Control.End) -> Control.Field state restStateFields -> Maybe.Maybe ( Control.State state, restStates )) ((Control.End -> Control.EndRecord) -> ( Control.Delta delta, restDeltas ) -> Control.Field delta restDeltaFields) ((Control.EndRecord -> Maybe.Maybe Control.End) -> Control.Field delta restDeltaFields -> Maybe.Maybe ( Control.Delta delta, restDeltas )) ( Control.Delta delta, restDeltas ) -> Control.AdvancedControl context input (Control.Record (Control.Field state restStateFields)) (Control.Record (Control.Field delta restDeltaFields)) output"},{"name":"enum","comment":" A control that produces a custom type where none of the variants have any\narguments. Renders as an HTML radio input. Defaults to the first variant.\n\n import Control exposing (Control, enum)\n\n type Colour\n = Red\n | Green\n | Blue\n\n enum\n ( \"Red\", Red )\n ( \"Green\", Green )\n [ ( \"Blue\", Blue ) ]\n\n --: Control context Colour Colour Colour\n\n","type":"( String.String, enum ) -> ( String.String, enum ) -> List.List ( String.String, enum ) -> Control.Control context enum enum enum"},{"name":"failIf","comment":" Display an error on a `Control` if the supplied predicate function returns\n`True`.\n\nThis causes the `Control` to fail validation.\n\n import Control exposing (Control, failIf, int)\n\n int\n |> failIf\n (\\x -> x < 1)\n \"This must be greater than zero!\"\n\n --: Control context String String Int\n\n","type":"(output -> Basics.Bool) -> String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"failIfWithContext","comment":" Display an error on a `Control` if the supplied predicate function returns\n`True`.\n\nThis causes the `Control` to fail validation.\n\n import Control exposing (Control, failIfWithContext, int)\n\n type alias Context =\n { minimumValue : Int }\n\n int\n |> failIfWithContext\n (\\context x -> x < context.minimumValue)\n \"This is less than the minimum value!\"\n\n --: Control Context String String Int\n\n","type":"(context -> output -> Basics.Bool) -> String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"field","comment":" Add a field to a `record` combinator.\n\n import Control exposing (Control, Record, Field, EndRecord, record, field, endRecord, string)\n\n type alias Hello =\n { hello : String }\n\n record Hello\n |> field .hello string\n |> endRecord\n\n --: Control context (Record (Field String EndRecord)) (Record (Field String EndRecord)) Hello\n\n","type":"(recordOutput9 -> output7) -> Control.AdvancedControl context9 input9 state9 delta11 output7 -> Control.RecordBuilder b a22 (( Control.Delta delta12, a21 ) -> c5) (( ( Control.Delta delta12, a21 ) -> c5, a20 ) -> c4) (a19 -> { alerts : List.List Control.Alert, fns : restFns7, states : restStates6 } -> List.List Control.Alert) (a18 -> { cmds : List.List (Platform.Cmd.Cmd recordDelta2), deltaSetters : restDeltaSetters2, fieldDeltas : restDeltas2 } -> List.List (Platform.Cmd.Cmd recordDelta2)) (a17 -> { alerts : List.List Control.Alert, feedback : List.List Control.Feedback, fns : restFns6, states : restStates5 } -> List.List Control.Feedback) (a16 -> { alerts : List.List Control.Alert, context : context6, fns : restFns5, states : restStates4 } -> List.List Control.Alert) (Path.Path -> ( Control.RecordFns context9 input9 state9 delta11 output7 recordOutput9, a15 ) -> c3) (a14 -> { fns : restFns4, inputStates : restInputStates, outputStates : restInputStates -> outputStates } -> outputStates) (Path.Path -> ( Platform.Cmd.Cmd (Control.Delta delta11), a13 ) -> c2) (Path.Path -> ( Control.State state9, a12 ) -> c1) (a11 -> { deltaSetters : deltaSetters, deltas : List.List (Platform.Cmd.Cmd msg1), fns : fns, recordInput : recordOutput4, states : nextState -> states } -> statesAndDeltas) (a10 -> { afters : d, befores : e, output : a9 -> c, wrapDeltas : f -> g } -> h) (a8 -> { context : context3, fns : restFns3, states : restStates3, toOutputResult : Result.Result (List.List Control.Feedback) output1_1 } -> Result.Result (List.List Control.Feedback) output2_1) (a7 -> { context : context2, fns : restFns2, listSubs : List.List (Platform.Sub.Sub msg), setters : restDeltas1, states : restStates2 } -> List.List (Platform.Sub.Sub msg)) toOutput (a6 -> { context : context1, deltaSetters : restDeltaSetters1, deltas : restDeltas, fns : restFns1, newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : restStates1 -> intermediateRecordStates, states : restStates1 } -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : finalRecordStates }) (a5 -> { alerts : List.List Control.Alert, context : context, deltaSetters : restDeltaSetters, fns : restFns, states : restStates, views : List.List (Control.Subcontrol recordDelta) } -> List.List (Control.Subcontrol recordDelta)) (a4 -> restStateTuples -> restStateFields) (a3 -> restStateFields -> Maybe.Maybe restStateTuples) (a2 -> restDeltaTuples -> restDeltaFields) (a1 -> restDeltaFields -> Maybe.Maybe restDeltaTuples) a -> Control.RecordBuilder ( Control.Delta delta10, b ) ( b, a22 ) (a21 -> c5) (a20 -> c4) (a19 -> { alerts : List.List Control.Alert, fns : ( Control.RecordFns context8 input8 state8 delta9 output6 recordOutput8, restFns7 ), states : ( Control.State state8, restStates6 ) } -> List.List Control.Alert) (a18 -> { cmds : List.List (Platform.Cmd.Cmd recordDelta2), deltaSetters : ( fieldDelta1 -> recordDelta2, restDeltaSetters2 ), fieldDeltas : ( Platform.Cmd.Cmd fieldDelta1, restDeltas2 ) } -> List.List (Platform.Cmd.Cmd recordDelta2)) (a17 -> { alerts : List.List Control.Alert, feedback : List.List Control.Feedback, fns : ( Control.RecordFns context7 input7 state7 delta8 output5 recordOutput7, restFns6 ), states : ( Control.State state7, restStates5 ) } -> List.List Control.Feedback) (a16 -> { alerts : List.List Control.Alert, context : context6, fns : ( Control.RecordFns context6 input6 state6 delta7 output4 recordOutput6, restFns5 ), states : ( Control.State state6, restStates4 ) } -> List.List Control.Alert) (Path.Path -> a15 -> c3) (a14 -> { fns : ( Control.RecordFns context5 input5 inputState delta6 output3 recordOutput5, restFns4 ), inputStates : ( Control.State inputState, restInputStates ), outputStates : ( Control.State inputState, restInputStates ) -> outputStates } -> outputStates) (Path.Path -> a13 -> c2) (Path.Path -> a12 -> c1) (a11 -> { deltaSetters : ( Control.Delta delta5 -> msg1, deltaSetters ), deltas : List.List (Platform.Cmd.Cmd msg1), fns : ( Control.RecordFns context4 input4 state5 delta5 input4 recordOutput4, fns ), recordInput : recordOutput4, states : ( Control.State state5, nextState ) -> states } -> statesAndDeltas) (a10 -> { k | afters : ( i, d ), befores : ( ( j, i ) -> f, e ), output : ( j -> g, a9 ) -> c, wrapDeltas : f -> g } -> h) (a8 -> { context : context3, fns : ( Control.RecordFns context3 input3 state4 delta4 output0 recordOutput3, restFns3 ), states : ( Control.State state4, restStates3 ), toOutputResult : Result.Result (List.List Control.Feedback) (output0 -> output1_1) } -> Result.Result (List.List Control.Feedback) output2_1) (a7 -> { context : context2, fns : ( Control.RecordFns context2 input2 state3 delta3 output2 recordOutput2, restFns2 ), listSubs : List.List (Platform.Sub.Sub msg), setters : ( Control.Delta delta3 -> msg, restDeltas1 ), states : ( Control.State state3, restStates2 ) } -> List.List (Platform.Sub.Sub msg)) toOutput (a6 -> { context : context1, deltaSetters : ( Control.Delta fieldDelta -> recordDelta1, restDeltaSetters1 ), deltas : ( Control.Delta fieldDelta, restDeltas ), fns : ( Control.RecordFns context1 input1 state2 fieldDelta output1 recordOutput1, restFns1 ), newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : ( Control.State state2, restStates1 ) -> intermediateRecordStates, states : ( Control.State state2, restStates1 ) } -> { newCmds : List.List (Platform.Cmd.Cmd recordDelta1), newStates : finalRecordStates }) (a5 -> { alerts : List.List Control.Alert, context : context, deltaSetters : ( Control.Delta delta2 -> recordDelta, restDeltaSetters ), fns : ( Control.RecordFns context input state1 delta2 output recordOutput, restFns ), states : ( Control.State state1, restStates ), views : List.List (Control.Subcontrol recordDelta) } -> List.List (Control.Subcontrol recordDelta)) (a4 -> ( Control.State state, restStateTuples ) -> Control.Field state restStateFields) (a3 -> Control.Field state restStateFields -> Maybe.Maybe ( Control.State state, restStateTuples )) (a2 -> ( Control.Delta delta1, restDeltaTuples ) -> Control.Field delta1 restDeltaFields) (a1 -> Control.Field delta1 restDeltaFields -> Maybe.Maybe ( Control.Delta delta1, restDeltaTuples )) ( Control.Delta delta, a )"},{"name":"float","comment":" A control that produces a `Float`. Renders as an HTML number input.\n\n import Control exposing (Control, float)\n\n float\n\n --: Control context String String Float\n\n","type":"Control.Control context 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 import Control exposing (Form, Delta, form, int)\n import Html\n import Html.Attributes\n import Html.Events\n\n type Msg\n = FormUpdated (Delta String)\n | FormSubmitted\n\n form\n { control = int\n , onUpdate = FormUpdated\n , view =\n \\controlView ->\n Html.form\n [ Html.Events.onSubmit FormSubmitted ]\n (controlView ++ [ Html.button [ Html.Attributes.type_ \"submit\" ] [ Html.text \"Submit\" ] ])\n }\n\n --: Form String String Int Msg\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":"formWithContext","comment":" Convert a `Control` into a `FormWithContext`, and render the form however\nyou like.\n\nTo use this function, follow the instructions in the documentation for\n`form`. The only difference is that when you call `myForm.update`,\n`myForm.submit`, `myForm.view` and `myForm.subscriptions`, you will need to\nsupply a `context` value as the first argument.\n\n","type":"{ control : Control.Control context state delta output, onUpdate : Control.Delta delta -> msg, view : List.List (Html.Html msg) -> Html.Html msg } -> Control.FormWithContext context state delta output msg"},{"name":"id","comment":" Set an id for a `Control`.\n\n import Control exposing (Control, string, id)\n\n string\n |> id \"my-string\"\n\n --: Control context String String String\n\n","type":"String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"int","comment":" A control that produces an `Int`. Renders as an HTML number input.\n\n import Control exposing (Control, int)\n\n int\n\n --: Control context String String Int\n\n","type":"Control.Control context String.String String.String Basics.Int"},{"name":"label","comment":" Set a label for a `Control`.\n\n import Control exposing (Control, string, label)\n\n string\n |> label \"Enter your name\"\n\n --: Control context String String String\n\n","type":"String.String -> Control.AdvancedControl context input state delta output -> Control.AdvancedControl context 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 import Control exposing (Control, Record, Field, EndRecord, record, field, endRecord, layout, string, int)\n import Html\n import Html.Attributes\n import Html.Events\n\n type alias MyRecord =\n { foo : String\n , bar : Int\n }\n\n record\n (\\foo bar ->\n { foo = foo\n , bar = bar\n }\n )\n |> field .foo string\n |> field .bar int\n |> endRecord\n |> layout wizard\n\n --: Control context (Record (Field String (Field String EndRecord))) (Record (Field String (Field String EndRecord))) MyRecord\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\n","type":"(Control.LayoutConfig delta -> List.List (Control.Subcontrol delta) -> List.List (Html.Html (Control.Delta delta))) -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"list","comment":" A combinator that produces a `List` of controls of a given type.\n\n import Control exposing (Control, List_, list, bool)\n\n list bool\n\n --: Control context (List_ Bool) (List_ Bool) (List Bool)\n\n","type":"Control.Control context state delta output -> Control.Control context (Control.List_ state) (Control.List_ 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 import Control exposing (Control, Mapping, int, map)\n\n type Id\n = Id Int\n\n int\n |> map\n { convert = \\i -> Id i\n , revert = \\(Id i) -> i\n }\n\n --: Control context (Mapping String) (Mapping String) Id\n\n","type":"{ convert : a -> b, revert : b -> a } -> Control.Control context state delta a -> Control.Control context (Control.Mapping state) (Control.Mapping delta) b"},{"name":"maybe","comment":" A combinator that produces a `Maybe` of a control of a given type.\n\n import Control exposing (Control, Maybe_, int, maybe)\n\n maybe int\n\n --: Control context (Maybe_ String) (Maybe_ String) (Maybe Int)\n\n","type":"Control.Control context state delta output -> Control.Control context (Control.Maybe_ state) (Control.Maybe_ delta) (Maybe.Maybe output)"},{"name":"name","comment":" Set a name for a `Control`.\n\n import Control exposing (Control, string, name)\n\n string\n |> name \"My string\"\n\n --: Control context String String String\n\n","type":"String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"noteIf","comment":" Display a notification on a `Control` if the supplied predicate function\nreturns `True`.\n\nThis just shows the user a message - it doesn't cause the `Control` to fail\nvalidation.\n\n import Control exposing (Control, int, noteIf)\n\n int\n |> noteIf\n (\\x -> x < 1)\n \"Maybe this should be greater than zero?\"\n\n --: Control context String String Int\n\n","type":"(output -> Basics.Bool) -> String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"noteIfWithContext","comment":" Display a notification on a `Control` if the supplied predicate function\nreturns `True`.\n\nThis does not cause the `Control` to fail validation.\n\n import Control exposing (Control, int, noteIfWithContext)\n\n type alias Context =\n { recommendedMinimumValue : Int }\n\n int\n |> noteIfWithContext\n (\\context x -> x < context.recommendedMinimumValue)\n \"This value is below the recommended minimum - are you sure?\"\n\n --: Control Context String String Int\n\n","type":"(context -> output -> Basics.Bool) -> String.String -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"record","comment":" A combinator that produces a record type.\n\n import Control exposing (Control, Record, Field, EndRecord, record, field, endRecord, string, int)\n\n type alias MyRecord =\n { foo : String\n , bar : Int\n }\n\n record\n (\\foo bar ->\n { foo = foo\n , bar = bar\n }\n )\n |> field .foo string\n |> field .bar int\n |> endRecord\n\n --: Control context (Record (Field String (Field String EndRecord))) (Record (Field String (Field String EndRecord))) MyRecord\n\n","type":"toOutput -> Control.RecordBuilder Control.End Control.End (a16 -> a16) (a15 -> a15) (a14 -> a14) (a13 -> a13) (a12 -> a12) (a11 -> a11) (b -> c -> c) (a10 -> a10) (d -> e -> e) (f -> g -> g) (a9 -> a9) (a8 -> a8) (a7 -> a7) (a6 -> a6) toOutput (a5 -> a5) (a4 -> a4) (a3 -> a3) (a2 -> a2) (a1 -> a1) (a -> a) Control.End"},{"name":"respond","comment":" Display an error or notification message on a `Control` in response to an\nalert emitted by another `Control`. If desired, cause validation to fail.\n\n import Control exposing (Control, respond, int)\n\n int\n |> respond\n { alert = \"int-greater-than-zero\"\n , fail = True\n , message = \"Must be less than zero\"\n , class = \"control-feedback-fail\"\n }\n\n --: Control context String String Int\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, class : String.String } -> Control.Control context state delta output -> Control.Control context state delta output"},{"name":"result","comment":" A combinator that produces a `Result` with a given error and\nsuccess type.\n\n import Control exposing (Control, Result_, result, string, bool)\n\n result string bool\n\n --: Control context (Result_ String Bool) (Result_ String Bool) (Result String Bool)\n\n","type":"Control.Control context errState errDelta errOutput -> Control.Control context okState okDelta okOutput -> Control.Control context (Control.Result_ errState okState) (Control.Result_ errDelta okDelta) (Result.Result errOutput okOutput)"},{"name":"sandbox","comment":" Test and debug a `Control` by turning it into a `Program` that you can run as a standalone Elm application.\n\n import Control exposing (sandbox, int, State, Delta)\n\n sandbox\n { control = int\n , outputToString = Debug.toString\n }\n\n --: Program () (State String) (Delta String)\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","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 import Control exposing (Control, Set_, set, string)\n import Set\n\n set string\n\n --: Control context (Set_ String) (Set_ String) (Set.Set String)\n\n","type":"Control.Control context state delta comparable -> Control.Control context (Control.Set_ state) (Control.Set_ delta) (Set.Set comparable)"},{"name":"simpleForm","comment":" Convert a `Control` into a simple `Form`, rendered as a list of controls\nwrapped in an HTML `