[ { "name": "Exts.RemoteData", "comment": " A datatype representing fetched data.\n\n@docs RemoteData, map, mapFailure, mapBoth, withDefault, fromResult, asEffect, mappend, isSuccess\n", "unions": [ { "name": "RemoteData", "comment": " Frequently when you're fetching data from an API, you want to represent four different states:\n * `NotAsked` - We haven't asked for the data yet.\n * `Loading` - We've asked, but haven't got an answer yet.\n * `Failure` - We asked, but something went wrong. Here's the error.\n * `Success` - Everything worked, and here's the data.\n", "args": [ "e", "a" ], "cases": [ [ "NotAsked", [] ], [ "Loading", [] ], [ "Failure", [ "e" ] ], [ "Success", [ "a" ] ] ] } ], "aliases": [], "values": [ { "name": "asEffect", "comment": " Convert a web `Task`, probably produced from elm-http, to a RemoteData Effect.\n", "type": "Task e a -> Effects (RemoteData e a)" }, { "name": "fromResult", "comment": " Convert a `Result Error`, probably produced from elm-http, to a RemoteData value.\n", "type": "Result e a -> RemoteData e a" }, { "name": "isSuccess", "comment": " State-checking predicate. Returns true if we've successfully loaded some data.\n", "type": "RemoteData e a -> Bool" }, { "name": "map", "comment": " Map a function into the `Success` value.\n", "type": "(a -> b) -> RemoteData e a -> RemoteData e b" }, { "name": "mapBoth", "comment": " Map function into both the `Success` and `Failure` value.\n", "type": "(a -> b) -> (e -> f) -> RemoteData e a -> RemoteData f b" }, { "name": "mapFailure", "comment": " Map a function into the `Failure` value.\n", "type": "(e -> f) -> RemoteData e a -> RemoteData f a" }, { "name": "mappend", "comment": " Monoidal append - join two `RemoteData` values together as though\nthey were one. If both values are Failure, the left one wins.\n", "type": "RemoteData e a -> RemoteData e b -> RemoteData e ( a, b )" }, { "name": "withDefault", "comment": " Return the `Success` value, or the default.\n", "type": "a -> RemoteData e a -> a" } ], "binops": [] }, { "name": "Exts.Html", "comment": " Extensions to the `Html` library.\n\n@docs matchText\n\n", "unions": [], "aliases": [], "values": [ { "name": "matchText", "comment": " Highlight regex matches in a given piece of text. This is most easily explained with an example:\n\n import Regex exposing (regex)\n import Html.Attributes exposing (class)\n\n matchText\n [class \"match\"]\n (regex \"the\")\n \"the quick brown fox jumped over the lazy dog\"\n\n =>\n\n [span [class \"match\"] [text \"the\"]\n ,text \" quick brown fox jumped over \"\n ,span [class \"match\"] [text \"the\"]\n ,text \" lazy dog\"]\n\n Now you can add a CSS rule like `.match {background-color: yellow;}` to highlight matches\n for the user.\n\n (Note that you can supply any attributes you like for the matched sections, or an empty list.)\n\n", "type": "List Attribute -> Regex -> String -> List Html" } ], "binops": [] }, { "name": "Exts.Validation", "comment": " Simple tools for validation. See also [Richard Feldman's elm-validate](http://package.elm-lang.org/packages/rtfeldman/elm-validate/latest)\n\n@docs apply, (|:), required, notBlank, emailRegex\n", "unions": [], "aliases": [], "values": [ { "name": "apply", "comment": " A validator is a function that takes a possibly-invalid form, and\neither returns an error message, or a form that is definitely valid. For example:\n\n type alias Form =\n { email : Maybe String\n , age : Maybe Int\n }\n\n type alias ValidForm =\n { email : String\n , age : Int\n }\n\n validateForm : Form -> Result String ValidForm\n validateForm form =\n Ok ValidForm\n |: (notBlank \"Email is required and may not be blank.\" form.email)\n |: (required \"Age is required\" form.age)\n\nAn error message is typically a `String`, but may be any type you choose.\n\n(Hat tip to CircuitHub, who inspired the syntax and guided the code with their [elm-json-extra](http://package.elm-lang.org/packages/circuithub/elm-json-extra/latest) library.)\n", "type": "Result e (a -> b) -> Result e a -> Result e b" }, { "name": "emailRegex", "comment": " A basic email regex. This is incredibly simplistic, but is\nincluded for convenience.\n\nRemember that the only real way to validate an email address is to\nsend something to it and get a reply.\n", "type": "Regex" }, { "name": "notBlank", "comment": " A field that might be `Nothing`, but is only valid if it is a non-empty `String`.\n", "type": "e -> Maybe String -> Result e String" }, { "name": "required", "comment": " A field that might be `Nothing`, but is only valid if it is `Just a`.\n", "type": "e -> Maybe a -> Result e a" } ], "binops": [ { "name": "|:", "comment": " Convenient synonym for `apply`.\n", "type": "Result e (a -> b) -> Result e a -> Result e b", "associativity": "left", "precedence": 9 } ] }, { "name": "Exts.Tuple", "comment": " Extensions for tuples.\n\n@docs indexedPair, first, second, both, pair, fork\n\n", "unions": [], "aliases": [], "values": [ { "name": "both", "comment": " Update both components of a pair with a single function.\n", "type": "(a -> b) -> ( a, a ) -> ( b, b )" }, { "name": "first", "comment": " Update the first component of a pair.\n", "type": "(a -> a_) -> ( a, b ) -> ( a_, b )" }, { "name": "fork", "comment": " Generate a pair from a single value and a left & right function.\n", "type": "(a -> b) -> (a -> c) -> a -> ( b, c )" }, { "name": "indexedPair", "comment": " Turn a items into a key-value pair.\n\n See also `Exts.Dict.indexBy` and `Exts.Dict.groupBy`.\n", "type": "(a -> b) -> a -> ( b, a )" }, { "name": "pair", "comment": " Update both components of a pair with two functions.\n", "type": "(a -> a_) -> (b -> b_) -> ( a, b ) -> ( a_, b_ )" }, { "name": "second", "comment": " Update the second component of a pair.\n", "type": "(b -> b_) -> ( a, b ) -> ( a, b_ )" } ], "binops": [] }, { "name": "Exts.Task", "comment": " Extensions for Tasks.\n\n@docs asEffect\n", "unions": [], "aliases": [], "values": [ { "name": "asEffect", "comment": " Convert a `Task` to an `Effect` which conveys success or failure.\n", "type": "Task e a -> Effects (Result e a)" } ], "binops": [] }, { "name": "Exts.String", "comment": " Extensions to the core `String` library.\n\n@docs removePrefix\n\n", "unions": [], "aliases": [], "values": [ { "name": "removePrefix", "comment": " Strip a leading string from a `String`.\n", "type": "String -> String -> String" } ], "binops": [] }, { "name": "Exts.State", "comment": " Extensions to the core `Array` library.\n\n@docs subUpdate\n", "unions": [], "aliases": [], "values": [ { "name": "subUpdate", "comment": " Quite often in Elm we want to say:\n\n - This `action` wraps a sub-module's `subaction`.\n - Take that `subaction`, apply the sub-module's update function to get `(submodel,subeffects)`\n - Merge the `submodel` our `model`.\n - Merge the `subeffects` into our `effects`, using a wrapper.\n\nThat plumbing's pretty repetitive, and we can abstract it out if we\ncreate a Focus to package up the getting & setting.\n\nFor example, if you want to pass actions down the chain to a `DatePicker`:\n\n\n -- Create a Focus. This may well be useful in other parts of your code.\n datePickerFocus : Focus Model DatePicker.Model\n datePickerFocus =\n Focus.create\n .datePicker\n (\\f model -> { model | datePicker = f model.datePicker })\n\n -- Handle the sub-update in one sweep.\n update action model =\n case action of\n ...\n DatePickerAction subaction ->\n subUpdate\n DatePicker.update\n datePickerFocus\n DatePickerAction\n subaction\n model\n ...\n", "type": "(subaction -> submodel -> ( submodel, Effects subaction )) -> Focus model submodel -> (subaction -> action) -> subaction -> model -> ( model, Effects action )" } ], "binops": [] }, { "name": "Exts.Set", "comment": " Extensions to the core `Set` library.\n\n@docs select, uniqueItems\n\n", "unions": [], "aliases": [], "values": [ { "name": "select", "comment": " Pull any items from a list where (f x) is in the given set.\n", "type": "(a -> comparable) -> Set comparable -> List a -> List a" }, { "name": "uniqueItems", "comment": " Dive into a `List` to get a set of values.\n\n For example, pulling a `Set` of countries from a `List` of users.\n", "type": "(a -> Maybe comparable) -> List a -> Set comparable" } ], "binops": [] }, { "name": "Exts.Result", "comment": " Extensions to the core `Result` library.\n\n@docs mapBoth, isOk, isErr, fromOk, fromErr, mappend\n", "unions": [], "aliases": [], "values": [ { "name": "fromErr", "comment": " ", "type": "Result e a -> Maybe e" }, { "name": "fromOk", "comment": " Convert a `Result` to a `Maybe`.\n", "type": "Result e a -> Maybe a" }, { "name": "isErr", "comment": " ", "type": "Result e a -> Bool" }, { "name": "isOk", "comment": " Boolean checks for success/failure.\n", "type": "Result e a -> Bool" }, { "name": "mapBoth", "comment": " Apply functions to both sides of a `Result`, transforming the error and ok types.\n", "type": "(e -> f) -> (a -> b) -> Result e a -> Result f b" }, { "name": "mappend", "comment": " Monoidal append - join two Results together as though they were one.\n", "type": "Result e a -> Result e b -> Result e ( a, b )" } ], "binops": [] }, { "name": "Exts.Maybe", "comment": " Extensions to the core `Maybe` library.\n\n@docs isJust, isNothing, maybe, mappend, catMaybes\n", "unions": [], "aliases": [], "values": [ { "name": "catMaybes", "comment": " Extract all the `Just` values from a List of Maybes.\n", "type": "List (Maybe a) -> List a" }, { "name": "isJust", "comment": " Boolean checks.\n", "type": "Maybe a -> Bool" }, { "name": "isNothing", "comment": " ", "type": "Maybe a -> Bool" }, { "name": "mappend", "comment": " Join two `Maybe`s together as though they were one.\n", "type": "Maybe a -> Maybe b -> Maybe ( a, b )" }, { "name": "maybe", "comment": " Apply a function to a value, returning the default if the value is `Nothing`.\n", "type": "b -> (a -> b) -> Maybe a -> b" } ], "binops": [] }, { "name": "Exts.List", "comment": " Extensions to the core `List` library.\n\n@docs chunk, mergeBy, singleton, maybeSingleton, firstMatch, rest\n", "unions": [], "aliases": [], "values": [ { "name": "chunk", "comment": " Split a list into chunks of length `n`.\n\n Be aware that the last sub-list may be smaller than `n`-items long.\n\n For example `chunk 3 [1..10] => [[1,2,3], [4,5,6], [7,8,9], [10]]`\n", "type": "Int -> List a -> List (List a)" }, { "name": "firstMatch", "comment": " Find the first element in the `List` that matches the given predicate.\n", "type": "(a -> Bool) -> List a -> Maybe a" }, { "name": "maybeSingleton", "comment": " Wrap a maybe item into a `List`. If the item is `Nothing`, the `List` is empty.\n", "type": "Maybe a -> List a" }, { "name": "mergeBy", "comment": " Merge two lists. The first argument is a function which returns\nthe unique ID of each element. Where an element appears more than\nonce, the last won wins.\n", "type": "(a -> comparable) -> List a -> List a -> List a" }, { "name": "rest", "comment": " Like List.tail, but if the list is empty it returns an empty list rather than `Nothing`.\n", "type": "List a -> List a" }, { "name": "singleton", "comment": " Wrap a single item into a `List`.\n", "type": "a -> List a" } ], "binops": [] }, { "name": "Exts.LatLng", "comment": " Calculations between points on the earth.\n\n@docs distanceBetween, bearingTo\n", "unions": [], "aliases": [], "values": [ { "name": "bearingTo", "comment": " Calculate the heading you'd need to travel on to get from point a to point b.\n", "type": "{ a | latitude : Float, longitude : Float } -> { b | latitude : Float, longitude : Float } -> Float" }, { "name": "distanceBetween", "comment": " Calculate the distance in kilometers between two points.\n\n Note that this assumes the earth is spherical, which is not true, but may be true enough for your purposes.\n", "type": "{ a | latitude : Float, longitude : Float } -> { b | latitude : Float, longitude : Float } -> Float" } ], "binops": [] }, { "name": "Exts.Json.Encode", "comment": " Extensions to the core `Json.Encode` library.\n\n@docs set, dict, tuple2\n", "unions": [], "aliases": [], "values": [ { "name": "dict", "comment": " Encode a `Dict` to a JSON array .\n", "type": "(comparable -> Value) -> (v -> Value) -> Dict comparable v -> Value" }, { "name": "set", "comment": " Encode a `Set` to a JSON array .\n", "type": "(comparable -> Value) -> Set comparable -> Value" }, { "name": "tuple2", "comment": " Encode a pair to a JSON array .\n", "type": "(a -> Value) -> (b -> Value) -> ( a, b ) -> Value" } ], "binops": [] }, { "name": "Exts.Http", "comment": " Extensions to the `Http` library.\n\n@docs handleError, put, postContent, postForm, postJson\n", "unions": [], "aliases": [], "values": [ { "name": "handleError", "comment": " Lift a raw Http response into a `Task Error Response`, using the same rules `Http` uses internally.\n", "type": "Task RawError Response -> Task Error Response" }, { "name": "postContent", "comment": " Send a `POST` request with the given content-type.\n", "type": "String -> Decoder value -> String -> Body -> Task Error value" }, { "name": "postForm", "comment": " Send a `POST` request with appropriate headers form-encoding.\n", "type": "Decoder value -> String -> Body -> Task Error value" }, { "name": "postJson", "comment": " Send a `POST` request with appropriate headers form-encoding.\n", "type": "Decoder value -> String -> Body -> Task Error value" }, { "name": "put", "comment": " Send a simple `PUT` request.\n", "type": "Decoder value -> String -> Body -> Task Error value" } ], "binops": [] }, { "name": "Exts.Html.Table", "comment": " Helpers for simple data tables. Define how a list of items can be\nrendered as a table. The definition is a `List` of `(column-title,\ncolumn-value-accessor)` pairs.\n\n I find this approach works well for simple tables, but breaks down\n as soon as you need much customisation. Use it to get you started\n quickly, but be ready to rewrite when this 80% case no longer suits.\n\n@docs CellDef, TableDef, simpleTable, simpleTableRow, titleGroup, valueGroup\n", "unions": [], "aliases": [ { "name": "CellDef", "comment": " A table definition looks something like:\n\n [(text \"Name\", .name >> text)\n ,(text \"Name\", .age >> toString >> text)]\n\n", "args": [ "a" ], "type": "( Html, a -> Html )" }, { "name": "TableDef", "comment": " ", "args": [ "a" ], "type": "List (CellDef a)" } ], "values": [ { "name": "simpleTable", "comment": " Given a table definition, render a list of elements as HTML.\n", "type": "TableDef a -> List a -> Html" }, { "name": "simpleTableRow", "comment": " Given a table definition, render an element to a tag. This is\nlower-level. Usually you will want `simpleTable` instead.\n", "type": "TableDef a -> a -> Html" }, { "name": "titleGroup", "comment": " titleGroup and valueGroup are used to create columns that stack multiple pairs. For example:\n\n [(titleGroup [\"Latitude\", \"Longitude\"]\n ,valueGroup [.location >> .lat >> toString >> text\n ,.location >> .lng >> toString >> text])\n\n", "type": "List String -> Html" }, { "name": "valueGroup", "comment": " ", "type": "List (a -> Html) -> a -> Html" } ], "binops": [] }, { "name": "Exts.Html.Events", "comment": " Extensions to the `Html.Events` library.\n\n@docs onEnter, onCheckbox, onSelect, onInput\n", "unions": [], "aliases": [], "values": [ { "name": "onCheckbox", "comment": " Send a message whenever a checkbox is clicked. You supply a\n`function` which takes a `Bool` and returns an appropriate message.\n", "type": "Address a -> (Bool -> a) -> Attribute" }, { "name": "onEnter", "comment": " Send a message when the user hits enter.\n", "type": "Message -> Attribute" }, { "name": "onInput", "comment": " Similar to onChange, but it fires as soon as the value has changed,\nwhereas onChange waits until the input loses focus.\n", "type": "Address a -> (String -> a) -> Attribute" }, { "name": "onSelect", "comment": " An event handler for `