[ { "name": "Random", "comment": " This library helps you generate pseudo-random values.\n\nThis library is all about building [`generators`](#Generator) for whatever\ntype of values you need. There are a bunch of primitive generators like\n[`bool`](#bool) and [`int`](#int) that you can build up into fancier\ngenerators with functions like [`list`](#list) and [`map`](#map).\n\nIt may be helpful to [read about JSON decoders][json] because they work very\nsimilarly.\n\n[json]: https://evancz.gitbooks.io/an-introduction-to-elm/content/interop/json.html\n\n> *Note:* This is an implementation of the Portable Combined Generator of\nL'Ecuyer for 32-bit computers. It is almost a direct translation from the\n[System.Random](http://hackage.haskell.org/package/random-1.0.1.1/docs/System-Random.html)\nmodule. It has a period of roughly 2.30584e18.\n\n# Generators\n@docs Generator\n\n# Primitive Generators\n@docs bool, int, float\n\n# Data Structure Generators\n@docs pair, list\n\n# Custom Generators\n@docs map, map2, map3, map4, map5, andThen\n\n# Generate Values\n@docs generate\n\n# Generate Values Manually\n@docs step, Seed, initialSeed\n\n# Constants\n@docs maxInt, minInt\n\n", "unions": [ { "name": "Generator", "comment": " A `Generator` is like a recipe for generating certain random values. So a\n`Generator Int` describes how to generate integers and a `Generator String`\ndescribes how to generate strings.\n\nTo actually *run* a generator and produce the random values, you need to use\nfunctions like [`generate`](#generate) and [`initialSeed`](#initialSeed).\n", "args": [ "a" ], "cases": [] }, { "name": "Seed", "comment": " A `Seed` is the source of randomness in this whole system. Whenever\nyou want to use a generator, you need to pair it with a seed.\n", "args": [], "cases": [] } ], "aliases": [], "values": [ { "name": "andThen", "comment": " Chain random operations, threading through the seed. In the following\nexample, we will generate a random letter by putting together uppercase and\nlowercase letters.\n\n letter : Generator Char\n letter =\n bool\n |> andThen upperOrLower\n\n upperOrLower : Bool -> Generator Char\n upperOrLower b =\n if b then uppercaseLetter else lowercaseLetter\n\n -- bool : Generator Bool\n -- uppercaseLetter : Generator Char\n -- lowercaseLetter : Generator Char\n", "type": "(a -> Generator b) -> Generator a -> Generator b" }, { "name": "bool", "comment": " Create a generator that produces boolean values. The following example\nsimulates a coin flip that may land heads or tails.\n\n type Flip = Heads | Tails\n\n coinFlip : Generator Flip\n coinFlip =\n map (\\b -> if b then Heads else Tails) bool\n", "type": "Generator Bool" }, { "name": "float", "comment": " Generate floats in a given range. The following example is a generator\nthat produces decimals between 0 and 1.\n\n probability : Generator Float\n probability =\n float 0 1\n", "type": "Float -> Float -> Generator Float" }, { "name": "generate", "comment": " Create a command that will generate random values.\n\nRead more about how to use this in your programs in [The Elm Architecture\ntutorial][arch] which has a section specifically [about random values][rand].\n\n[arch]: https://evancz.gitbooks.io/an-introduction-to-elm/content/architecture/index.html\n[rand]: https://evancz.gitbooks.io/an-introduction-to-elm/content/architecture/effects/random.html\n", "type": "(a -> msg) -> Generator a -> Cmd msg" }, { "name": "initialSeed", "comment": " Create a “seed” of randomness which makes it possible to\ngenerate random values. If you use the same seed many times, it will result\nin the same thing every time! A good way to get an unexpected seed is to use\nthe current time.\n", "type": "Int -> Seed" }, { "name": "int", "comment": " Generate 32-bit integers in a given range.\n\n int 0 10 -- an integer between zero and ten\n int -5 5 -- an integer between -5 and 5\n\n int minInt maxInt -- an integer in the widest range feasible\n\nThis function *can* produce values outside of the range [[`minInt`](#minInt),\n[`maxInt`](#maxInt)] but sufficient randomness is not guaranteed.\n", "type": "Int -> Int -> Generator Int" }, { "name": "list", "comment": " Create a list of random values.\n\n floatList : Generator (List Float)\n floatList =\n list 10 (float 0 1)\n\n intList : Generator (List Int)\n intList =\n list 5 (int 0 100)\n\n intPairs : Generator (List (Int, Int))\n intPairs =\n list 10 <| pair (int 0 100) (int 0 100)\n", "type": "Int -> Generator a -> Generator (List a)" }, { "name": "map", "comment": " Transform the values produced by a generator. The following examples show\nhow to generate booleans and letters based on a basic integer generator.\n\n bool : Generator Bool\n bool =\n map ((==) 1) (int 0 1)\n\n lowercaseLetter : Generator Char\n lowercaseLetter =\n map (\\n -> Char.fromCode (n + 97)) (int 0 25)\n\n uppercaseLetter : Generator Char\n uppercaseLetter =\n map (\\n -> Char.fromCode (n + 65)) (int 0 25)\n\n", "type": "(a -> b) -> Generator a -> Generator b" }, { "name": "map2", "comment": " Combine two generators.\n\nThis function is used to define things like [`pair`](#pair) where you want to\nput two generators together.\n\n pair : Generator a -> Generator b -> Generator (a,b)\n pair genA genB =\n map2 (,) genA genB\n\n", "type": "(a -> b -> c) -> Generator a -> Generator b -> Generator c" }, { "name": "map3", "comment": " Combine three generators. This could be used to produce random colors.\n\n import Color\n\n rgb : Generator Color.Color\n rgb =\n map3 Color.rgb (int 0 255) (int 0 255) (int 0 255)\n\n hsl : Generator Color.Color\n hsl =\n map3 Color.hsl (map degrees (int 0 360)) (float 0 1) (float 0 1)\n", "type": "(a -> b -> c -> d) -> Generator a -> Generator b -> Generator c -> Generator d" }, { "name": "map4", "comment": " Combine four generators.\n", "type": "(a -> b -> c -> d -> e) -> Generator a -> Generator b -> Generator c -> Generator d -> Generator e" }, { "name": "map5", "comment": " Combine five generators.\n", "type": "(a -> b -> c -> d -> e -> f) -> Generator a -> Generator b -> Generator c -> Generator d -> Generator e -> Generator f" }, { "name": "maxInt", "comment": " The maximum value for randomly generated 32-bit ints: 2147483647 ", "type": "Int" }, { "name": "minInt", "comment": " The minimum value for randomly generated 32-bit ints: -2147483648 ", "type": "Int" }, { "name": "pair", "comment": " Create a pair of random values. A common use of this might be to generate\na point in a certain 2D space. Imagine we have a collage that is 400 pixels\nwide and 200 pixels tall.\n\n randomPoint : Generator (Int,Int)\n randomPoint =\n pair (int -200 200) (int -100 100)\n\n", "type": "Generator a -> Generator b -> Generator ( a, b )" }, { "name": "step", "comment": " Generate a random value as specified by a given `Generator`.\n\nIn the following example, we are trying to generate a number between 0 and 100\nwith the `int 0 100` generator. Each time we call `step` we need to provide a\nseed. This will produce a random number and a *new* seed to use if we want to\nrun other generators later.\n\nSo here it is done right, where we get a new seed from each `step` call and\nthread that through.\n\n seed0 = initialSeed 31415\n\n -- step (int 0 100) seed0 ==> (42, seed1)\n -- step (int 0 100) seed1 ==> (31, seed2)\n -- step (int 0 100) seed2 ==> (99, seed3)\n\nNotice that we use different seeds on each line. This is important! If you use\nthe same seed, you get the same results.\n\n -- step (int 0 100) seed0 ==> (42, seed1)\n -- step (int 0 100) seed0 ==> (42, seed1)\n -- step (int 0 100) seed0 ==> (42, seed1)\n", "type": "Generator a -> Seed -> ( a, Seed )" } ], "binops": [] }, { "name": "Process", "comment": "\n\n# Processes\n@docs Id, spawn, sleep, kill\n\n## Future Plans\n\nRight now, this library is pretty sparse. For example, there is no public API\nfor processes to communicate with each other. This is a really important\nability, but it is also something that is extraordinarily easy to get wrong!\n\nI think the trend will be towards an Erlang style of concurrency, where every\nprocess has an “event queue” that anyone can send messages to. I currently\nthink the API will be extended to be more like this:\n\n type Id exit msg\n\n spawn : Task exit a -> Task x (Id exit Never)\n\n kill : Id exit msg -> Task x ()\n\n send : Id exit msg -> msg -> Task x ()\n\nA process `Id` will have two type variables to make sure all communication is\nvalid. The `exit` type describes the messages that are produced if the process\nfails because of user code. So if processes are linked and trapping errors,\nthey will need to handle this. The `msg` type just describes what kind of\nmessages this process can be sent by strangers.\n\nWe shall see though! This is just a draft that does not cover nearly everything\nit needs to, so the long-term vision for concurrency in Elm will be rolling out\nslowly as I get more data and experience.\n\nI ask that people bullish on compiling to node.js keep this in mind. I think we\ncan do better than the hopelessly bad concurrency model of node.js, and I hope\nthe Elm community will be supportive of being more ambitious, even if it takes\nlonger. That’s kind of what Elm is all about.\n", "unions": [], "aliases": [ { "name": "Id", "comment": " A light-weight process that runs concurrently. You can use `spawn` to\nget a bunch of different tasks running in different processes. The Elm runtime\nwill interleave their progress. So if a task is taking too long, we will pause\nit at an `andThen` and switch over to other stuff.\n\n**Note:** We make a distinction between *concurrency* which means interleaving\ndifferent sequences and *parallelism* which means running different\nsequences at the exact same time. For example, a\n[time-sharing system](https://en.wikipedia.org/wiki/Time-sharing) is definitely\nconcurrent, but not necessarily parallel. So even though JS runs within a\nsingle OS-level thread, Elm can still run things concurrently.\n", "args": [], "type": "ProcessId" } ], "values": [ { "name": "kill", "comment": " Sometimes you `spawn` a process, but later decide it would be a waste to\nhave it keep running and doing stuff. The `kill` function will force a process\nto bail on whatever task it is running. So if there is an HTTP request in\nflight, it will also abort the request.\n", "type": "Id -> Task x ()" }, { "name": "sleep", "comment": " Block progress on the current process for a given amount of time. The\nJavaScript equivalent of this is [`setTimeout`][setTimeout] which lets you\ndelay work until later.\n\n[setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout\n", "type": "Time -> Task x ()" }, { "name": "spawn", "comment": " Run a task in its own light-weight process. In the following example,\n`task1` and `task2` will be interleaved. If `task1` makes a long HTTP request\nor is just taking a long time, we can hop over to `task2` and do some work\nthere.\n\n spawn task1\n |> Task.andThen (\\_ -> spawn task2)\n\n**Note:** This creates a relatively restricted kind of `Process` because it\ncannot receive any messages. More flexibility for user-defined processes will\ncome in a later release!\n", "type": "Task x a -> Task y Id" } ], "binops": [] }, { "name": "Date", "comment": " Library for working with dates. Email the mailing list if you encounter\nissues with internationalization or locale formatting.\n\n# Dates\n@docs Date, now\n\n# Conversions\n@docs fromString, toTime, fromTime\n\n# Extractions\n@docs year, month, Month, day, dayOfWeek, Day, hour, minute, second, millisecond\n\n", "unions": [ { "name": "Date", "comment": " Representation of a date.\n", "args": [], "cases": [] }, { "name": "Day", "comment": " Represents the days of the week.\n", "args": [], "cases": [ [ "Mon", [] ], [ "Tue", [] ], [ "Wed", [] ], [ "Thu", [] ], [ "Fri", [] ], [ "Sat", [] ], [ "Sun", [] ] ] }, { "name": "Month", "comment": " Represents the month of the year.\n", "args": [], "cases": [ [ "Jan", [] ], [ "Feb", [] ], [ "Mar", [] ], [ "Apr", [] ], [ "May", [] ], [ "Jun", [] ], [ "Jul", [] ], [ "Aug", [] ], [ "Sep", [] ], [ "Oct", [] ], [ "Nov", [] ], [ "Dec", [] ] ] } ], "aliases": [], "values": [ { "name": "day", "comment": " Extract the day of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `23`.\n", "type": "Date -> Int" }, { "name": "dayOfWeek", "comment": " Extract the day of the week for a given date. Given the date 23 June\n1990 at 11:45AM this returns the day `Sat` as defined below.\n", "type": "Date -> Day" }, { "name": "fromString", "comment": " Attempt to read a date from a string.\n", "type": "String -> Result String Date" }, { "name": "fromTime", "comment": " Convert a time in milliseconds into a `Date`.\n\nA time is the number of milliseconds since\n[the Unix epoch](http://en.wikipedia.org/wiki/Unix_time).\n", "type": "Time -> Date" }, { "name": "hour", "comment": " Extract the hour of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `11`.\n", "type": "Date -> Int" }, { "name": "millisecond", "comment": " Extract the millisecond of a given date. Given the date 23 June 1990 at 11:45:30.123AM\nthis returns the integer `123`.\n", "type": "Date -> Int" }, { "name": "minute", "comment": " Extract the minute of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `45`.\n", "type": "Date -> Int" }, { "name": "month", "comment": " Extract the month of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the month `Jun` as defined below.\n", "type": "Date -> Month" }, { "name": "now", "comment": " Get the `Date` at the moment when this task is run.\n", "type": "Task x Date" }, { "name": "second", "comment": " Extract the second of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `0`.\n", "type": "Date -> Int" }, { "name": "toTime", "comment": " Convert a `Date` to a time in milliseconds.\n\nA time is the number of milliseconds since\n[the Unix epoch](http://en.wikipedia.org/wiki/Unix_time).\n", "type": "Date -> Time" }, { "name": "year", "comment": " Extract the year of a given date. Given the date 23 June 1990 at 11:45AM\nthis returns the integer `1990`.\n", "type": "Date -> Int" } ], "binops": [] }, { "name": "Time", "comment": " Library for working with time.\n\n# Time\n@docs Time, now, every\n\n# Units\n@docs millisecond, second, minute, hour,\n inMilliseconds, inSeconds, inMinutes, inHours\n\n", "unions": [], "aliases": [ { "name": "Time", "comment": " Type alias to make it clearer when you are working with time values.\nUsing the `Time` helpers like `second` and `inSeconds` instead of raw numbers\nis very highly recommended.\n", "args": [], "type": "Float" } ], "values": [ { "name": "every", "comment": " Subscribe to the current time. First you provide an interval describing how\nfrequently you want updates. Second, you give a tagger that turns a time into a\nmessage for your `update` function. So if you want to hear about the current\ntime every second, you would say something like this:\n\n type Msg = Tick Time | ...\n\n subscriptions model =\n every second Tick\n\nCheck out the [Elm Architecture Tutorial][arch] for more info on how\nsubscriptions work.\n\n[arch]: https://github.com/evancz/elm-architecture-tutorial/\n\n**Note:** this function is not for animation! You need to use something based\non `requestAnimationFrame` to get smooth animations. This is based on\n`setInterval` which is better for recurring tasks like “check on something\nevery 30 seconds”.\n", "type": "Time -> (Time -> msg) -> Sub msg" }, { "name": "hour", "comment": "", "type": "Time" }, { "name": "inHours", "comment": "", "type": "Time -> Float" }, { "name": "inMilliseconds", "comment": "", "type": "Time -> Float" }, { "name": "inMinutes", "comment": "", "type": "Time -> Float" }, { "name": "inSeconds", "comment": "", "type": "Time -> Float" }, { "name": "millisecond", "comment": " Units of time, making it easier to specify things like a half-second\n`(500 * millisecond)` without remembering Elm’s underlying units of time.\n", "type": "Time" }, { "name": "minute", "comment": "", "type": "Time" }, { "name": "now", "comment": " Get the `Time` at the moment when this task is run.\n", "type": "Task x Time" }, { "name": "second", "comment": "", "type": "Time" } ], "binops": [] }, { "name": "Set", "comment": " A set of unique values. The values can be any comparable type. This\nincludes `Int`, `Float`, `Time`, `Char`, `String`, and tuples or lists\nof comparable types.\n\nInsert, remove, and query operations all take *O(log n)* time.\n\n# Sets\n@docs Set\n\n# Build\n@docs empty, singleton, insert, remove\n\n# Query\n@docs isEmpty, member, size\n\n# Combine\n@docs union, intersect, diff\n\n# Lists\n@docs toList, fromList\n\n# Transform\n@docs map, foldl, foldr, filter, partition\n\n", "unions": [ { "name": "Set", "comment": " Represents a set of unique values. So `(Set Int)` is a set of integers and\n`(Set String)` is a set of strings.\n", "args": [ "t" ], "cases": [] } ], "aliases": [], "values": [ { "name": "diff", "comment": " Get the difference between the first set and the second. Keeps values\nthat do not appear in the second set.\n", "type": "Set comparable -> Set comparable -> Set comparable" }, { "name": "empty", "comment": " Create an empty set.\n", "type": "Set a" }, { "name": "filter", "comment": " Create a new set consisting only of elements which satisfy a predicate.\n", "type": "(comparable -> Bool) -> Set comparable -> Set comparable" }, { "name": "foldl", "comment": " Fold over the values in a set, in order from lowest to highest.\n", "type": "(comparable -> b -> b) -> b -> Set comparable -> b" }, { "name": "foldr", "comment": " Fold over the values in a set, in order from highest to lowest.\n", "type": "(comparable -> b -> b) -> b -> Set comparable -> b" }, { "name": "fromList", "comment": " Convert a list into a set, removing any duplicates.\n", "type": "List comparable -> Set comparable" }, { "name": "insert", "comment": " Insert a value into a set.\n", "type": "comparable -> Set comparable -> Set comparable" }, { "name": "intersect", "comment": " Get the intersection of two sets. Keeps values that appear in both sets.\n", "type": "Set comparable -> Set comparable -> Set comparable" }, { "name": "isEmpty", "comment": " Determine if a set is empty.\n", "type": "Set a -> Bool" }, { "name": "map", "comment": " Map a function onto a set, creating a new set with no duplicates.\n", "type": "(comparable -> comparable2) -> Set comparable -> Set comparable2" }, { "name": "member", "comment": " Determine if a value is in a set.\n", "type": "comparable -> Set comparable -> Bool" }, { "name": "partition", "comment": " Create two new sets; the first consisting of elements which satisfy a\npredicate, the second consisting of elements which do not.\n", "type": "(comparable -> Bool) -> Set comparable -> ( Set comparable, Set comparable )" }, { "name": "remove", "comment": " Remove a value from a set. If the value is not found, no changes are made.\n", "type": "comparable -> Set comparable -> Set comparable" }, { "name": "singleton", "comment": " Create a set with one value.\n", "type": "comparable -> Set comparable" }, { "name": "size", "comment": " Determine the number of elements in a set.\n", "type": "Set a -> Int" }, { "name": "toList", "comment": " Convert a set into a list, sorted from lowest to highest.\n", "type": "Set comparable -> List comparable" }, { "name": "union", "comment": " Get the union of two sets. Keep all values.\n", "type": "Set comparable -> Set comparable -> Set comparable" } ], "binops": [] }, { "name": "Json.Decode", "comment": " Turn JSON values into Elm values. Definitely check out this [intro to\nJSON decoders][guide] to get a feel for how this library works!\n\n[guide]: https://guide.elm-lang.org/interop/json.html\n\n# Primitives\n@docs Decoder, string, bool, int, float\n\n# Data Structures\n@docs nullable, list, array, dict, keyValuePairs\n\n# Object Primitives\n@docs field, at, index\n\n# Inconsistent Structure\n@docs maybe, oneOf\n\n# Run Decoders\n@docs decodeString, decodeValue, Value\n\n# Mapping\n\n**Note:** If you run out of map functions, take a look at [elm-decode-pipeline][pipe]\nwhich makes it easier to handle large objects, but produces lower quality type\nerrors.\n\n[pipe]: http://package.elm-lang.org/packages/NoRedInk/elm-decode-pipeline/latest\n\n@docs map, map2, map3, map4, map5, map6, map7, map8\n\n# Fancy Decoding\n@docs lazy, value, null, succeed, fail, andThen\n", "unions": [ { "name": "Decoder", "comment": " A value that knows how to decode JSON values.\n", "args": [ "a" ], "cases": [] } ], "aliases": [ { "name": "Value", "comment": " A JSON value.\n", "args": [], "type": "Value" } ], "values": [ { "name": "andThen", "comment": " Create decoders that depend on previous results. If you are creating\nversioned data, you might do something like this:\n\n info : Decoder Info\n info =\n field \"version\" int\n |> andThen infoHelp\n\n infoHelp : Int -> Decoder Info\n infoHelp version =\n case version of\n 4 ->\n infoDecoder4\n\n 3 ->\n infoDecoder3\n\n _ ->\n fail <|\n \"Trying to decode info, but version \"\n ++ toString version ++ \" is not supported.\"\n\n -- infoDecoder4 : Decoder Info\n -- infoDecoder3 : Decoder Info\n", "type": "(a -> Decoder b) -> Decoder a -> Decoder b" }, { "name": "array", "comment": " Decode a JSON array into an Elm `Array`.\n\n decodeString (array int) \"[1,2,3]\" == Ok (Array.fromList [1,2,3])\n decodeString (array bool) \"[true,false]\" == Ok (Array.fromList [True,False])\n", "type": "Decoder a -> Decoder (Array a)" }, { "name": "at", "comment": " Decode a nested JSON object, requiring certain fields.\n\n json = \"\"\"{ \"person\": { \"name\": \"tom\", \"age\": 42 } }\"\"\"\n\n decodeString (at [\"person\", \"name\"] string) json == Ok \"tom\"\n decodeString (at [\"person\", \"age\" ] int ) json == Ok \"42\n\nThis is really just a shorthand for saying things like:\n\n field \"person\" (field \"name\" string) == at [\"person\",\"name\"] string\n", "type": "List String -> Decoder a -> Decoder a" }, { "name": "bool", "comment": " Decode a JSON boolean into an Elm `Bool`.\n\n decodeString bool \"true\" == Ok True\n decodeString bool \"42\" == Err ...\n decodeString bool \"3.14\" == Err ...\n decodeString bool \"\\\"hello\\\"\" == Err ...\n decodeString bool \"{ \\\"hello\\\": 42 }\" == Err ...\n", "type": "Decoder Bool" }, { "name": "decodeString", "comment": " Parse the given string into a JSON value and then run the `Decoder` on it.\nThis will fail if the string is not well-formed JSON or if the `Decoder`\nfails for some reason.\n\n decodeString int \"4\" == Ok 4\n decodeString int \"1 + 2\" == Err ...\n", "type": "Decoder a -> String -> Result String a" }, { "name": "decodeValue", "comment": " Run a `Decoder` on some JSON `Value`. You can send these JSON values\nthrough ports, so that is probably the main time you would use this function.\n", "type": "Decoder a -> Value -> Result String a" }, { "name": "dict", "comment": " Decode a JSON object into an Elm `Dict`.\n\n decodeString (dict int) \"{ \\\"alice\\\": 42, \\\"bob\\\": 99 }\"\n == Dict.fromList [(\"alice\", 42), (\"bob\", 99)]\n", "type": "Decoder a -> Decoder (Dict String a)" }, { "name": "fail", "comment": " Ignore the JSON and make the decoder fail. This is handy when used with\n`oneOf` or `andThen` where you want to give a custom error message in some\ncase.\n\nSee the [`andThen`](#andThen) docs for an example.\n", "type": "String -> Decoder a" }, { "name": "field", "comment": " Decode a JSON object, requiring a particular field.\n\n decodeString (field \"x\" int) \"{ \\\"x\\\": 3 }\" == Ok 3\n decodeString (field \"x\" int) \"{ \\\"x\\\": 3, \\\"y\\\": 4 }\" == Ok 3\n decodeString (field \"x\" int) \"{ \\\"x\\\": true }\" == Err ...\n decodeString (field \"x\" int) \"{ \\\"y\\\": 4 }\" == Err ...\n\n decodeString (field \"name\" string) \"{ \\\"name\\\": \\\"tom\\\" }\" == Ok \"tom\"\n\nThe object *can* have other fields. Lots of them! The only thing this decoder\ncares about is if `x` is present and that the value there is an `Int`.\n\nCheck out [`map2`](#map2) to see how to decode multiple fields!\n", "type": "String -> Decoder a -> Decoder a" }, { "name": "float", "comment": " Decode a JSON number into an Elm `Float`.\n\n decodeString float \"true\" == Err ..\n decodeString float \"42\" == Ok 42\n decodeString float \"3.14\" == Ok 3.14\n decodeString float \"\\\"hello\\\"\" == Err ...\n decodeString float \"{ \\\"hello\\\": 42 }\" == Err ...\n", "type": "Decoder Float" }, { "name": "index", "comment": " Decode a JSON array, requiring a particular index.\n\n json = \"\"\"[ \"alice\", \"bob\", \"chuck\" ]\"\"\"\n\n decodeString (index 0 string) json == Ok \"alice\"\n decodeString (index 1 string) json == Ok \"bob\"\n decodeString (index 2 string) json == Ok \"chuck\"\n decodeString (index 3 string) json == Err ...\n", "type": "Int -> Decoder a -> Decoder a" }, { "name": "int", "comment": " Decode a JSON number into an Elm `Int`.\n\n decodeString int \"true\" == Err ...\n decodeString int \"42\" == Ok 42\n decodeString int \"3.14\" == Err ...\n decodeString int \"\\\"hello\\\"\" == Err ...\n decodeString int \"{ \\\"hello\\\": 42 }\" == Err ...\n", "type": "Decoder Int" }, { "name": "keyValuePairs", "comment": " Decode a JSON object into an Elm `List` of pairs.\n\n decodeString (keyValuePairs int) \"{ \\\"alice\\\": 42, \\\"bob\\\": 99 }\"\n == [(\"alice\", 42), (\"bob\", 99)]\n", "type": "Decoder a -> Decoder (List ( String, a ))" }, { "name": "lazy", "comment": " Sometimes you have JSON with recursive structure, like nested comments.\nYou can use `lazy` to make sure your decoder unrolls lazily.\n\n type alias Comment =\n { message : String\n , responses : Responses\n }\n\n type Responses = Responses (List Comment)\n\n comment : Decoder Comment\n comment =\n map2 Comment\n (field \"message\" string)\n (field \"responses\" (map Responses (list (lazy (\\_ -> comment)))))\n\nIf we had said `list comment` instead, we would start expanding the value\ninfinitely. What is a `comment`? It is a decoder for objects where the\n`responses` field contains comments. What is a `comment` though? Etc.\n\nBy using `list (lazy (\\_ -> comment))` we make sure the decoder only expands\nto be as deep as the JSON we are given. You can read more about recursive data\nstructures [here][].\n\n[here]: https://github.com/elm-lang/elm-compiler/blob/master/hints/recursive-alias.md\n", "type": "(() -> Decoder a) -> Decoder a" }, { "name": "list", "comment": " Decode a JSON array into an Elm `List`.\n\n decodeString (list int) \"[1,2,3]\" == Ok [1,2,3]\n decodeString (list bool) \"[true,false]\" == Ok [True,False]\n", "type": "Decoder a -> Decoder (List a)" }, { "name": "map", "comment": " Transform a decoder. Maybe you just want to know the length of a string:\n\n import String\n\n stringLength : Decoder Int\n stringLength =\n map String.length string\n\nIt is often helpful to use `map` with `oneOf`, like when defining `nullable`:\n\n nullable : Decoder a -> Decoder (Maybe a)\n nullable decoder =\n oneOf\n [ null Nothing\n , map Just decoder\n ]\n", "type": "(a -> value) -> Decoder a -> Decoder value" }, { "name": "map2", "comment": " Try two decoders and then combine the result. We can use this to decode\nobjects with many fields:\n\n type alias Point = { x : Float, y : Float }\n\n point : Decoder Point\n point =\n map2 Point\n (field \"x\" float)\n (field \"y\" float)\n\n -- decodeString point \"\"\"{ \"x\": 3, \"y\": 4 }\"\"\" == Ok { x = 3, y = 4 }\n\nIt tries each individual decoder and puts the result together with the `Point`\nconstructor.\n", "type": "(a -> b -> value) -> Decoder a -> Decoder b -> Decoder value" }, { "name": "map3", "comment": " Try three decoders and then combine the result. We can use this to decode\nobjects with many fields:\n\n type alias Person = { name : String, age : Int, height : Float }\n\n person : Decoder Person\n person =\n map3 Person\n (at [\"name\"] string)\n (at [\"info\",\"age\"] int)\n (at [\"info\",\"height\"] float)\n\n -- json = \"\"\"{ \"name\": \"tom\", \"info\": { \"age\": 42, \"height\": 1.8 } }\"\"\"\n -- decodeString person json == Ok { name = \"tom\", age = 42, height = 1.8 }\n\nLike `map2` it tries each decoder in order and then give the results to the\n`Person` constructor. That can be any function though!\n", "type": "(a -> b -> c -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder value" }, { "name": "map4", "comment": "", "type": "(a -> b -> c -> d -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder value" }, { "name": "map5", "comment": "", "type": "(a -> b -> c -> d -> e -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder value" }, { "name": "map6", "comment": "", "type": "(a -> b -> c -> d -> e -> f -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder value" }, { "name": "map7", "comment": "", "type": "(a -> b -> c -> d -> e -> f -> g -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder value" }, { "name": "map8", "comment": "", "type": "(a -> b -> c -> d -> e -> f -> g -> h -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder g -> Decoder h -> Decoder value" }, { "name": "maybe", "comment": " Helpful for dealing with optional fields. Here are a few slightly different\nexamples:\n\n json = \"\"\"{ \"name\": \"tom\", \"age\": 42 }\"\"\"\n\n decodeString (maybe (field \"age\" int )) json == Ok (Just 42)\n decodeString (maybe (field \"name\" int )) json == Ok Nothing\n decodeString (maybe (field \"height\" float)) json == Ok Nothing\n\n decodeString (field \"age\" (maybe int )) json == Ok (Just 42)\n decodeString (field \"name\" (maybe int )) json == Ok Nothing\n decodeString (field \"height\" (maybe float)) json == Err ...\n\nNotice the last example! It is saying we *must* have a field named `height` and\nthe content *may* be a float. There is no `height` field, so the decoder fails.\n\nPoint is, `maybe` will make exactly what it contains conditional. For optional\nfields, this means you probably want it *outside* a use of `field` or `at`.\n", "type": "Decoder a -> Decoder (Maybe a)" }, { "name": "null", "comment": " Decode a `null` value into some Elm value.\n\n decodeString (null False) \"null\" == Ok False\n decodeString (null 42) \"null\" == Ok 42\n decodeString (null 42) \"42\" == Err ..\n decodeString (null 42) \"false\" == Err ..\n\nSo if you ever see a `null`, this will return whatever value you specified.\n", "type": "a -> Decoder a" }, { "name": "nullable", "comment": " Decode a nullable JSON value into an Elm value.\n\n decodeString (nullable int) \"13\" == Ok (Just 13)\n decodeString (nullable int) \"42\" == Ok (Just 42)\n decodeString (nullable int) \"null\" == Ok Nothing\n decodeString (nullable int) \"true\" == Err ..\n", "type": "Decoder a -> Decoder (Maybe a)" }, { "name": "oneOf", "comment": " Try a bunch of different decoders. This can be useful if the JSON may come\nin a couple different formats. For example, say you want to read an array of\nnumbers, but some of them are `null`.\n\n import String\n\n badInt : Decoder Int\n badInt =\n oneOf [ int, null 0 ]\n\n -- decodeString (list badInt) \"[1,2,null,4]\" == Ok [1,2,0,4]\n\nWhy would someone generate JSON like this? Questions like this are not good\nfor your health. The point is that you can use `oneOf` to handle situations\nlike this!\n\nYou could also use `oneOf` to help version your data. Try the latest format,\nthen a few older ones that you still support. You could use `andThen` to be\neven more particular if you wanted.\n", "type": "List (Decoder a) -> Decoder a" }, { "name": "string", "comment": " Decode a JSON string into an Elm `String`.\n\n decodeString string \"true\" == Err ...\n decodeString string \"42\" == Err ...\n decodeString string \"3.14\" == Err ...\n decodeString string \"\\\"hello\\\"\" == Ok \"hello\"\n decodeString string \"{ \\\"hello\\\": 42 }\" == Err ...\n", "type": "Decoder String" }, { "name": "succeed", "comment": " Ignore the JSON and produce a certain Elm value.\n\n decodeString (succeed 42) \"true\" == Ok 42\n decodeString (succeed 42) \"[1,2,3]\" == Ok 42\n decodeString (succeed 42) \"hello\" == Err ... -- this is not a valid JSON string\n\nThis is handy when used with `oneOf` or `andThen`.\n", "type": "a -> Decoder a" }, { "name": "value", "comment": " Do not do anything with a JSON value, just bring it into Elm as a `Value`.\nThis can be useful if you have particularly crazy data that you would like to\ndeal with later. Or if you are going to send it out a port and do not care\nabout its structure.\n", "type": "Decoder Value" } ], "binops": [] }, { "name": "Dict", "comment": " A dictionary mapping unique keys to values. The keys can be any comparable\ntype. This includes `Int`, `Float`, `Time`, `Char`, `String`, and tuples or\nlists of comparable types.\n\nInsert, remove, and query operations all take *O(log n)* time.\n\n# Dictionaries\n@docs Dict\n\n# Build\n@docs empty, singleton, insert, update, remove\n\n# Query\n@docs isEmpty, member, get, size\n\n# Lists\n@docs keys, values, toList, fromList\n\n# Transform\n@docs map, foldl, foldr, filter, partition\n\n# Combine\n@docs union, intersect, diff, merge\n\n", "unions": [ { "name": "Dict", "comment": " A dictionary of keys and values. So a `(Dict String User)` is a dictionary\nthat lets you look up a `String` (such as user names) and find the associated\n`User`.\n", "args": [ "k", "v" ], "cases": [] } ], "aliases": [], "values": [ { "name": "diff", "comment": " Keep a key-value pair when its key does not appear in the second dictionary.\n", "type": "Dict comparable v -> Dict comparable v -> Dict comparable v" }, { "name": "empty", "comment": " Create an empty dictionary. ", "type": "Dict k v" }, { "name": "filter", "comment": " Keep a key-value pair when it satisfies a predicate. ", "type": "(comparable -> v -> Bool) -> Dict comparable v -> Dict comparable v" }, { "name": "foldl", "comment": " Fold over the key-value pairs in a dictionary, in order from lowest\nkey to highest key.\n", "type": "(comparable -> v -> b -> b) -> b -> Dict comparable v -> b" }, { "name": "foldr", "comment": " Fold over the key-value pairs in a dictionary, in order from highest\nkey to lowest key.\n", "type": "(comparable -> v -> b -> b) -> b -> Dict comparable v -> b" }, { "name": "fromList", "comment": " Convert an association list into a dictionary. ", "type": "List ( comparable, v ) -> Dict comparable v" }, { "name": "get", "comment": " Get the value associated with a key. If the key is not found, return\n`Nothing`. This is useful when you are not sure if a key will be in the\ndictionary.\n\n animals = fromList [ (\"Tom\", Cat), (\"Jerry\", Mouse) ]\n\n get \"Tom\" animals == Just Cat\n get \"Jerry\" animals == Just Mouse\n get \"Spike\" animals == Nothing\n\n", "type": "comparable -> Dict comparable v -> Maybe v" }, { "name": "insert", "comment": " Insert a key-value pair into a dictionary. Replaces value when there is\na collision. ", "type": "comparable -> v -> Dict comparable v -> Dict comparable v" }, { "name": "intersect", "comment": " Keep a key-value pair when its key appears in the second dictionary.\nPreference is given to values in the first dictionary.\n", "type": "Dict comparable v -> Dict comparable v -> Dict comparable v" }, { "name": "isEmpty", "comment": " Determine if a dictionary is empty.\n\n isEmpty empty == True\n", "type": "Dict k v -> Bool" }, { "name": "keys", "comment": " Get all of the keys in a dictionary, sorted from lowest to highest.\n\n keys (fromList [(0,\"Alice\"),(1,\"Bob\")]) == [0,1]\n", "type": "Dict comparable v -> List comparable" }, { "name": "map", "comment": " Apply a function to all values in a dictionary.\n", "type": "(comparable -> a -> b) -> Dict comparable a -> Dict comparable b" }, { "name": "member", "comment": " Determine if a key is in a dictionary. ", "type": "comparable -> Dict comparable v -> Bool" }, { "name": "merge", "comment": " The most general way of combining two dictionaries. You provide three\naccumulators for when a given key appears:\n\n 1. Only in the left dictionary.\n 2. In both dictionaries.\n 3. Only in the right dictionary.\n\nYou then traverse all the keys from lowest to highest, building up whatever\nyou want.\n", "type": "(comparable -> a -> result -> result) -> (comparable -> a -> b -> result -> result) -> (comparable -> b -> result -> result) -> Dict comparable a -> Dict comparable b -> result -> result" }, { "name": "partition", "comment": " Partition a dictionary according to a predicate. The first dictionary\ncontains all key-value pairs which satisfy the predicate, and the second\ncontains the rest.\n", "type": "(comparable -> v -> Bool) -> Dict comparable v -> ( Dict comparable v, Dict comparable v )" }, { "name": "remove", "comment": " Remove a key-value pair from a dictionary. If the key is not found,\nno changes are made. ", "type": "comparable -> Dict comparable v -> Dict comparable v" }, { "name": "singleton", "comment": " Create a dictionary with one key-value pair. ", "type": "comparable -> v -> Dict comparable v" }, { "name": "size", "comment": " Determine the number of key-value pairs in the dictionary. ", "type": "Dict k v -> Int" }, { "name": "toList", "comment": " Convert a dictionary into an association list of key-value pairs, sorted by keys. ", "type": "Dict comparable v -> List ( comparable, v )" }, { "name": "union", "comment": " Combine two dictionaries. If there is a collision, preference is given\nto the first dictionary.\n", "type": "Dict comparable v -> Dict comparable v -> Dict comparable v" }, { "name": "update", "comment": " Update the value of a dictionary for a specific key with a given function. ", "type": "comparable -> (Maybe v -> Maybe v) -> Dict comparable v -> Dict comparable v" }, { "name": "values", "comment": " Get all of the values in a dictionary, in the order of their keys.\n\n values (fromList [(0,\"Alice\"),(1,\"Bob\")]) == [\"Alice\", \"Bob\"]\n", "type": "Dict comparable v -> List v" } ], "binops": [] }, { "name": "Json.Encode", "comment": " Library for turning Elm values into Json values.\n\n# Encoding\n@docs encode, Value\n\n# Primitives\n@docs string, int, float, bool, null\n\n# Arrays\n@docs list, array\n\n# Objects\n@docs object\n", "unions": [ { "name": "Value", "comment": " Represents a JavaScript value.\n", "args": [], "cases": [] } ], "aliases": [], "values": [ { "name": "array", "comment": "", "type": "Array Value -> Value" }, { "name": "bool", "comment": "", "type": "Bool -> Value" }, { "name": "encode", "comment": " Convert a `Value` into a prettified string. The first argument specifies\nthe amount of indentation in the resulting string.\n\n person =\n object\n [ (\"name\", string \"Tom\")\n , (\"age\", int 42)\n ]\n\n compact = encode 0 person\n -- {\"name\":\"Tom\",\"age\":42}\n\n readable = encode 4 person\n -- {\n -- \"name\": \"Tom\",\n -- \"age\": 42\n -- }\n", "type": "Int -> Value -> String" }, { "name": "float", "comment": " Encode a Float. `Infinity` and `NaN` are encoded as `null`.\n", "type": "Float -> Value" }, { "name": "int", "comment": "", "type": "Int -> Value" }, { "name": "list", "comment": "", "type": "List Value -> Value" }, { "name": "null", "comment": "", "type": "Value" }, { "name": "object", "comment": "", "type": "List ( String, Value ) -> Value" }, { "name": "string", "comment": "", "type": "String -> Value" } ], "binops": [] }, { "name": "Task", "comment": " Tasks make it easy to describe asynchronous operations that may fail, like\nHTTP requests or writing to a database. For more information, see the [Elm\ndocumentation on Tasks](http://guide.elm-lang.org/error_handling/task.html).\n\n# Basics\n@docs Task, succeed, fail\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\n# Chaining\n@docs andThen, sequence\n\n# Errors\n@docs onError, mapError\n\n# Commands\n@docs perform, attempt\n\n", "unions": [], "aliases": [ { "name": "Task", "comment": " Represents asynchronous effects that may fail. It is useful for stuff like\nHTTP.\n\nFor example, maybe we have a task with the type (`Task String User`). This means\nthat when we perform the task, it will either fail with a `String` message or\nsucceed with a `User`. So this could represent a task that is asking a server\nfor a certain user.\n", "args": [ "err", "ok" ], "type": "Task err ok" } ], "values": [ { "name": "andThen", "comment": " Chain together a task and a callback. The first task will run, and if it is\nsuccessful, you give the result to the callback resulting in another task. This\ntask then gets run.\n\n succeed 2\n |> andThen (\\n -> succeed (n + 2))\n -- succeed 4\n\nThis is useful for chaining tasks together. Maybe you need to get a user from\nyour servers *and then* lookup their picture once you know their name.\n", "type": "(a -> Task x b) -> Task x a -> Task x b" }, { "name": "attempt", "comment": " Command the Elm runtime to attempt a task that might fail!\n", "type": "(Result x a -> msg) -> Task x a -> Cmd msg" }, { "name": "fail", "comment": " A task that fails immediately when run.\n\n fail \"file not found\" : Task String a\n", "type": "x -> Task x a" }, { "name": "map", "comment": " Transform a task.\n\n map sqrt (succeed 9) -- succeed 3\n", "type": "(a -> b) -> Task x a -> Task x b" }, { "name": "map2", "comment": " Put the results of two tasks together. If either task fails, the whole\nthing fails. It also runs in order so the first task will be completely\nfinished before the second task starts.\n\n map2 (+) (succeed 9) (succeed 3) -- succeed 12\n", "type": "(a -> b -> result) -> Task x a -> Task x b -> Task x result" }, { "name": "map3", "comment": "", "type": "(a -> b -> c -> result) -> Task x a -> Task x b -> Task x c -> Task x result" }, { "name": "map4", "comment": "", "type": "(a -> b -> c -> d -> result) -> Task x a -> Task x b -> Task x c -> Task x d -> Task x result" }, { "name": "map5", "comment": "", "type": "(a -> b -> c -> d -> e -> result) -> Task x a -> Task x b -> Task x c -> Task x d -> Task x e -> Task x result" }, { "name": "mapError", "comment": " Transform the error value. This can be useful if you need a bunch of error\ntypes to match up.\n\n type Error = Http Http.Error | WebGL WebGL.Error\n\n getResources : Task Error Resource\n getResources =\n sequence [ mapError Http serverTask, mapError WebGL textureTask ]\n", "type": "(x -> y) -> Task x a -> Task y a" }, { "name": "onError", "comment": " Recover from a failure in a task. If the given task fails, we use the\ncallback to recover.\n\n fail \"file not found\"\n |> onError (\\msg -> succeed 42)\n -- succeed 42\n\n succeed 9\n |> onError (\\msg -> succeed 42)\n -- succeed 9\n", "type": "(x -> Task y a) -> Task x a -> Task y a" }, { "name": "perform", "comment": " The only way to *do* things in Elm is to give commands to the Elm runtime.\nSo we describe some complex behavior with a `Task` and then command the runtime\nto `perform` that task. For example, getting the current time looks like this:\n\n import Task\n import Time exposing (Time)\n\n type Msg = Click | NewTime Time\n\n update : Msg -> Model -> ( Model, Cmd Msg )\n update msg model =\n case msg of\n Click ->\n ( model, Task.perform NewTime Time.now )\n\n NewTime time ->\n ...\n", "type": "(a -> msg) -> Task Never a -> Cmd msg" }, { "name": "sequence", "comment": " Start with a list of tasks, and turn them into a single task that returns a\nlist. The tasks will be run in order one-by-one and if any task fails the whole\nsequence fails.\n\n sequence [ succeed 1, succeed 2 ] -- succeed [ 1, 2 ]\n\nThis can be useful if you need to make a bunch of HTTP requests one-by-one.\n", "type": "List (Task x a) -> Task x (List a)" }, { "name": "succeed", "comment": " A task that succeeds immediately when run.\n\n succeed 42 -- results in 42\n", "type": "a -> Task x a" } ], "binops": [] }, { "name": "String", "comment": " A built-in representation for efficient string manipulation. String literals\nare enclosed in `\"double quotes\"`. Strings are *not* lists of characters.\n\n# Basics\n@docs isEmpty, length, reverse, repeat\n\n# Building and Splitting\n@docs cons, uncons, fromChar, append, concat, split, join, words, lines\n\n# Get Substrings\n@docs slice, left, right, dropLeft, dropRight\n\n# Check for Substrings\n@docs contains, startsWith, endsWith, indexes, indices\n\n# Conversions\n@docs toInt, toFloat, toList, fromList\n\n# Formatting\nCosmetic operations such as padding with extra characters or trimming whitespace.\n\n@docs toUpper, toLower,\n pad, padLeft, padRight,\n trim, trimLeft, trimRight\n\n# Higher-Order Functions\n@docs map, filter, foldl, foldr, any, all\n", "unions": [], "aliases": [], "values": [ { "name": "all", "comment": " Determine whether *all* characters satisfy a predicate.\n\n all isDigit \"90210\" == True\n all isDigit \"R2-D2\" == False\n all isDigit \"heart\" == False\n", "type": "(Char -> Bool) -> String -> Bool" }, { "name": "any", "comment": " Determine whether *any* characters satisfy a predicate.\n\n any isDigit \"90210\" == True\n any isDigit \"R2-D2\" == True\n any isDigit \"heart\" == False\n", "type": "(Char -> Bool) -> String -> Bool" }, { "name": "append", "comment": " Append two strings. You can also use [the `(++)` operator](Basics#++)\nto do this.\n\n append \"butter\" \"fly\" == \"butterfly\"\n", "type": "String -> String -> String" }, { "name": "concat", "comment": " Concatenate many strings into one.\n\n concat [\"never\",\"the\",\"less\"] == \"nevertheless\"\n", "type": "List String -> String" }, { "name": "cons", "comment": " Add a character to the beginning of a string.\n\n cons 'T' \"he truth is out there\" == \"The truth is out there\"\n", "type": "Char -> String -> String" }, { "name": "contains", "comment": " See if the second string contains the first one.\n\n contains \"the\" \"theory\" == True\n contains \"hat\" \"theory\" == False\n contains \"THE\" \"theory\" == False\n\nUse [`Regex.contains`](Regex#contains) if you need something more flexible.\n", "type": "String -> String -> Bool" }, { "name": "dropLeft", "comment": " Drop *n* characters from the left side of a string.\n\n dropLeft 2 \"The Lone Gunmen\" == \"e Lone Gunmen\"\n", "type": "Int -> String -> String" }, { "name": "dropRight", "comment": " Drop *n* characters from the right side of a string.\n\n dropRight 2 \"Cigarette Smoking Man\" == \"Cigarette Smoking M\"\n", "type": "Int -> String -> String" }, { "name": "endsWith", "comment": " See if the second string ends with the first one.\n\n endsWith \"the\" \"theory\" == False\n endsWith \"ory\" \"theory\" == True\n", "type": "String -> String -> Bool" }, { "name": "filter", "comment": " Keep only the characters that satisfy the predicate.\n\n filter isDigit \"R2-D2\" == \"22\"\n", "type": "(Char -> Bool) -> String -> String" }, { "name": "foldl", "comment": " Reduce a string from the left.\n\n foldl cons \"\" \"time\" == \"emit\"\n", "type": "(Char -> b -> b) -> b -> String -> b" }, { "name": "foldr", "comment": " Reduce a string from the right.\n\n foldr cons \"\" \"time\" == \"time\"\n", "type": "(Char -> b -> b) -> b -> String -> b" }, { "name": "fromChar", "comment": " Create a string from a given character.\n\n fromChar 'a' == \"a\"\n", "type": "Char -> String" }, { "name": "fromList", "comment": " Convert a list of characters into a String. Can be useful if you\nwant to create a string primarily by consing, perhaps for decoding\nsomething.\n\n fromList ['a','b','c'] == \"abc\"\n", "type": "List Char -> String" }, { "name": "indexes", "comment": " Get all of the indexes for a substring in another string.\n\n indexes \"i\" \"Mississippi\" == [1,4,7,10]\n indexes \"ss\" \"Mississippi\" == [2,5]\n indexes \"needle\" \"haystack\" == []\n", "type": "String -> String -> List Int" }, { "name": "indices", "comment": " Alias for `indexes`. ", "type": "String -> String -> List Int" }, { "name": "isEmpty", "comment": " Determine if a string is empty.\n\n isEmpty \"\" == True\n isEmpty \"the world\" == False\n", "type": "String -> Bool" }, { "name": "join", "comment": " Put many strings together with a given separator.\n\n join \"a\" [\"H\",\"w\",\"ii\",\"n\"] == \"Hawaiian\"\n join \" \" [\"cat\",\"dog\",\"cow\"] == \"cat dog cow\"\n join \"/\" [\"home\",\"evan\",\"Desktop\"] == \"home/evan/Desktop\"\n", "type": "String -> List String -> String" }, { "name": "left", "comment": " Take *n* characters from the left side of a string.\n\n left 2 \"Mulder\" == \"Mu\"\n", "type": "Int -> String -> String" }, { "name": "length", "comment": " Get the length of a string.\n\n length \"innumerable\" == 11\n length \"\" == 0\n\n", "type": "String -> Int" }, { "name": "lines", "comment": " Break a string into lines, splitting on newlines.\n\n lines \"How are you?\\nGood?\" == [\"How are you?\", \"Good?\"]\n", "type": "String -> List String" }, { "name": "map", "comment": " Transform every character in a string\n\n map (\\c -> if c == '/' then '.' else c) \"a/b/c\" == \"a.b.c\"\n", "type": "(Char -> Char) -> String -> String" }, { "name": "pad", "comment": " Pad a string on both sides until it has a given length.\n\n pad 5 ' ' \"1\" == \" 1 \"\n pad 5 ' ' \"11\" == \" 11 \"\n pad 5 ' ' \"121\" == \" 121 \"\n", "type": "Int -> Char -> String -> String" }, { "name": "padLeft", "comment": " Pad a string on the left until it has a given length.\n\n padLeft 5 '.' \"1\" == \"....1\"\n padLeft 5 '.' \"11\" == \"...11\"\n padLeft 5 '.' \"121\" == \"..121\"\n", "type": "Int -> Char -> String -> String" }, { "name": "padRight", "comment": " Pad a string on the right until it has a given length.\n\n padRight 5 '.' \"1\" == \"1....\"\n padRight 5 '.' \"11\" == \"11...\"\n padRight 5 '.' \"121\" == \"121..\"\n", "type": "Int -> Char -> String -> String" }, { "name": "repeat", "comment": " Repeat a string *n* times.\n\n repeat 3 \"ha\" == \"hahaha\"\n", "type": "Int -> String -> String" }, { "name": "reverse", "comment": " Reverse a string.\n\n reverse \"stressed\" == \"desserts\"\n", "type": "String -> String" }, { "name": "right", "comment": " Take *n* characters from the right side of a string.\n\n right 2 \"Scully\" == \"ly\"\n", "type": "Int -> String -> String" }, { "name": "slice", "comment": " Take a substring given a start and end index. Negative indexes\nare taken starting from the *end* of the list.\n\n slice 7 9 \"snakes on a plane!\" == \"on\"\n slice 0 6 \"snakes on a plane!\" == \"snakes\"\n slice 0 -7 \"snakes on a plane!\" == \"snakes on a\"\n slice -6 -1 \"snakes on a plane!\" == \"plane\"\n", "type": "Int -> Int -> String -> String" }, { "name": "split", "comment": " Split a string using a given separator.\n\n split \",\" \"cat,dog,cow\" == [\"cat\",\"dog\",\"cow\"]\n split \"/\" \"home/evan/Desktop/\" == [\"home\",\"evan\",\"Desktop\", \"\"]\n\nUse [`Regex.split`](Regex#split) if you need something more flexible.\n", "type": "String -> String -> List String" }, { "name": "startsWith", "comment": " See if the second string starts with the first one.\n\n startsWith \"the\" \"theory\" == True\n startsWith \"ory\" \"theory\" == False\n", "type": "String -> String -> Bool" }, { "name": "toFloat", "comment": " Try to convert a string into a float, failing on improperly formatted strings.\n\n String.toFloat \"123\" == Ok 123.0\n String.toFloat \"-42\" == Ok -42.0\n String.toFloat \"3.1\" == Ok 3.1\n String.toFloat \"31a\" == Err \"could not convert string '31a' to a Float\"\n\nIf you are extracting a number from some raw user input, you will typically\nwant to use [`Result.withDefault`](Result#withDefault) to handle bad data:\n\n Result.withDefault 0 (String.toFloat \"42.5\") == 42.5\n Result.withDefault 0 (String.toFloat \"cats\") == 0\n", "type": "String -> Result String Float" }, { "name": "toInt", "comment": " Try to convert a string into an int, failing on improperly formatted strings.\n\n String.toInt \"123\" == Ok 123\n String.toInt \"-42\" == Ok -42\n String.toInt \"3.1\" == Err \"could not convert string '3.1' to an Int\"\n String.toInt \"31a\" == Err \"could not convert string '31a' to an Int\"\n\nIf you are extracting a number from some raw user input, you will typically\nwant to use [`Result.withDefault`](Result#withDefault) to handle bad data:\n\n Result.withDefault 0 (String.toInt \"42\") == 42\n Result.withDefault 0 (String.toInt \"ab\") == 0\n", "type": "String -> Result String Int" }, { "name": "toList", "comment": " Convert a string to a list of characters.\n\n toList \"abc\" == ['a','b','c']\n", "type": "String -> List Char" }, { "name": "toLower", "comment": " Convert a string to all lower case. Useful for case-insensitive comparisons.\n\n toLower \"X-FILES\" == \"x-files\"\n", "type": "String -> String" }, { "name": "toUpper", "comment": " Convert a string to all upper case. Useful for case-insensitive comparisons\nand VIRTUAL YELLING.\n\n toUpper \"skinner\" == \"SKINNER\"\n", "type": "String -> String" }, { "name": "trim", "comment": " Get rid of whitespace on both sides of a string.\n\n trim \" hats \\n\" == \"hats\"\n", "type": "String -> String" }, { "name": "trimLeft", "comment": " Get rid of whitespace on the left of a string.\n\n trimLeft \" hats \\n\" == \"hats \\n\"\n", "type": "String -> String" }, { "name": "trimRight", "comment": " Get rid of whitespace on the right of a string.\n\n trimRight \" hats \\n\" == \" hats\"\n", "type": "String -> String" }, { "name": "uncons", "comment": " Split a non-empty string into its head and tail. This lets you\npattern match on strings exactly as you would with lists.\n\n uncons \"abc\" == Just ('a',\"bc\")\n uncons \"\" == Nothing\n", "type": "String -> Maybe ( Char, String )" }, { "name": "words", "comment": " Break a string into words, splitting on chunks of whitespace.\n\n words \"How are \\t you? \\n Good?\" == [\"How\",\"are\",\"you?\",\"Good?\"]\n", "type": "String -> List String" } ], "binops": [] }, { "name": "Array", "comment": " A library for fast immutable arrays. The elements in an array must have the\nsame type. The arrays are implemented in Relaxed Radix Balanced-Trees for fast\nreads, updates, and appends.\n\n# Arrays\n@docs Array\n\n# Creating Arrays\n@docs empty, repeat, initialize, fromList\n\n# Basics\n@docs isEmpty, length, push, append\n\n# Get and Set\n@docs get, set\n\n# Taking Arrays Apart\n@docs slice, toList, toIndexedList\n\n# Mapping, Filtering, and Folding\n@docs map, indexedMap, filter, foldl, foldr\n", "unions": [ { "name": "Array", "comment": " Representation of fast immutable arrays. You can create arrays of integers\n(`Array Int`) or strings (`Array String`) or any other type of value you can\ndream up.\n", "args": [ "a" ], "cases": [] } ], "aliases": [], "values": [ { "name": "append", "comment": " Append two arrays to a new one.\n\n append (repeat 2 42) (repeat 3 81) == fromList [42,42,81,81,81]\n", "type": "Array a -> Array a -> Array a" }, { "name": "empty", "comment": " Return an empty array.\n\n length empty == 0\n", "type": "Array a" }, { "name": "filter", "comment": " Keep only elements that satisfy the predicate:\n\n filter isEven (fromList [1,2,3,4,5,6]) == (fromList [2,4,6])\n", "type": "(a -> Bool) -> Array a -> Array a" }, { "name": "foldl", "comment": " Reduce an array from the left. Read `foldl` as “fold from the left”.\n\n foldl (::) [] (fromList [1,2,3]) == [3,2,1]\n", "type": "(a -> b -> b) -> b -> Array a -> b" }, { "name": "foldr", "comment": " Reduce an array from the right. Read `foldr` as “fold from the right”.\n\n foldr (+) 0 (repeat 3 5) == 15\n", "type": "(a -> b -> b) -> b -> Array a -> b" }, { "name": "fromList", "comment": " Create an array from a list.\n", "type": "List a -> Array a" }, { "name": "get", "comment": " Return Just the element at the index or Nothing if the index is out of range.\n\n get 0 (fromList [0,5,3]) == Just 0\n get 2 (fromList [0,5,3]) == Just 3\n get 5 (fromList [0,5,3]) == Nothing\n get -1 (fromList [0,5,3]) == Nothing\n\n", "type": "Int -> Array a -> Maybe a" }, { "name": "indexedMap", "comment": " Apply a function on every element with its index as first argument.\n\n indexedMap (*) (fromList [5,5,5]) == fromList [0,5,10]\n", "type": "(Int -> a -> b) -> Array a -> Array b" }, { "name": "initialize", "comment": " Initialize an array. `initialize n f` creates an array of length `n` with\nthe element at index `i` initialized to the result of `(f i)`.\n\n initialize 4 identity == fromList [0,1,2,3]\n initialize 4 (\\n -> n*n) == fromList [0,1,4,9]\n initialize 4 (always 0) == fromList [0,0,0,0]\n", "type": "Int -> (Int -> a) -> Array a" }, { "name": "isEmpty", "comment": " Determine if an array is empty.\n\n isEmpty empty == True\n", "type": "Array a -> Bool" }, { "name": "length", "comment": " Return the length of an array.\n\n length (fromList [1,2,3]) == 3\n", "type": "Array a -> Int" }, { "name": "map", "comment": " Apply a function on every element in an array.\n\n map sqrt (fromList [1,4,9]) == fromList [1,2,3]\n", "type": "(a -> b) -> Array a -> Array b" }, { "name": "push", "comment": " Push an element to the end of an array.\n\n push 3 (fromList [1,2]) == fromList [1,2,3]\n", "type": "a -> Array a -> Array a" }, { "name": "repeat", "comment": " Creates an array with a given length, filled with a default element.\n\n repeat 5 0 == fromList [0,0,0,0,0]\n repeat 3 \"cat\" == fromList [\"cat\",\"cat\",\"cat\"]\n\nNotice that `repeat 3 x` is the same as `initialize 3 (always x)`.\n", "type": "Int -> a -> Array a" }, { "name": "set", "comment": " Set the element at a particular index. Returns an updated array.\nIf the index is out of range, the array is unaltered.\n\n set 1 7 (fromList [1,2,3]) == fromList [1,7,3]\n", "type": "Int -> a -> Array a -> Array a" }, { "name": "slice", "comment": " Get a sub-section of an array: `(slice start end array)`. The `start` is a\nzero-based index where we will start our slice. The `end` is a zero-based index\nthat indicates the end of the slice. The slice extracts up to but not including\n`end`.\n\n slice 0 3 (fromList [0,1,2,3,4]) == fromList [0,1,2]\n slice 1 4 (fromList [0,1,2,3,4]) == fromList [1,2,3]\n\nBoth the `start` and `end` indexes can be negative, indicating an offset from\nthe end of the array.\n\n slice 1 -1 (fromList [0,1,2,3,4]) == fromList [1,2,3]\n slice -2 5 (fromList [0,1,2,3,4]) == fromList [3,4]\n\nThis makes it pretty easy to `pop` the last element off of an array: `slice 0 -1 array`\n", "type": "Int -> Int -> Array a -> Array a" }, { "name": "toIndexedList", "comment": " Create an indexed list from an array. Each element of the array will be\npaired with its index.\n\n toIndexedList (fromList [\"cat\",\"dog\"]) == [(0,\"cat\"), (1,\"dog\")]\n", "type": "Array a -> List ( Int, a )" }, { "name": "toList", "comment": " Create a list of elements from an array.\n\n toList (fromList [3,5,8]) == [3,5,8]\n", "type": "Array a -> List a" } ], "binops": [] }, { "name": "Platform", "comment": "\n\n# Programs\n@docs Program, program, programWithFlags\n\n# Platform Internals\n\n## Tasks and Processes\n@docs Task, ProcessId\n\n## Effect Manager Helpers\n\nAn extremely tiny portion of library authors should ever write effect managers.\nFundamentally, Elm needs maybe 10 of them total. I get that people are smart,\ncurious, etc. but that is not a substitute for a legitimate reason to make an\neffect manager. Do you have an *organic need* this fills? Or are you just\ncurious? Public discussions of your explorations should be framed accordingly.\n\n@docs Router, sendToApp, sendToSelf\n", "unions": [ { "name": "ProcessId", "comment": " Head over to the documentation for the [`Process`](Process) module for\ninformation on this. It is only defined here because it is a platform\nprimitive.\n", "args": [], "cases": [] }, { "name": "Program", "comment": " A `Program` describes how to manage your Elm app.\n\nYou can create [headless][] programs with the [`program`](#program) and\n[`programWithFlags`](#programWithFlags) functions. Similar functions exist in\n[`Html`][html] that let you specify a view.\n\n[headless]: https://en.wikipedia.org/wiki/Headless_software\n[html]: http://package.elm-lang.org/packages/elm-lang/html/latest/Html\n\nHonestly, it is totally normal if this seems crazy at first. The best way to\nunderstand is to work through [guide.elm-lang.org](http://guide.elm-lang.org/).\nIt makes way more sense in context!\n", "args": [ "flags", "model", "msg" ], "cases": [] }, { "name": "Router", "comment": " An effect manager has access to a “router” that routes messages between\nthe main app and your individual effect manager.\n", "args": [ "appMsg", "selfMsg" ], "cases": [] }, { "name": "Task", "comment": " Head over to the documentation for the [`Task`](Task) module for more\ninformation on this. It is only defined here because it is a platform\nprimitive.\n", "args": [ "err", "ok" ], "cases": [] } ], "aliases": [], "values": [ { "name": "program", "comment": " Create a [headless][] program. This is great if you want to use Elm as the\n“brain” for something else. You can still communicate with JS via\nports and manage your model, you just do not have to specify a `view`.\n\n[headless]: https://en.wikipedia.org/wiki/Headless_software\n\nInitializing a headless program from JavaScript looks like this:\n\n```javascript\nvar app = Elm.MyThing.worker();\n```\n", "type": "{ init : ( model, Cmd msg ), update : msg -> model -> ( model, Cmd msg ), subscriptions : model -> Sub msg } -> Program Never model msg" }, { "name": "programWithFlags", "comment": " Same as [`program`](#program), but you can provide flags. Initializing a\nheadless program (with flags) from JavaScript looks like this:\n\n```javascript\nvar app = Elm.MyThing.worker({ user: 'Tom', token: 1234 });\n```\n\nWhatever argument you provide to `worker` will get converted to an Elm value,\nallowing you to configure your Elm program however you want from JavaScript!\n", "type": "{ init : flags -> ( model, Cmd msg ), update : msg -> model -> ( model, Cmd msg ), subscriptions : model -> Sub msg } -> Program flags model msg" }, { "name": "sendToApp", "comment": " Send the router a message for the main loop of your app. This message will\nbe handled by the overall `update` function, just like events from `Html`.\n", "type": "Router msg a -> msg -> Task x ()" }, { "name": "sendToSelf", "comment": " Send the router a message for your effect manager. This message will\nbe routed to the `onSelfMsg` function, where you can update the state of your\neffect manager as necessary.\n\nAs an example, the effect manager for web sockets\n", "type": "Router a msg -> msg -> Task x ()" } ], "binops": [] }, { "name": "Regex", "comment": " A library for working with regular expressions. It uses [the\nsame kind of regular expressions accepted by JavaScript](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions).\n\n# Create\n@docs Regex, regex, escape, caseInsensitive\n\n# Helpful Data Structures\n\nThese data structures are needed to help define functions like [`find`](#find)\nand [`replace`](#replace).\n\n@docs HowMany, Match\n\n# Use\n@docs contains, find, replace, split\n\n", "unions": [ { "name": "HowMany", "comment": " `HowMany` is used to specify how many matches you want to make. So\n`replace All` would replace every match, but `replace (AtMost 2)` would\nreplace at most two matches (i.e. zero, one, two, but never three or more).\n", "args": [], "cases": [ [ "All", [] ], [ "AtMost", [ "Int" ] ] ] }, { "name": "Regex", "comment": " A regular expression, describing a certain set of strings.\n", "args": [], "cases": [] } ], "aliases": [ { "name": "Match", "comment": " A `Match` represents all of the details about a particular match in a string.\nHere are details on each field:\n\n * `match` — the full string of the match.\n * `submatches` — a regex might have [subpatterns, surrounded by\n parentheses](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches).\n If there are N subpatterns, there will be N elements in the `submatches` list.\n Each submatch in this list is a `Maybe` because not all subpatterns may trigger.\n For example, `(regex \"(a+)|(b+)\")` will either match many `a`’s or\n many `b`’s, but never both.\n * `index` — the index of the match in the original string.\n * `number` — if you find many matches, you can think of each one\n as being labeled with a `number` starting at one. So the first time you\n find a match, that is match `number` one. Second time is match `number` two.\n This is useful when paired with `replace All` if replacement is dependent on how\n many times a pattern has appeared before.\n", "args": [], "type": "{ match : String, submatches : List (Maybe String), index : Int, number : Int }" } ], "values": [ { "name": "caseInsensitive", "comment": " Make a regex case insensitive ", "type": "Regex -> Regex" }, { "name": "contains", "comment": " Check to see if a Regex is contained in a string.\n\n contains (regex \"123\") \"12345\" == True\n contains (regex \"b+\") \"aabbcc\" == True\n\n contains (regex \"789\") \"12345\" == False\n contains (regex \"z+\") \"aabbcc\" == False\n", "type": "Regex -> String -> Bool" }, { "name": "escape", "comment": " Escape strings to be regular expressions, making all special characters\nsafe. So `regex (escape \"^a+\")` will match exactly `\"^a+\"` instead of a series\nof `a`’s that start at the beginning of the line.\n", "type": "String -> String" }, { "name": "find", "comment": " Find matches in a string:\n\n findTwoCommas = find (AtMost 2) (regex \",\")\n\n -- map .index (findTwoCommas \"a,b,c,d,e\") == [1,3]\n -- map .index (findTwoCommas \"a b c d e\") == []\n\n places = find All (regex \"[oi]n a (\\\\w+)\") \"I am on a boat in a lake.\"\n\n -- map .match places == [\"on a boat\", \"in a lake\"]\n -- map .submatches places == [ [Just \"boat\"], [Just \"lake\"] ]\n", "type": "HowMany -> Regex -> String -> List Match" }, { "name": "regex", "comment": " Create a Regex that matches patterns [as specified in JavaScript](https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions#Writing_a_Regular_Expression_Pattern).\n\nBe careful to escape backslashes properly! For example, `\"\\w\"` is escaping the\nletter `w` which is probably not what you want. You probably want `\"\\\\w\"`\ninstead, which escapes the backslash.\n", "type": "String -> Regex" }, { "name": "replace", "comment": " Replace matches. The function from `Match` to `String` lets\nyou use the details of a specific match when making replacements.\n\n devowel = replace All (regex \"[aeiou]\") (\\_ -> \"\")\n\n -- devowel \"The quick brown fox\" == \"Th qck brwn fx\"\n\n reverseWords = replace All (regex \"\\\\w+\") (\\{match} -> String.reverse match)\n\n -- reverseWords \"deliver mined parts\" == \"reviled denim strap\"\n", "type": "HowMany -> Regex -> (Match -> String) -> String -> String" }, { "name": "split", "comment": " Split a string, using the regex as the separator.\n\n split (AtMost 1) (regex \",\") \"tom,99,90,85\" == [\"tom\",\"99,90,85\"]\n\n split All (regex \",\") \"a,b,c,d\" == [\"a\",\"b\",\"c\",\"d\"]\n", "type": "HowMany -> Regex -> String -> List String" } ], "binops": [] }, { "name": "Result", "comment": " A `Result` is the result of a computation that may fail. This is a great\nway to manage errors in Elm.\n\n# Type and Constructors\n@docs Result\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\n# Chaining\n@docs andThen\n\n# Handling Errors\n@docs withDefault, toMaybe, fromMaybe, mapError\n", "unions": [ { "name": "Result", "comment": " A `Result` is either `Ok` meaning the computation succeeded, or it is an\n`Err` meaning that there was some failure.\n", "args": [ "error", "value" ], "cases": [ [ "Ok", [ "value" ] ], [ "Err", [ "error" ] ] ] } ], "aliases": [], "values": [ { "name": "andThen", "comment": " Chain together a sequence of computations that may fail. It is helpful\nto see its definition:\n\n andThen : (a -> Result e b) -> Result e a -> Result e b\n andThen callback result =\n case result of\n Ok value -> callback value\n Err msg -> Err msg\n\nThis means we only continue with the callback if things are going well. For\nexample, say you need to use (`toInt : String -> Result String Int`) to parse\na month and make sure it is between 1 and 12:\n\n toValidMonth : Int -> Result String Int\n toValidMonth month =\n if month >= 1 && month <= 12\n then Ok month\n else Err \"months must be between 1 and 12\"\n\n toMonth : String -> Result String Int\n toMonth rawString =\n toInt rawString\n |> andThen toValidMonth\n\n -- toMonth \"4\" == Ok 4\n -- toMonth \"9\" == Ok 9\n -- toMonth \"a\" == Err \"cannot parse to an Int\"\n -- toMonth \"0\" == Err \"months must be between 1 and 12\"\n\nThis allows us to come out of a chain of operations with quite a specific error\nmessage. It is often best to create a custom type that explicitly represents\nthe exact ways your computation may fail. This way it is easy to handle in your\ncode.\n", "type": "(a -> Result x b) -> Result x a -> Result x b" }, { "name": "fromMaybe", "comment": " Convert from a simple `Maybe` to interact with some code that primarily\nuses `Results`.\n\n parseInt : String -> Maybe Int\n\n resultParseInt : String -> Result String Int\n resultParseInt string =\n fromMaybe (\"error parsing string: \" ++ toString string) (parseInt string)\n", "type": "x -> Maybe a -> Result x a" }, { "name": "map", "comment": " Apply a function to a result. If the result is `Ok`, it will be converted.\nIf the result is an `Err`, the same error value will propagate through.\n\n map sqrt (Ok 4.0) == Ok 2.0\n map sqrt (Err \"bad input\") == Err \"bad input\"\n", "type": "(a -> value) -> Result x a -> Result x value" }, { "name": "map2", "comment": " Apply a function to two results, if both results are `Ok`. If not,\nthe first argument which is an `Err` will propagate through.\n\n map2 (+) (String.toInt \"1\") (String.toInt \"2\") == Ok 3\n map2 (+) (String.toInt \"1\") (String.toInt \"y\") == Err \"could not convert string 'y' to an Int\"\n map2 (+) (String.toInt \"x\") (String.toInt \"y\") == Err \"could not convert string 'x' to an Int\"\n", "type": "(a -> b -> value) -> Result x a -> Result x b -> Result x value" }, { "name": "map3", "comment": "", "type": "(a -> b -> c -> value) -> Result x a -> Result x b -> Result x c -> Result x value" }, { "name": "map4", "comment": "", "type": "(a -> b -> c -> d -> value) -> Result x a -> Result x b -> Result x c -> Result x d -> Result x value" }, { "name": "map5", "comment": "", "type": "(a -> b -> c -> d -> e -> value) -> Result x a -> Result x b -> Result x c -> Result x d -> Result x e -> Result x value" }, { "name": "mapError", "comment": " Transform an `Err` value. For example, say the errors we get have too much\ninformation:\n\n parseInt : String -> Result ParseError Int\n\n type alias ParseError =\n { message : String\n , code : Int\n , position : (Int,Int)\n }\n\n mapError .message (parseInt \"123\") == Ok 123\n mapError .message (parseInt \"abc\") == Err \"char 'a' is not a number\"\n", "type": "(x -> y) -> Result x a -> Result y a" }, { "name": "toMaybe", "comment": " Convert to a simpler `Maybe` if the actual error message is not needed or\nyou need to interact with some code that primarily uses maybes.\n\n parseInt : String -> Result ParseError Int\n\n maybeParseInt : String -> Maybe Int\n maybeParseInt string =\n toMaybe (parseInt string)\n", "type": "Result x a -> Maybe a" }, { "name": "withDefault", "comment": " If the result is `Ok` return the value, but if the result is an `Err` then\nreturn a given default value. The following examples try to parse integers.\n\n Result.withDefault 0 (String.toInt \"123\") == 123\n Result.withDefault 0 (String.toInt \"abc\") == 0\n", "type": "a -> Result x a -> a" } ], "binops": [] }, { "name": "List", "comment": " A library for manipulating lists of values. Every value in a\nlist must have the same type.\n\n# Basics\n@docs isEmpty, length, reverse, member\n\n# Sub-lists\n@docs head, tail, filter, take, drop\n\n# Putting Lists Together\n@docs singleton, repeat, range, (::), append, concat, intersperse\n\n# Taking Lists Apart\n@docs partition, unzip\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\nIf you can think of a legitimate use of `mapN` where `N` is 6 or more, please\nlet us know on [the list](https://groups.google.com/forum/#!forum/elm-discuss).\nThe current sentiment is that it is already quite error prone once you get to\n4 and possibly should be approached another way.\n\n# Special Maps\n@docs filterMap, concatMap, indexedMap\n\n# Folding\n@docs foldr, foldl\n\n# Special Folds\n@docs sum, product, maximum, minimum, all, any, scanl\n\n# Sorting\n@docs sort, sortBy, sortWith\n\n", "unions": [], "aliases": [], "values": [ { "name": "all", "comment": " Determine if all elements satisfy the predicate.\n\n all isEven [2,4] == True\n all isEven [2,3] == False\n all isEven [] == True\n", "type": "(a -> Bool) -> List a -> Bool" }, { "name": "any", "comment": " Determine if any elements satisfy the predicate.\n\n any isEven [2,3] == True\n any isEven [1,3] == False\n any isEven [] == False\n", "type": "(a -> Bool) -> List a -> Bool" }, { "name": "append", "comment": " Put two lists together.\n\n append [1,1,2] [3,5,8] == [1,1,2,3,5,8]\n append ['a','b'] ['c'] == ['a','b','c']\n\nYou can also use [the `(++)` operator](Basics#++) to append lists.\n", "type": "List a -> List a -> List a" }, { "name": "concat", "comment": " Concatenate a bunch of lists into a single list:\n\n concat [[1,2],[3],[4,5]] == [1,2,3,4,5]\n", "type": "List (List a) -> List a" }, { "name": "concatMap", "comment": " Map a given function onto a list and flatten the resulting lists.\n\n concatMap f xs == concat (map f xs)\n", "type": "(a -> List b) -> List a -> List b" }, { "name": "drop", "comment": " Drop the first *n* members of a list.\n\n drop 2 [1,2,3,4] == [3,4]\n", "type": "Int -> List a -> List a" }, { "name": "filter", "comment": " Keep only elements that satisfy the predicate.\n\n filter isEven [1,2,3,4,5,6] == [2,4,6]\n", "type": "(a -> Bool) -> List a -> List a" }, { "name": "filterMap", "comment": " Apply a function that may succeed to all values in the list, but only keep\nthe successes.\n\n onlyTeens =\n filterMap isTeen [3, 15, 12, 18, 24] == [15, 18]\n\n isTeen : Int -> Maybe Int\n isTeen n =\n if 13 <= n && n <= 19 then\n Just n\n\n else\n Nothing\n", "type": "(a -> Maybe b) -> List a -> List b" }, { "name": "foldl", "comment": " Reduce a list from the left.\n\n foldl (::) [] [1,2,3] == [3,2,1]\n", "type": "(a -> b -> b) -> b -> List a -> b" }, { "name": "foldr", "comment": " Reduce a list from the right.\n\n foldr (+) 0 [1,2,3] == 6\n", "type": "(a -> b -> b) -> b -> List a -> b" }, { "name": "head", "comment": " Extract the first element of a list.\n\n head [1,2,3] == Just 1\n head [] == Nothing\n", "type": "List a -> Maybe a" }, { "name": "indexedMap", "comment": " Same as `map` but the function is also applied to the index of each\nelement (starting at zero).\n\n indexedMap (,) [\"Tom\",\"Sue\",\"Bob\"] == [ (0,\"Tom\"), (1,\"Sue\"), (2,\"Bob\") ]\n", "type": "(Int -> a -> b) -> List a -> List b" }, { "name": "intersperse", "comment": " Places the given value between all members of the given list.\n\n intersperse \"on\" [\"turtles\",\"turtles\",\"turtles\"] == [\"turtles\",\"on\",\"turtles\",\"on\",\"turtles\"]\n", "type": "a -> List a -> List a" }, { "name": "isEmpty", "comment": " Determine if a list is empty.\n\n isEmpty [] == True\n", "type": "List a -> Bool" }, { "name": "length", "comment": " Determine the length of a list.\n\n length [1,2,3] == 3\n", "type": "List a -> Int" }, { "name": "map", "comment": " Apply a function to every element of a list.\n\n map sqrt [1,4,9] == [1,2,3]\n\n map not [True,False,True] == [False,True,False]\n", "type": "(a -> b) -> List a -> List b" }, { "name": "map2", "comment": " Combine two lists, combining them with the given function.\nIf one list is longer, the extra elements are dropped.\n\n map2 (+) [1,2,3] [1,2,3,4] == [2,4,6]\n\n map2 (,) [1,2,3] ['a','b'] == [ (1,'a'), (2,'b') ]\n\n pairs : List a -> List b -> List (a,b)\n pairs lefts rights =\n map2 (,) lefts rights\n", "type": "(a -> b -> result) -> List a -> List b -> List result" }, { "name": "map3", "comment": "", "type": "(a -> b -> c -> result) -> List a -> List b -> List c -> List result" }, { "name": "map4", "comment": "", "type": "(a -> b -> c -> d -> result) -> List a -> List b -> List c -> List d -> List result" }, { "name": "map5", "comment": "", "type": "(a -> b -> c -> d -> e -> result) -> List a -> List b -> List c -> List d -> List e -> List result" }, { "name": "maximum", "comment": " Find the maximum element in a non-empty list.\n\n maximum [1,4,2] == Just 4\n maximum [] == Nothing\n", "type": "List comparable -> Maybe comparable" }, { "name": "member", "comment": " Figure out whether a list contains a value.\n\n member 9 [1,2,3,4] == False\n member 4 [1,2,3,4] == True\n", "type": "a -> List a -> Bool" }, { "name": "minimum", "comment": " Find the minimum element in a non-empty list.\n\n minimum [3,2,1] == Just 1\n minimum [] == Nothing\n", "type": "List comparable -> Maybe comparable" }, { "name": "partition", "comment": " Partition a list based on a predicate. The first list contains all values\nthat satisfy the predicate, and the second list contains all the value that do\nnot.\n\n partition (\\x -> x < 3) [0,1,2,3,4,5] == ([0,1,2], [3,4,5])\n partition isEven [0,1,2,3,4,5] == ([0,2,4], [1,3,5])\n", "type": "(a -> Bool) -> List a -> ( List a, List a )" }, { "name": "product", "comment": " Get the product of the list elements.\n\n product [1,2,3,4] == 24\n", "type": "List number -> number" }, { "name": "range", "comment": " Create a list of numbers, every element increasing by one.\nYou give the lowest and highest number that should be in the list.\n\n range 3 6 == [3, 4, 5, 6]\n range 3 3 == [3]\n range 6 3 == []\n", "type": "Int -> Int -> List Int" }, { "name": "repeat", "comment": " Create a list with *n* copies of a value:\n\n repeat 3 (0,0) == [(0,0),(0,0),(0,0)]\n", "type": "Int -> a -> List a" }, { "name": "reverse", "comment": " Reverse a list.\n\n reverse [1,2,3,4] == [4,3,2,1]\n", "type": "List a -> List a" }, { "name": "scanl", "comment": " Reduce a list from the left, building up all of the intermediate results into a list.\n\n scanl (+) 0 [1,2,3,4] == [0,1,3,6,10]\n", "type": "(a -> b -> b) -> b -> List a -> List b" }, { "name": "singleton", "comment": " Create a list with only one element:\n\n singleton 1234 == [1234]\n singleton \"hi\" == [\"hi\"]\n", "type": "a -> List a" }, { "name": "sort", "comment": " Sort values from lowest to highest\n\n sort [3,1,5] == [1,3,5]\n", "type": "List comparable -> List comparable" }, { "name": "sortBy", "comment": " Sort values by a derived property.\n\n alice = { name=\"Alice\", height=1.62 }\n bob = { name=\"Bob\" , height=1.85 }\n chuck = { name=\"Chuck\", height=1.76 }\n\n sortBy .name [chuck,alice,bob] == [alice,bob,chuck]\n sortBy .height [chuck,alice,bob] == [alice,chuck,bob]\n\n sortBy String.length [\"mouse\",\"cat\"] == [\"cat\",\"mouse\"]\n", "type": "(a -> comparable) -> List a -> List a" }, { "name": "sortWith", "comment": " Sort values with a custom comparison function.\n\n sortWith flippedComparison [1,2,3,4,5] == [5,4,3,2,1]\n\n flippedComparison a b =\n case compare a b of\n LT -> GT\n EQ -> EQ\n GT -> LT\n\nThis is also the most general sort function, allowing you\nto define any other: `sort == sortWith compare`\n", "type": "(a -> a -> Order) -> List a -> List a" }, { "name": "sum", "comment": " Get the sum of the list elements.\n\n sum [1,2,3,4] == 10\n", "type": "List number -> number" }, { "name": "tail", "comment": " Extract the rest of the list.\n\n tail [1,2,3] == Just [2,3]\n tail [] == Nothing\n", "type": "List a -> Maybe (List a)" }, { "name": "take", "comment": " Take the first *n* members of a list.\n\n take 2 [1,2,3,4] == [1,2]\n", "type": "Int -> List a -> List a" }, { "name": "unzip", "comment": " Decompose a list of tuples into a tuple of lists.\n\n unzip [(0, True), (17, False), (1337, True)] == ([0,17,1337], [True,False,True])\n", "type": "List ( a, b ) -> ( List a, List b )" } ], "binops": [ { "name": "::", "comment": " Add an element to the front of a list. Pronounced *cons*.\n\n 1 :: [2,3] == [1,2,3]\n 1 :: [] == [1]\n", "type": "a -> List a -> List a", "associativity": "right", "precedence": 5 } ] }, { "name": "Char", "comment": " Functions for working with characters. Character literals are enclosed in\n`'a'` pair of single quotes.\n\n# Classification\n@docs isUpper, isLower, isDigit, isOctDigit, isHexDigit\n\n# Conversion\n@docs toUpper, toLower, toLocaleUpper, toLocaleLower\n\n# Key Codes\n@docs KeyCode, toCode, fromCode\n\n", "unions": [], "aliases": [ { "name": "KeyCode", "comment": " Keyboard keys can be represented as integers. These are called *key codes*.\nYou can use [`toCode`](#toCode) and [`fromCode`](#fromCode) to convert between\nkey codes and characters.\n", "args": [], "type": "Int" } ], "values": [ { "name": "fromCode", "comment": " Convert from key code. ", "type": "KeyCode -> Char" }, { "name": "isDigit", "comment": " True for ASCII digits `[0-9]`. ", "type": "Char -> Bool" }, { "name": "isHexDigit", "comment": " True for ASCII hexadecimal digits `[0-9a-fA-F]`. ", "type": "Char -> Bool" }, { "name": "isLower", "comment": " True for lower case ASCII letters. ", "type": "Char -> Bool" }, { "name": "isOctDigit", "comment": " True for ASCII octal digits `[0-7]`. ", "type": "Char -> Bool" }, { "name": "isUpper", "comment": " True for upper case ASCII letters. ", "type": "Char -> Bool" }, { "name": "toCode", "comment": " Convert to key code.\n", "type": "Char -> KeyCode" }, { "name": "toLocaleLower", "comment": " Convert to lower case, according to any locale-specific case mappings. ", "type": "Char -> Char" }, { "name": "toLocaleUpper", "comment": " Convert to upper case, according to any locale-specific case mappings. ", "type": "Char -> Char" }, { "name": "toLower", "comment": " Convert to lower case. ", "type": "Char -> Char" }, { "name": "toUpper", "comment": " Convert to upper case. ", "type": "Char -> Char" } ], "binops": [] }, { "name": "Color", "comment": " Library for working with colors. Includes\n[RGB](https://en.wikipedia.org/wiki/RGB_color_model) and\n[HSL](http://en.wikipedia.org/wiki/HSL_and_HSV) creation, gradients, and\nbuilt-in names.\n\n# Colors\n@docs Color\n\n# Creation\n@docs rgb, rgba, hsl, hsla, greyscale, grayscale, complement\n\n# Gradients\n@docs Gradient, linear, radial\n\n# Extracting Colors\n@docs toRgb, toHsl\n\n# Built-in Colors\nThese colors come from the [Tango\npalette](http://tango.freedesktop.org/Tango_Icon_Theme_Guidelines)\nwhich provides aesthetically reasonable defaults for colors. Each color also\ncomes with a light and dark version.\n\n### Standard\n@docs red, orange, yellow, green, blue, purple, brown\n\n### Light\n@docs lightRed, lightOrange, lightYellow, lightGreen, lightBlue, lightPurple, lightBrown\n\n### Dark\n@docs darkRed, darkOrange, darkYellow, darkGreen, darkBlue, darkPurple, darkBrown\n\n### Eight Shades of Grey\nThese colors are a compatible series of shades of grey, fitting nicely\nwith the Tango palette.\n@docs white, lightGrey, grey, darkGrey, lightCharcoal, charcoal, darkCharcoal, black\n\nThese are identical to the *grey* versions. It seems the spelling is regional, but\nthat has never helped me remember which one I should be writing.\n@docs lightGray, gray, darkGray\n\n", "unions": [ { "name": "Color", "comment": " Representation of colors.\n", "args": [], "cases": [] }, { "name": "Gradient", "comment": " Abstract representation of a color gradient.\n", "args": [], "cases": [] } ], "aliases": [], "values": [ { "name": "black", "comment": "", "type": "Color" }, { "name": "blue", "comment": "", "type": "Color" }, { "name": "brown", "comment": "", "type": "Color" }, { "name": "charcoal", "comment": "", "type": "Color" }, { "name": "complement", "comment": " Produce a “complementary color”. The two colors will\naccent each other. This is the same as rotating the hue by 180°.\n", "type": "Color -> Color" }, { "name": "darkBlue", "comment": "", "type": "Color" }, { "name": "darkBrown", "comment": "", "type": "Color" }, { "name": "darkCharcoal", "comment": "", "type": "Color" }, { "name": "darkGray", "comment": "", "type": "Color" }, { "name": "darkGreen", "comment": "", "type": "Color" }, { "name": "darkGrey", "comment": "", "type": "Color" }, { "name": "darkOrange", "comment": "", "type": "Color" }, { "name": "darkPurple", "comment": "", "type": "Color" }, { "name": "darkRed", "comment": "", "type": "Color" }, { "name": "darkYellow", "comment": "", "type": "Color" }, { "name": "gray", "comment": "", "type": "Color" }, { "name": "grayscale", "comment": " Produce a gray based on the input. 0 is white, 1 is black.\n", "type": "Float -> Color" }, { "name": "green", "comment": "", "type": "Color" }, { "name": "grey", "comment": "", "type": "Color" }, { "name": "greyscale", "comment": " Produce a gray based on the input. 0 is white, 1 is black.\n", "type": "Float -> Color" }, { "name": "hsl", "comment": " Create [HSL colors](http://en.wikipedia.org/wiki/HSL_and_HSV). This gives\nyou access to colors more like a color wheel, where all hues are arranged in a\ncircle that you specify with standard Elm angles (radians).\n\n red = hsl (degrees 0) 1 0.5\n green = hsl (degrees 120) 1 0.5\n blue = hsl (degrees 240) 1 0.5\n\n pastelRed = hsl (degrees 0) 0.7 0.7\n\nTo cycle through all colors, just cycle through degrees. The saturation level\nis how vibrant the color is, like a dial between grey and bright colors. The\nlightness level is a dial between white and black.\n", "type": "Float -> Float -> Float -> Color" }, { "name": "hsla", "comment": " Create [HSL colors](http://en.wikipedia.org/wiki/HSL_and_HSV)\nwith an alpha component for transparency.\n", "type": "Float -> Float -> Float -> Float -> Color" }, { "name": "lightBlue", "comment": "", "type": "Color" }, { "name": "lightBrown", "comment": "", "type": "Color" }, { "name": "lightCharcoal", "comment": "", "type": "Color" }, { "name": "lightGray", "comment": "", "type": "Color" }, { "name": "lightGreen", "comment": "", "type": "Color" }, { "name": "lightGrey", "comment": "", "type": "Color" }, { "name": "lightOrange", "comment": "", "type": "Color" }, { "name": "lightPurple", "comment": "", "type": "Color" }, { "name": "lightRed", "comment": "", "type": "Color" }, { "name": "lightYellow", "comment": "", "type": "Color" }, { "name": "linear", "comment": " Create a linear gradient. Takes a start and end point and then a series of\n“color stops” that indicate how to interpolate between the start and\nend points. See [this example](http://elm-lang.org/examples/linear-gradient) for a\nmore visual explanation.\n", "type": "( Float, Float ) -> ( Float, Float ) -> List ( Float, Color ) -> Gradient" }, { "name": "orange", "comment": "", "type": "Color" }, { "name": "purple", "comment": "", "type": "Color" }, { "name": "radial", "comment": " Create a radial gradient. First takes a start point and inner radius. Then\ntakes an end point and outer radius. It then takes a series of “color\nstops” that indicate how to interpolate between the inner and outer\ncircles. See [this example](http://elm-lang.org/examples/radial-gradient) for a\nmore visual explanation.\n", "type": "( Float, Float ) -> Float -> ( Float, Float ) -> Float -> List ( Float, Color ) -> Gradient" }, { "name": "red", "comment": "", "type": "Color" }, { "name": "rgb", "comment": " Create RGB colors from numbers between 0 and 255 inclusive. ", "type": "Int -> Int -> Int -> Color" }, { "name": "rgba", "comment": " Create RGB colors with an alpha component for transparency.\nThe alpha component is specified with numbers between 0 and 1. ", "type": "Int -> Int -> Int -> Float -> Color" }, { "name": "toHsl", "comment": " Extract the components of a color in the HSL format.\n", "type": "Color -> { hue : Float, saturation : Float, lightness : Float, alpha : Float }" }, { "name": "toRgb", "comment": " Extract the components of a color in the RGB format.\n", "type": "Color -> { red : Int, green : Int, blue : Int, alpha : Float }" }, { "name": "white", "comment": "", "type": "Color" }, { "name": "yellow", "comment": "", "type": "Color" } ], "binops": [] }, { "name": "Tuple", "comment": " Some helpers for working with 2-tuples.\n\n**Note:** For larger chunks of data, it is best to switch to using records. So\ninstead of representing a 3D point as `(3,4,5)` and wondering why there are no\nhelper functions, represent it as `{ x = 3, y = 4, z = 5 }` and use all the\nbuilt-in syntax for records.\n\n@docs first, second, mapFirst, mapSecond\n\n", "unions": [], "aliases": [], "values": [ { "name": "first", "comment": " Extract the first value from a tuple.\n\n first (3, 4) == 3\n first (\"john\", \"doe\") == \"john\"\n", "type": "( a1, a2 ) -> a1" }, { "name": "mapFirst", "comment": " Transform the first value in a tuple.\n\n import String\n\n mapFirst String.reverse (\"stressed\", 16) == (\"desserts\", 16)\n mapFirst String.length (\"stressed\", 16) == (8, 16)\n", "type": "(a -> b) -> ( a, a2 ) -> ( b, a2 )" }, { "name": "mapSecond", "comment": " Transform the second value in a tuple.\n\n import String\n\n mapSecond sqrt (\"stressed\", 16) == (\"stressed\", 4)\n mapSecond (\\x -> x + 1) (\"stressed\", 16) == (\"stressed\", 17)\n", "type": "(a -> b) -> ( a1, a ) -> ( a1, b )" }, { "name": "second", "comment": " Extract the second value from a tuple.\n\n second (3, 4) == 4\n second (\"john\", \"doe\") == \"doe\"\n", "type": "( a1, a2 ) -> a2" } ], "binops": [] }, { "name": "Platform.Sub", "comment": "\n\n@docs Sub, map, batch, none\n", "unions": [ { "name": "Sub", "comment": " A subscription is a way of telling Elm, “Hey, let me know if anything\ninteresting happens over there!” So if you want to listen for messages on a web\nsocket, you would tell Elm to create a subscription. If you want to get clock\nticks, you would tell Elm to subscribe to that. The cool thing here is that\nthis means *Elm* manages all the details of subscriptions instead of *you*.\nSo if a web socket goes down, *you* do not need to manually reconnect with an\nexponential backoff strategy, *Elm* does this all for you behind the scenes!\n\nEvery `Sub` specifies (1) which effects you need access to and (2) the type of\nmessages that will come back into your application.\n\n**Note:** Do not worry if this seems confusing at first! As with every Elm user\never, subscriptions will make more sense as you work through [the Elm Architecture\nTutorial](http://guide.elm-lang.org/architecture/index.html) and see how they fit\ninto a real application!\n", "args": [ "msg" ], "cases": [] } ], "aliases": [], "values": [ { "name": "batch", "comment": "", "type": "List (Sub msg) -> Sub msg" }, { "name": "map", "comment": "", "type": "(a -> msg) -> Sub a -> Sub msg" }, { "name": "none", "comment": "", "type": "Sub msg" } ], "binops": [] }, { "name": "Platform.Cmd", "comment": "\n\n# Effects\n\nElm has **managed effects**, meaning that things like HTTP requests or writing\nto disk are all treated as *data* in Elm. When this data is given to the Elm\nruntime system, it can do some “query optimization” before actually performing\nthe effect. Perhaps unexpectedly, this managed effects idea is the heart of why\nElm is so nice for testing, reuse, reproducibility, etc.\n\nThere are two kinds of managed effects you will use in your programs: commands\nand subscriptions.\n\n@docs Cmd, map, batch, none, (!)\n\n", "unions": [ { "name": "Cmd", "comment": " A command is a way of telling Elm, “Hey, I want you to do this thing!”\nSo if you want to send an HTTP request, you would need to command Elm to do it.\nOr if you wanted to ask for geolocation, you would need to command Elm to go\nget it.\n\nEvery `Cmd` specifies (1) which effects you need access to and (2) the type of\nmessages that will come back into your application.\n\n**Note:** Do not worry if this seems confusing at first! As with every Elm user\never, commands will make more sense as you work through [the Elm Architecture\nTutorial](http://guide.elm-lang.org/architecture/index.html) and see how they\nfit into a real application!\n", "args": [ "msg" ], "cases": [] } ], "aliases": [], "values": [ { "name": "batch", "comment": "", "type": "List (Cmd msg) -> Cmd msg" }, { "name": "map", "comment": "", "type": "(a -> msg) -> Cmd a -> Cmd msg" }, { "name": "none", "comment": "", "type": "Cmd msg" } ], "binops": [ { "name": "!", "comment": "", "type": "model -> List (Cmd msg) -> ( model, Cmd msg )", "associativity": "left", "precedence": 9 } ] }, { "name": "Debug", "comment": " This library is for investigating bugs or performance problems. It should\n*not* be used in production code.\n\n# Debugging\n@docs log, crash\n", "unions": [], "aliases": [], "values": [ { "name": "crash", "comment": " Crash the program with an error message. This is an uncatchable error,\nintended for code that is soon-to-be-implemented. For example, if you are\nworking with a large ADT and have partially completed a case expression, it may\nmake sense to do this:\n\n type Entity = Ship | Fish | Captain | Seagull\n\n drawEntity entity =\n case entity of\n Ship ->\n ...\n\n Fish ->\n ...\n\n _ ->\n Debug.crash \"TODO\"\n\nThe Elm compiler recognizes each `Debug.crash` and when you run into it at\nruntime, the error will point to the corresponding module name and line number.\nFor `case` expressions that ends with a wildcard pattern and a crash, it will\nalso show the value that snuck through. In our example, that'd be `Captain` or\n`Seagull`.\n\n**Use this if** you want to do some testing while you are partway through\nwriting a function.\n\n**Do not use this if** you want to do some typical try-catch exception handling.\nUse the [`Maybe`](Maybe) or [`Result`](Result) libraries instead.\n", "type": "String -> a" }, { "name": "log", "comment": " Log a tagged value on the developer console, and then return the value.\n\n 1 + log \"number\" 1 -- equals 2, logs \"number: 1\"\n length (log \"start\" []) -- equals 0, logs \"start: []\"\n\nNotice that `log` is not a pure function! It should *only* be used for\ninvestigating bugs or performance problems.\n", "type": "String -> a -> a" } ], "binops": [] }, { "name": "Maybe", "comment": " This library fills a bunch of important niches in Elm. A `Maybe` can help\nyou with optional arguments, error handling, and records with optional fields.\n\n# Definition\n@docs Maybe\n\n# Common Helpers\n@docs withDefault, map, map2, map3, map4, map5\n\n# Chaining Maybes\n@docs andThen\n", "unions": [ { "name": "Maybe", "comment": " Represent values that may or may not exist. It can be useful if you have a\nrecord field that is only filled in sometimes. Or if a function takes a value\nsometimes, but does not absolutely need it.\n\n -- A person, but maybe we do not know their age.\n type alias Person =\n { name : String\n , age : Maybe Int\n }\n\n tom = { name = \"Tom\", age = Just 42 }\n sue = { name = \"Sue\", age = Nothing }\n", "args": [ "a" ], "cases": [ [ "Just", [ "a" ] ], [ "Nothing", [] ] ] } ], "aliases": [], "values": [ { "name": "andThen", "comment": " Chain together many computations that may fail. It is helpful to see its\ndefinition:\n\n andThen : (a -> Maybe b) -> Maybe a -> Maybe b\n andThen callback maybe =\n case maybe of\n Just value ->\n callback value\n\n Nothing ->\n Nothing\n\nThis means we only continue with the callback if things are going well. For\nexample, say you need to use (`head : List Int -> Maybe Int`) to get the\nfirst month from a `List` and then make sure it is between 1 and 12:\n\n toValidMonth : Int -> Maybe Int\n toValidMonth month =\n if month >= 1 && month <= 12 then\n Just month\n else\n Nothing\n\n getFirstMonth : List Int -> Maybe Int\n getFirstMonth months =\n head months\n |> andThen toValidMonth\n\nIf `head` fails and results in `Nothing` (because the `List` was `empty`),\nthis entire chain of operations will short-circuit and result in `Nothing`.\nIf `toValidMonth` results in `Nothing`, again the chain of computations\nwill result in `Nothing`.\n", "type": "(a -> Maybe b) -> Maybe a -> Maybe b" }, { "name": "map", "comment": " Transform a `Maybe` value with a given function:\n\n map sqrt (Just 9) == Just 3\n map sqrt Nothing == Nothing\n", "type": "(a -> b) -> Maybe a -> Maybe b" }, { "name": "map2", "comment": " Apply a function if all the arguments are `Just` a value.\n\n map2 (+) (Just 3) (Just 4) == Just 7\n map2 (+) (Just 3) Nothing == Nothing\n map2 (+) Nothing (Just 4) == Nothing\n", "type": "(a -> b -> value) -> Maybe a -> Maybe b -> Maybe value" }, { "name": "map3", "comment": "", "type": "(a -> b -> c -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe value" }, { "name": "map4", "comment": "", "type": "(a -> b -> c -> d -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe value" }, { "name": "map5", "comment": "", "type": "(a -> b -> c -> d -> e -> value) -> Maybe a -> Maybe b -> Maybe c -> Maybe d -> Maybe e -> Maybe value" }, { "name": "withDefault", "comment": " Provide a default value, turning an optional value into a normal\nvalue. This comes in handy when paired with functions like\n[`Dict.get`](Dict#get) which gives back a `Maybe`.\n\n withDefault 100 (Just 42) -- 42\n withDefault 100 Nothing -- 100\n\n withDefault \"unknown\" (Dict.get \"Tom\" Dict.empty) -- \"unknown\"\n\n", "type": "a -> Maybe a -> a" } ], "binops": [] }, { "name": "Basics", "comment": " Tons of useful functions that get imported by default.\n\n# Equality\n@docs (==), (/=)\n\n# Comparison\n\nThese functions only work on `comparable` types. This includes numbers,\ncharacters, strings, lists of comparable things, and tuples of comparable\nthings. Note that tuples with 7 or more elements are not comparable; why\nare your tuples so big?\n\n@docs (<), (>), (<=), (>=), max, min, Order, compare\n\n# Booleans\n@docs not, (&&), (||), xor\n\n# Mathematics\n@docs (+), (-), (*), (/), (^), (//), rem, (%), negate, abs, sqrt, clamp, logBase, e\n\n# Trigonometry\n@docs pi, cos, sin, tan, acos, asin, atan, atan2\n\n# Number Conversions\n@docs round, floor, ceiling, truncate, toFloat\n\n# Angle Conversions\nAll angle conversions result in “standard Elm angles”\nwhich happen to be radians.\n\n@docs degrees, radians, turns\n\n# Polar Coordinates\n@docs toPolar, fromPolar\n\n# Floating Point Checks\n@docs isNaN, isInfinite\n\n# Strings and Lists\n@docs toString, (++)\n\n# Higher-Order Helpers\n@docs identity, always, (<|), (|>), (<<), (>>), flip, curry, uncurry, Never, never\n\n", "unions": [ { "name": "Never", "comment": " A value that can never happen! For context:\n\n - The boolean type `Bool` has two values: `True` and `False`\n - The unit type `()` has one value: `()`\n - The never type `Never` has no values!\n\nYou may see it in the wild in `Html Never` which means this HTML will never\nproduce any messages. You would need to write an event handler like\n`onClick ??? : Attribute Never` but how can we fill in the question marks?!\nSo there cannot be any event handlers on that HTML.\n\nYou may also see this used with tasks that never fail, like `Task Never ()`.\n\nThe `Never` type is useful for restricting *arguments* to a function. Maybe my\nAPI can only accept HTML without event handlers, so I require `Html Never` and\nusers can give `Html msg` and everything will go fine. Generally speaking, you\ndo not want `Never` in your return types though.\n", "args": [], "cases": [] }, { "name": "Order", "comment": " Represents the relative ordering of two things.\nThe relations are less than, equal to, and greater than.\n", "args": [], "cases": [ [ "LT", [] ], [ "EQ", [] ], [ "GT", [] ] ] } ], "aliases": [], "values": [ { "name": "abs", "comment": " Take the absolute value of a number. ", "type": "number -> number" }, { "name": "acos", "comment": "", "type": "Float -> Float" }, { "name": "always", "comment": " Create a function that *always* returns the same value. Useful with\nfunctions like `map`:\n\n List.map (always 0) [1,2,3,4,5] == [0,0,0,0,0]\n\n -- List.map (\\_ -> 0) [1,2,3,4,5] == [0,0,0,0,0]\n -- always = (\\x _ -> x)\n", "type": "a -> b -> a" }, { "name": "asin", "comment": "", "type": "Float -> Float" }, { "name": "atan", "comment": " You probably do not want to use this. It takes `(y/x)` as the\nargument, so there is no way to know whether the negative signs comes from\nthe `y` or `x`. Thus, the resulting angle is always between π/2 and -π/2\n(in quadrants I and IV). You probably want to use `atan2` instead.\n", "type": "Float -> Float" }, { "name": "atan2", "comment": " This helps you find the angle of a Cartesian coordinate.\nYou will almost certainly want to use this instead of `atan`.\nSo `atan2 y x` computes *atan(y/x)* but also keeps track of which\nquadrant the angle should really be in. The result will be between\nπ and -π, giving you the full range of angles.\n", "type": "Float -> Float -> Float" }, { "name": "ceiling", "comment": " Ceiling function, rounding up. ", "type": "Float -> Int" }, { "name": "clamp", "comment": " Clamps a number within a given range. With the expression\n`clamp 100 200 x` the results are as follows:\n\n 100 if x < 100\n x if 100 <= x < 200\n 200 if 200 <= x\n", "type": "number -> number -> number -> number" }, { "name": "compare", "comment": " Compare any two comparable values. Comparable values include `String`, `Char`,\n`Int`, `Float`, `Time`, or a list or tuple containing comparable values.\nThese are also the only values that work as `Dict` keys or `Set` members.\n", "type": "comparable -> comparable -> Order" }, { "name": "cos", "comment": "", "type": "Float -> Float" }, { "name": "curry", "comment": " Change how arguments are passed to a function.\nThis splits paired arguments into two separate arguments.\n", "type": "(( a, b ) -> c) -> a -> b -> c" }, { "name": "degrees", "comment": " Convert degrees to standard Elm angles (radians). ", "type": "Float -> Float" }, { "name": "e", "comment": " An approximation of e. ", "type": "Float" }, { "name": "flip", "comment": " Flip the order of the first two arguments to a function. ", "type": "(a -> b -> c) -> b -> a -> c" }, { "name": "floor", "comment": " Floor function, rounding down. ", "type": "Float -> Int" }, { "name": "fromPolar", "comment": " Convert polar coordinates (r,θ) to Cartesian coordinates (x,y). ", "type": "( Float, Float ) -> ( Float, Float )" }, { "name": "identity", "comment": " Given a value, returns exactly the same value. This is called\n[the identity function](http://en.wikipedia.org/wiki/Identity_function).\n", "type": "a -> a" }, { "name": "isInfinite", "comment": " Determine whether a float is positive or negative infinity.\n\n isInfinite (0/0) == False\n isInfinite (sqrt -1) == False\n isInfinite (1/0) == True\n isInfinite 1 == False\n\nNotice that NaN is not infinite! For float `n` to be finite implies that\n`not (isInfinite n || isNaN n)` evaluates to `True`.\n", "type": "Float -> Bool" }, { "name": "isNaN", "comment": " Determine whether a float is an undefined or unrepresentable number.\nNaN stands for *not a number* and it is [a standardized part of floating point\nnumbers](http://en.wikipedia.org/wiki/NaN).\n\n isNaN (0/0) == True\n isNaN (sqrt -1) == True\n isNaN (1/0) == False -- infinity is a number\n isNaN 1 == False\n", "type": "Float -> Bool" }, { "name": "logBase", "comment": " Calculate the logarithm of a number with a given base.\n\n logBase 10 100 == 2\n logBase 2 256 == 8\n", "type": "Float -> Float -> Float" }, { "name": "max", "comment": " Find the larger of two comparables. ", "type": "comparable -> comparable -> comparable" }, { "name": "min", "comment": " Find the smaller of two comparables. ", "type": "comparable -> comparable -> comparable" }, { "name": "negate", "comment": " Negate a number.\n\n negate 42 == -42\n negate -42 == 42\n negate 0 == 0\n", "type": "number -> number" }, { "name": "never", "comment": " A function that can never be called. Seems extremely pointless, but it\n*can* come in handy. Imagine you have some HTML that should never produce any\nmessages. And say you want to use it in some other HTML that *does* produce\nmessages. You could say:\n\n import Html exposing (..)\n\n embedHtml : Html Never -> Html msg\n embedHtml staticStuff =\n div []\n [ text \"hello\"\n , Html.map never staticStuff\n ]\n\nSo the `never` function is basically telling the type system, make sure no one\never calls me!\n", "type": "Never -> a" }, { "name": "not", "comment": " Negate a boolean value.\n\n not True == False\n not False == True\n", "type": "Bool -> Bool" }, { "name": "pi", "comment": " An approximation of pi. ", "type": "Float" }, { "name": "radians", "comment": " Convert radians to standard Elm angles (radians). ", "type": "Float -> Float" }, { "name": "rem", "comment": " Find the remainder after dividing one number by another.\n\n rem 11 4 == 3\n rem 12 4 == 0\n rem 13 4 == 1\n rem -1 4 == -1\n", "type": "Int -> Int -> Int" }, { "name": "round", "comment": " Round a number to the nearest integer. ", "type": "Float -> Int" }, { "name": "sin", "comment": "", "type": "Float -> Float" }, { "name": "sqrt", "comment": " Take the square root of a number. ", "type": "Float -> Float" }, { "name": "tan", "comment": "", "type": "Float -> Float" }, { "name": "toFloat", "comment": " Convert an integer into a float. ", "type": "Int -> Float" }, { "name": "toPolar", "comment": " Convert Cartesian coordinates (x,y) to polar coordinates (r,θ). ", "type": "( Float, Float ) -> ( Float, Float )" }, { "name": "toString", "comment": " Turn any kind of value into a string. When you view the resulting string\nwith `Text.fromString` it should look just like the value it came from.\n\n toString 42 == \"42\"\n toString [1,2] == \"[1,2]\"\n toString \"he said, \\\"hi\\\"\" == \"\\\"he said, \\\\\\\"hi\\\\\\\"\\\"\"\n", "type": "a -> String" }, { "name": "truncate", "comment": " Truncate a number, rounding towards zero. ", "type": "Float -> Int" }, { "name": "turns", "comment": " Convert turns to standard Elm angles (radians).\nOne turn is equal to 360°.\n", "type": "Float -> Float" }, { "name": "uncurry", "comment": " Change how arguments are passed to a function.\nThis combines two arguments into a single pair.\n", "type": "(a -> b -> c) -> ( a, b ) -> c" }, { "name": "xor", "comment": " The exclusive-or operator. `True` if exactly one input is `True`. ", "type": "Bool -> Bool -> Bool" } ], "binops": [ { "name": "%", "comment": " Perform [modular arithmetic](http://en.wikipedia.org/wiki/Modular_arithmetic).\n\n 7 % 2 == 1\n -1 % 4 == 3\n", "type": "Int -> Int -> Int", "associativity": "left", "precedence": 7 }, { "name": "&&", "comment": " The logical AND operator. `True` if both inputs are `True`.\n\n**Note:** When used in the infix position, like `(left && right)`, the operator\nshort-circuits. This means if `left` is `False` we do not bother evaluating `right`\nand just return `False` overall.\n", "type": "Bool -> Bool -> Bool", "associativity": "right", "precedence": 3 }, { "name": "*", "comment": "", "type": "number -> number -> number", "associativity": "left", "precedence": 7 }, { "name": "+", "comment": "", "type": "number -> number -> number", "associativity": "left", "precedence": 6 }, { "name": "++", "comment": " Put two appendable things together. This includes strings, lists, and text.\n\n \"hello\" ++ \"world\" == \"helloworld\"\n [1,1,2] ++ [3,5,8] == [1,1,2,3,5,8]\n", "type": "appendable -> appendable -> appendable", "associativity": "right", "precedence": 5 }, { "name": "-", "comment": "", "type": "number -> number -> number", "associativity": "left", "precedence": 6 }, { "name": "/", "comment": " Floating point division. ", "type": "Float -> Float -> Float", "associativity": "left", "precedence": 7 }, { "name": "//", "comment": " Integer division. The remainder is discarded. ", "type": "Int -> Int -> Int", "associativity": "left", "precedence": 7 }, { "name": "/=", "comment": " Check if values are not “the same”.\n\nSo `(a /= b)` is the same as `(not (a == b))`.\n", "type": "a -> a -> Bool", "associativity": "non", "precedence": 4 }, { "name": "<", "comment": "", "type": "comparable -> comparable -> Bool", "associativity": "non", "precedence": 4 }, { "name": "<<", "comment": " Function composition, passing results along in the suggested direction. For\nexample, the following code checks if the square root of a number is odd:\n\n not << isEven << sqrt\n\nYou can think of this operator as equivalent to the following:\n\n (g << f) == (\\x -> g (f x))\n\nSo our example expands out to something like this:\n\n \\n -> not (isEven (sqrt n))\n", "type": "(b -> c) -> (a -> b) -> a -> c", "associativity": "right", "precedence": 9 }, { "name": "<=", "comment": "", "type": "comparable -> comparable -> Bool", "associativity": "non", "precedence": 4 }, { "name": "<|", "comment": " Backward function application `f <| x == f x`. This function is useful for\navoiding parentheses. Consider the following code to create a text element:\n\n leftAligned (monospace (fromString \"code\"))\n\nThis can also be written as:\n\n leftAligned <| monospace <| fromString \"code\"\n", "type": "(a -> b) -> a -> b", "associativity": "right", "precedence": 0 }, { "name": "==", "comment": " Check if values are “the same”.\n\n**Note:** Elm uses structural equality on tuples, records, and user-defined\nunion types. This means the values `(3, 4)` and `(3, 4)` are definitely equal.\nThis is not true in languages like JavaScript that use reference equality on\nobjects.\n\n**Note:** Equality (in the Elm sense) is not possible for certain types. For\nexample, the functions `(\\n -> n + 1)` and `(\\n -> 1 + n)` are “the\nsame” but detecting this in general is [undecidable][]. In a future\nrelease, the compiler will detect when `(==)` is used with problematic\ntypes and provide a helpful error message. This will require quite serious\ninfrastructure work that makes sense to batch with another big project, so the\nstopgap is to crash as quickly as possible. Problematic types include functions\nand JavaScript values like `Json.Encode.Value` which could contain functions\nif passed through a port.\n\n[undecidable]: https://en.wikipedia.org/wiki/Undecidable_problem\n", "type": "a -> a -> Bool", "associativity": "non", "precedence": 4 }, { "name": ">", "comment": "", "type": "comparable -> comparable -> Bool", "associativity": "non", "precedence": 4 }, { "name": ">=", "comment": "", "type": "comparable -> comparable -> Bool", "associativity": "non", "precedence": 4 }, { "name": ">>", "comment": " Function composition, passing results along in the suggested direction. For\nexample, the following code checks if the square root of a number is odd:\n\n sqrt >> isEven >> not\n\nThis direction of function composition seems less pleasant than `(<<)` which\nreads nicely in expressions like: `filter (not << isRegistered) students`\n", "type": "(a -> b) -> (b -> c) -> a -> c", "associativity": "left", "precedence": 9 }, { "name": "^", "comment": " Exponentiation\n\n 3^2 == 9\n", "type": "number -> number -> number", "associativity": "right", "precedence": 8 }, { "name": "|>", "comment": " Forward function application `x |> f == f x`. This function is useful\nfor avoiding parentheses and writing code in a more natural way.\nConsider the following code to create a pentagon:\n\n scale 2 (move (10,10) (filled blue (ngon 5 30)))\n\nThis can also be written as:\n\n ngon 5 30\n |> filled blue\n |> move (10,10)\n |> scale 2\n", "type": "a -> (a -> b) -> b", "associativity": "left", "precedence": 0 }, { "name": "||", "comment": " The logical OR operator. `True` if one or both inputs are `True`.\n\n**Note:** When used in the infix position, like `(left || right)`, the operator\nshort-circuits. This means if `left` is `True` we do not bother evaluating `right`\nand just return `True` overall.\n", "type": "Bool -> Bool -> Bool", "associativity": "right", "precedence": 2 } ] }, { "name": "Bitwise", "comment": " Library for [bitwise operations](http://en.wikipedia.org/wiki/Bitwise_operation).\n\n# Basic Operations\n@docs and, or, xor, complement\n\n# Bit Shifts\n@docs shiftLeftBy, shiftRightBy, shiftRightZfBy\n", "unions": [], "aliases": [], "values": [ { "name": "and", "comment": " Bitwise AND\n", "type": "Int -> Int -> Int" }, { "name": "complement", "comment": " Flip each bit individually, often called bitwise NOT\n", "type": "Int -> Int" }, { "name": "or", "comment": " Bitwise OR\n", "type": "Int -> Int -> Int" }, { "name": "shiftLeftBy", "comment": " Shift bits to the left by a given offset, filling new bits with zeros.\nThis can be used to multiply numbers by powers of two.\n\n shiftLeftBy 1 5 == 10\n shiftLeftBy 5 1 == 32\n", "type": "Int -> Int -> Int" }, { "name": "shiftRightBy", "comment": " Shift bits to the right by a given offset, filling new bits with\nwhatever is the topmost bit. This can be used to divide numbers by powers of two.\n\n shiftRightBy 1 32 == 16\n shiftRightBy 2 32 == 8\n shiftRightBy 1 -32 == -16\n\nThis is called an [arithmetic right shift][ars], often written (>>), and\nsometimes called a sign-propagating right shift because it fills empty spots\nwith copies of the highest bit.\n\n[ars]: http://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift\n", "type": "Int -> Int -> Int" }, { "name": "shiftRightZfBy", "comment": " Shift bits to the right by a given offset, filling new bits with zeros.\n\n shiftRightZfBy 1 32 == 16\n shiftRightZfBy 2 32 == 8\n shiftRightZfBy 1 -32 == 2147483632\n\nThis is called an [logical right shift][lrs], often written (>>>), and\nsometimes called a zero-fill right shift because it fills empty spots with\nzeros.\n\n[lrs]: http://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift\n", "type": "Int -> Int -> Int" }, { "name": "xor", "comment": " Bitwise XOR\n", "type": "Int -> Int -> Int" } ], "binops": [] } ]