[ { "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\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 `Thu` 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": " Take a UNIX time and convert it to a `Date`.\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": "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 into a time since midnight (UTC) of 1 January 1970 (i.e.\n[UNIX time](http://en.wikipedia.org/wiki/Unix_time)). Given the date 23 June\n1990 at 11:45AM this returns the corresponding 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": "Touch", "comment": " This is an early version of the touch library. It will likely grow to\ninclude gestures that would be useful for both games and web-pages.\n\n# Touches\n@docs Touch, touches\n\n# Gestures\n@docs taps\n", "unions": [], "aliases": [ { "name": "Touch", "comment": " Every `Touch` has `xy` coordinates. It also has an identifier\n`id` to distinguish one touch from another.\n\nA touch also keeps info about the initial point and time of contact:\n`x0`, `y0`, and `t0`. This helps compute more complicated gestures\nlike taps, drags, and swipes which need to know about timing or direction.\n", "args": [], "type": "{ x : Int, y : Int, id : Int, x0 : Int, y0 : Int, t0 : Time }" } ], "values": [ { "name": "taps", "comment": " The last position that was tapped. Default value is `{x=0,y=0}`.\nUpdates whenever the user taps the screen.\n", "type": "Signal { x : Int, y : Int }" }, { "name": "touches", "comment": " A list of ongoing touches. ", "type": "Signal (List Touch)" } ], "binops": [] }, { "name": "Graphics.Input", "comment": " This module is for creating input widgets such as buttons and text fields.\nAll functions in this library report to a [`Signal.Mailbox`](Signal#message).\n\n# Basic Input Elements\n\nTo learn about text fields, see the\n[`Graphics.Input.Field`](Graphics-Input-Field) library.\n\n@docs button, customButton, checkbox, dropDown\n\n# Clicks and Hovers\n@docs clickable, hoverable\n\n", "unions": [], "aliases": [], "values": [ { "name": "button", "comment": " Create a standard button. The following example begins making a basic\ncalculator:\n\n type Keys = Number Int | Plus | Minus | Clear\n\n keys : Signal.Mailbox Keys\n keys = Signal.mailbox Clear\n\n calculator : Element\n calculator =\n flow right\n [ button (Signal.message keys.address (Number 1)) \"1\"\n , button (Signal.message keys.address (Number 2)) \"2\"\n , button (Signal.message keys.address Plus ) \"+\"\n ]\n\nIf the user presses the \"+\" button, `keys.signal` will update to `Plus`. If the\nusers presses \"2\", `keys.signal` will update to `(Number 2)`.\n", "type": "Message -> String -> Element" }, { "name": "checkbox", "comment": " Create a checkbox. The following example creates three synced checkboxes:\n\n check : Signal.Mailbox Bool\n check = Signal.mailbox False\n\n boxes : Bool -> Element\n boxes checked =\n let box = container 40 40 middle (checkbox (Signal.message check.address) checked)\n in\n flow right [ box, box, box ]\n\n main : Signal Element\n main = Signal.map boxes check.signal\n", "type": "(Bool -> Message) -> Bool -> Element" }, { "name": "clickable", "comment": " Detect mouse clicks on a specific `Element`. In the following example,\nwe will create a clickable picture called `cat`.\n\n type Picture = Cat | Hat\n\n picture : Signal.Mailbox Picture\n picture = Signal.mailbox Cat\n\n cat : Element\n cat =\n image 30 30 \"/cat.jpg\"\n |> clickable (Signal.message picture.address Cat)\n\n hat : Element\n hat =\n image 30 30 \"/hat.jpg\"\n |> clickable (Signal.message picture.address Hat)\n\nWhen the user clicks on the `cat` element, `picture.signal` receives\nan update containing the value `Cat`. When the user clicks on the `hat` element,\n`picture.signal` receives an update containing the value `Hat`. This lets you\ndistinguish which element was clicked. In a more complex example, they could be\ndistinguished with IDs or more complex data structures.\n", "type": "Message -> Element -> Element" }, { "name": "customButton", "comment": " Same as `button` but lets you customize buttons to look however you want.\n\n click : Signal.Mailbox ()\n click = Signal.mailbox ()\n\n prettyButton : Element\n prettyButton =\n customButton (Signal.message click.address ())\n (image 100 40 \"/button_up.jpg\")\n (image 100 40 \"/button_hover.jpg\")\n (image 100 40 \"/button_down.jpg\")\n", "type": "Message -> Element -> Element -> Element -> Element" }, { "name": "dropDown", "comment": " Create a drop-down menu. The following drop-down lets you choose your\nfavorite British sport:\n\n type Sport = Football | Cricket | Snooker\n\n sport : Signal.Mailbox (Maybe Sport)\n sport = Signal.mailbox Nothing\n\n sportDropDown : Element\n sportDropDown =\n dropDown (Signal.message sport.address)\n [ (\"\" , Nothing)\n , (\"Football\", Just Football)\n , (\"Cricket\" , Just Cricket)\n , (\"Snooker\" , Just Snooker)\n ]\n\nIf the user selects \"Football\" from the drop down menu, `sport.signal`\nwill update to `Just Football`.\n", "type": "(a -> Message) -> List ( String, a ) -> Element" }, { "name": "hoverable", "comment": " Detect mouse hovers over a specific `Element`. In the following example,\nwe will create a hoverable picture called `cat`.\n\n hover : Signal.Mailbox Bool\n hover = Signal.mailbox False\n\n cat : Element\n cat =\n image 30 30 \"/cat.jpg\"\n |> hoverable (Signal.message hover.address)\n\nWhen the mouse hovers above the `cat` element, `hover.signal` will become\n`True`. When the mouse leaves it, `hover.signal` will become `False`.\n", "type": "(Bool -> Message) -> Element -> Element" } ], "binops": [] }, { "name": "Graphics.Input.Field", "comment": " This library provides an API for creating and updating text fields.\nText fields use exactly the same approach as [`Graphics.Input`](Graphics-Input)\nfor modelling user input, allowing you to keep track of new events and update\ntext fields programmatically.\n\n# Create Fields\n@docs field, password, email\n\n# Field Content\n@docs Content, Selection, Direction, noContent\n\n# Field Style\n@docs defaultStyle, Style, Outline, noOutline, Highlight, noHighlight, Dimensions, uniformly\n", "unions": [ { "name": "Direction", "comment": " The direction of selection. When the user highlights a selection in a text\nfield, they must do it in a particular direction. This determines which end of\nthe selection moves when they change the selection by pressing Shift-Left or\nShift-Right.\n", "args": [], "cases": [ [ "Forward", [] ], [ "Backward", [] ] ] } ], "aliases": [ { "name": "Content", "comment": " Represents the current content of a text field. For example:\n\n content = Content \"She sells sea shells\" (Selection 0 3 Backward)\n\nThis means the user highlighted the substring `\"She\"` backwards. The value of\n`content.string` is `\"She sells sea shells\"`.\n", "args": [], "type": "{ string : String, selection : Selection }" }, { "name": "Dimensions", "comment": " For setting dimensions of a field's padding or outline. The left, right,\ntop, and bottom may all have different sizes. The following example creates\ndimensions such that the left and right are twice as wide as the top and bottom:\n\n myDimensions : Int -> Dimensions\n myDimensions n =\n { left = 2 * n\n , right = 2 * n\n , top = n\n , bottom = n\n }\n", "args": [], "type": "{ left : Int, right : Int, top : Int, bottom : Int }" }, { "name": "Highlight", "comment": " When a field has focus, it has a blue highlight around it by default. The\n`Highlight` lets you set the `color` and `width` of this highlight. Set the\n`width` to zero to turn the highlight off. Here is an example highlight that\nis blue and thin:\n\n { color = blue, width = 1 }\n", "args": [], "type": "{ color : Color, width : Int }" }, { "name": "Outline", "comment": " A field can have a outline around it. This lets you set its color, width,\nand radius. The radius allows you to round the corners of your field. Set the\nwidth to zero to make it invisible. Here is an example outline that is grey\nand thin with slightly rounded corners:\n\n { color = grey, width = uniformly 1, radius = 4 }\n", "args": [], "type": "{ color : Color, width : Dimensions, radius : Int }" }, { "name": "Selection", "comment": " The selection within a text field. `start` is never greater than `end`:\n\n Selection 0 0 Forward -- cursor precedes all characters\n\n Selection 5 9 Backward -- highlighting characters starting after\n -- the 5th and ending after the 9th\n", "args": [], "type": "{ start : Int, end : Int, direction : Direction }" }, { "name": "Style", "comment": " Describe the style of a text box. `style` describes the style of the text\nitself using [`Text.Style`](Text#Style). `highlight` describes the glowing blue\nhighlight that shows up when the field has focus. `outline` describes the line\nsurrounding the text field, and `padding` adds whitespace between the `outline`\nand the text.\n\nThe width and height of the text box *includes* the `padding` and `outline`.\nSay we have a text box that is 40 pixels tall. It has a uniform outline of\n1 pixel and a uniform padding of 5 pixels. Both of these must be subtracted\nfrom the total height to determine how much room there is for text. The\n`padding` and `outline` appear on the top and bottom, so there will be 28\nvertical pixels remaining for the text (40 - 1 - 5 - 5 - 1).\n", "args": [], "type": "{ padding : Dimensions, outline : Outline, highlight : Highlight, style : Style }" } ], "values": [ { "name": "defaultStyle", "comment": " The default style for a text field. The outline is `Color.grey` with width\n1 and radius 2. The highlight is `Color.blue` with width 1, and the default\ntext color is black.\n", "type": "Style" }, { "name": "email", "comment": " Same as `field` but it adds an annotation that this field is for email\naddresses. This is helpful for auto-complete and for mobile users who may\nget a custom keyboard with an `@` and `.com` button.\n", "type": "Style -> (Content -> Message) -> String -> Content -> Element" }, { "name": "field", "comment": " Create a text field. The following example creates a time-varying element\ncalled `nameField`. As the user types their name, the field will be updated\nto match what they have entered.\n\n name : Signal.Mailbox Content\n name = Signal.mailbox noContent\n\n nameField : Signal Element\n nameField =\n Signal.map (field defaultStyle (Signal.message name.address) \"Name\") name.signal\n\nWhen we use the `field` function, we first give it a visual style. This is\nthe first argument so that it is easier to define your own custom field\n(`myField = field myStyle`). The next two arguments are a `Handle` and a\nhandler function that processes or augments events before sending them along\nto the associated `Input`. In the example above we use the `identity` function to\npass events along unchanged to the `name` `Input`. We then provide the\nplace-holder message to use when no input has been provided yet. Finally,\nwe give the current `Content` of the field. This argument is last because\nit is most likely to change frequently, making function composition easier.\n", "type": "Style -> (Content -> Message) -> String -> Content -> Element" }, { "name": "noContent", "comment": " A field with no content:\n\n Content \"\" (Selection 0 0 Forward)\n", "type": "Content" }, { "name": "noHighlight", "comment": " A highlight with zero width, so you cannot see it. ", "type": "Highlight" }, { "name": "noOutline", "comment": " An outline with zero width, so you cannot see it. ", "type": "Outline" }, { "name": "password", "comment": " Same as `field` but the UI element blocks out each characters. ", "type": "Style -> (Content -> Message) -> String -> Content -> Element" }, { "name": "uniformly", "comment": " Create uniform dimensions:\n\n uniformly 4 == { left=4, right=4, top=4, bottom=4 }\n\nThe following example creates an outline where the left, right, top, and bottom\nedges all have width 1:\n\n Outline grey (uniformly 1) 4\n", "type": "Int -> Dimensions" } ], "binops": [] }, { "name": "Window", "comment": " Provides information about the container that your Elm program lives in.\nWhen you embed Elm in a `
` it gives the dimensions of the container, not\nthe whole window.\n\n# Dimensions\n@docs dimensions, width, height\n\n", "unions": [], "aliases": [], "values": [ { "name": "dimensions", "comment": " The current width and height of the window (i.e. the area viewable to the\nuser, not including scroll bars). ", "type": "Signal ( Int, Int )" }, { "name": "height", "comment": " The current height of the window. ", "type": "Signal Int" }, { "name": "width", "comment": " The current width of the window. ", "type": "Signal Int" } ], "binops": [] }, { "name": "Time", "comment": " Library for working with time.\n\n# Units\n@docs Time, millisecond, second, minute, hour,\n inMilliseconds, inSeconds, inMinutes, inHours\n\n# Tickers\n@docs fps, fpsWhen, every\n\n# Timing\n@docs timestamp, delay, since\n", "unions": [], "aliases": [ { "name": "Time", "comment": " Type alias to make it clearer when you are working with time values.\nUsing the `Time` constants instead of raw numbers is very highly recommended.\n", "args": [], "type": "Float" } ], "values": [ { "name": "delay", "comment": " Delay a signal by a certain amount of time. So `(delay second Mouse.clicks)`\nwill update one second later than any mouse click.\n\nNote: Even calling `delay` with the same number on the same signal twice\ngives two independently firing signals.\n", "type": "Time -> Signal a -> Signal a" }, { "name": "every", "comment": " Takes a time interval `t`. The resulting signal is the current time, updated\nevery `t`.\n\nNote: Calling `every 100` twice gives two independently running timers.\n", "type": "Time -> Signal Time" }, { "name": "fps", "comment": " Takes desired number of frames per second (FPS). The resulting signal\ngives a sequence of time deltas as quickly as possible until it reaches\nthe desired FPS. A time delta is the time between the last frame and the\ncurrent frame.\n\nNote: Calling `fps 30` twice gives two independently running timers.\n", "type": "number -> Signal Time" }, { "name": "fpsWhen", "comment": " Same as the `fps` function, but you can turn it on and off. Allows you\nto do brief animations based on user input without major inefficiencies.\nThe first time delta after a pause is always zero, no matter how long\nthe pause was. This way summing the deltas will actually give the amount\nof time that the output signal has been running.\n", "type": "number -> Signal Bool -> Signal Time" }, { "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": "second", "comment": "", "type": "Time" }, { "name": "since", "comment": " Takes a time `t` and any signal. The resulting boolean signal is true for\ntime `t` after every event on the input signal. So ``(second `since`\nMouse.clicks)`` would result in a signal that is true for one second after\neach mouse click and false otherwise.\n", "type": "Time -> Signal a -> Signal Bool" }, { "name": "timestamp", "comment": " Add a timestamp to any signal. Timestamps increase monotonically. When you\ncreate `(timestamp Mouse.x)`, an initial timestamp is produced. The timestamp\nupdates whenever `Mouse.x` updates.\n\nTimestamp updates are tied to individual events, so `(timestamp Mouse.x)` and\n`(timestamp Mouse.y)` will always have the same timestamp because they rely on\nthe same underlying event (`Mouse.position`).\n", "type": "Signal a -> Signal ( Time, a )" } ], "binops": [] }, { "name": "Keyboard", "comment": " Library for working with keyboard input.\n\n# Directions\n@docs arrows, wasd\n\n# Specific Keys\nThe following signals are `True` when the particular key is pressed and `False`\notherwise.\n\n@docs enter, space, ctrl, shift, alt, meta\n\n# General Keypresses\n@docs isDown, keysDown, presses\n\n", "unions": [], "aliases": [], "values": [ { "name": "alt", "comment": "", "type": "Signal Bool" }, { "name": "arrows", "comment": " A signal of records indicating which arrow keys are pressed.\n\n * `{ x = 0, y = 0 }` when pressing no arrows.\n * `{ x =-1, y = 0 }` when pressing the left arrow.\n * `{ x = 1, y = 1 }` when pressing the up and right arrows.\n * `{ x = 0, y =-1 }` when pressing the down, left, and right arrows.\n", "type": "Signal { x : Int, y : Int }" }, { "name": "ctrl", "comment": "", "type": "Signal Bool" }, { "name": "enter", "comment": "", "type": "Signal Bool" }, { "name": "isDown", "comment": " Whether an arbitrary key is pressed. ", "type": "KeyCode -> Signal Bool" }, { "name": "keysDown", "comment": " Set of keys that are currently down. ", "type": "Signal (Set KeyCode)" }, { "name": "meta", "comment": " The meta key is the Windows key on Windows and the Command key on Mac.\n", "type": "Signal Bool" }, { "name": "presses", "comment": " The latest key that has been pressed. ", "type": "Signal KeyCode" }, { "name": "shift", "comment": "", "type": "Signal Bool" }, { "name": "space", "comment": "", "type": "Signal Bool" }, { "name": "wasd", "comment": " Just like the arrows signal, but this uses keys w, a, s, and d,\nwhich are common controls for many computer games.\n", "type": "Signal { x : Int, y : Int }" } ], "binops": [] }, { "name": "Mouse", "comment": " Library for working with mouse input.\n\n# Position\n@docs position, x, y\n\n# Button Status\n@docs isDown, clicks\n\n", "unions": [], "aliases": [], "values": [ { "name": "clicks", "comment": " Always equal to unit. Event triggers on every mouse click. ", "type": "Signal ()" }, { "name": "isDown", "comment": " The current state of the mouse\nTrue when any mouse button is down, and false otherwise. ", "type": "Signal Bool" }, { "name": "position", "comment": " The current mouse position. ", "type": "Signal ( Int, Int )" }, { "name": "x", "comment": " The current x-coordinate of the mouse. ", "type": "Signal Int" }, { "name": "y", "comment": " The current y-coordinate of the mouse. ", "type": "Signal Int" } ], "binops": [] }, { "name": "Signal", "comment": " A *signal* is a value that changes over time. For example, we can\nthink of the mouse position as a pair of numbers that is changing over time,\nwhenever the user moves the mouse.\n\n Mouse.position : Signal (Int,Int)\n\nAnother signal is the `Element` or `Html` we want to show on screen.\n\n main : Signal Html\n\nAs the `Html` changes, the user sees different things on screen automatically.\n\nSome useful functions for working with time (e.g. setting FPS) and combining\nsignals and time (e.g. timestamps) can be found in the [`Time`](Time) library.\n\n# Signals\n@docs Signal\n\n# Merging\n@docs merge, mergeMany\n\n# Mapping\n@docs map, map2, map3, map4, map5\n\n# Past-Dependence\n@docs foldp\n\n# Filters\n@docs filter, filterMap, dropRepeats, sampleOn\n\n# Mailboxes\n@docs Mailbox, Address, mailbox, Message, message, forwardTo, send\n\n# Constants\n@docs constant\n\n", "unions": [ { "name": "Address", "comment": " An `Address` points to a specific signal. It allows you to feed values into\nsignals, so you can provide your own signal updates.\n\nThe primary use case is when a `Task` or UI element needs to talk back to the\nmain part of your application.\n", "args": [ "a" ], "cases": [] }, { "name": "Message", "comment": " A `Message` is like an envelope that you have not yet put in a mailbox.\nThe address is filled out and the envelope is filled, but it will be sent at\nsome point in the future.\n", "args": [], "cases": [] }, { "name": "Signal", "comment": " A value that changes over time. So a `(Signal Int))` is an integer that is\nvarying as time passes, perhaps representing the current window width of the\nbrowser. Every signal is updated at discrete moments in response to events in\nthe world.\n", "args": [ "a" ], "cases": [] } ], "aliases": [ { "name": "Mailbox", "comment": " A `Mailbox` is a communication hub. It is made up of\n\n * an `Address` that you can send messages to\n * a `Signal` of messages sent to the mailbox\n", "args": [ "a" ], "type": "{ address : Address a, signal : Signal a }" } ], "values": [ { "name": "constant", "comment": " Create a signal that never changes. This can be useful if you need\nto pass a combination of signals and normal values to a function:\n\n map3 view Window.dimensions Mouse.position (constant initialModel)\n", "type": "a -> Signal a" }, { "name": "dropRepeats", "comment": " Drop updates that repeat the current value of the signal.\n\n numbers : Signal Int\n\n noDups : Signal Int\n noDups =\n dropRepeats numbers\n\n -- numbers => 0 0 3 3 5 5 5 4 ...\n -- noDups => 0 3 5 4 ...\n\nThe signal should not be a signal of functions, or a record that contains a\nfunction (you'll get a runtime error since functions cannot be equated).\n", "type": "Signal a -> Signal a" }, { "name": "filter", "comment": " Filter out some updates. The given function decides whether we should\n*keep* an update. If no updates ever flow through, we use the default value\nprovided. The following example only keeps even numbers and has an initial\nvalue of zero.\n\n numbers : Signal Int\n\n isEven : Int -> Bool\n\n evens : Signal Int\n evens =\n filter isEven 0 numbers\n", "type": "(a -> Bool) -> a -> Signal a -> Signal a" }, { "name": "filterMap", "comment": " Filter out some updates. When the filter function gives back `Just` a\nvalue, we send that value along. When it returns `Nothing` we drop it.\nIf the initial value of the incoming signal turns into `Nothing`, we use the\ndefault value provided. The following example keeps only strings that can be\nread as integers.\n\n userInput : Signal String\n\n toInt : String -> Maybe Int\n\n numbers : Signal Int\n numbers =\n filterMap toInt 0 userInput\n", "type": "(a -> Maybe b) -> b -> Signal a -> Signal b" }, { "name": "foldp", "comment": " Create a past-dependent signal. Each update from the incoming signals will\nbe used to step the state forward. The outgoing signal represents the current\nstate.\n\n clickCount : Signal Int\n clickCount =\n foldp (\\click total -> total + 1) 0 Mouse.clicks\n\n timeSoFar : Signal Time\n timeSoFar =\n foldp (+) 0 (fps 40)\n\nSo `clickCount` updates on each mouse click, incrementing by one. `timeSoFar`\nis the time the program has been running, updated 40 times a second.\n", "type": "(a -> state -> state) -> state -> Signal a -> Signal state" }, { "name": "forwardTo", "comment": " Create a new address. This address will tag each message it receives\nand then forward it along to some other address.\n\n type Action = Undo | Remove Int | NoOp\n\n actions : Mailbox Action\n actions = mailbox NoOp\n\n removeAddress : Address Int\n removeAddress =\n forwardTo actions.address Remove\n\nIn this case we have a general `address` that many people may send\nmessages to. The new `removeAddress` tags all messages with the `Remove` tag\nbefore forwarding them along to the more general `address`. This means\nsome parts of our application can know *only* about `removeAddress` and not\ncare what other kinds of `Actions` are possible.\n", "type": "Address b -> (a -> b) -> Address a" }, { "name": "mailbox", "comment": " Create a mailbox you can send messages to. The primary use case is\nreceiving updates from tasks and UI elements. The argument is a default value\nfor the custom signal.\n\nNote: Creating new signals is inherently impure, so `(mailbox ())` and\n`(mailbox ())` produce two different mailboxes.\n", "type": "a -> Mailbox a" }, { "name": "map", "comment": " Apply a function to a signal.\n\n mouseIsUp : Signal Bool\n mouseIsUp =\n map not Mouse.isDown\n\n main : Signal Element\n main =\n map Graphics.Element.show Mouse.position\n", "type": "(a -> result) -> Signal a -> Signal result" }, { "name": "map2", "comment": " Apply a function to the current value of two signals. The function\nis reevaluated whenever *either* signal changes. In the following example, we\nfigure out the `aspectRatio` of the window by combining the current width and\nheight.\n\n ratio : Int -> Int -> Float\n ratio width height =\n toFloat width / toFloat height\n\n aspectRatio : Signal Float\n aspectRatio =\n map2 ratio Window.width Window.height\n", "type": "(a -> b -> result) -> Signal a -> Signal b -> Signal result" }, { "name": "map3", "comment": "", "type": "(a -> b -> c -> result) -> Signal a -> Signal b -> Signal c -> Signal result" }, { "name": "map4", "comment": "", "type": "(a -> b -> c -> d -> result) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal result" }, { "name": "map5", "comment": "", "type": "(a -> b -> c -> d -> e -> result) -> Signal a -> Signal b -> Signal c -> Signal d -> Signal e -> Signal result" }, { "name": "merge", "comment": " Merge two signals into one. This function is extremely useful for bringing\ntogether lots of different signals to feed into a `foldp`.\n\n type Update = MouseMove (Int,Int) | TimeDelta Float\n\n updates : Signal Update\n updates =\n merge\n (map MouseMove Mouse.position)\n (map TimeDelta (fps 40))\n\nIf an update comes from either of the incoming signals, it updates the outgoing\nsignal. If an update comes on both signals at the same time, the update provided\nby the left input signal wins (i.e., the update from the second signal is discarded).\n", "type": "Signal a -> Signal a -> Signal a" }, { "name": "mergeMany", "comment": " Merge many signals into one. This is useful when you are merging more than\ntwo signals. When multiple updates come in at the same time, the left-most\nupdate wins, just like with `merge`.\n\n type Update = MouseMove (Int,Int) | TimeDelta Float | Click\n\n updates : Signal Update\n updates =\n mergeMany\n [ map MouseMove Mouse.position\n , map TimeDelta (fps 40)\n , map (always Click) Mouse.clicks\n ]\n", "type": "List (Signal a) -> Signal a" }, { "name": "message", "comment": " Create a message that may be sent to a `Mailbox` at a later time.\n\nMost importantly, this lets us create APIs that can send values to ports\n*without* allowing people to run arbitrary tasks.\n", "type": "Address a -> a -> Message" }, { "name": "sampleOn", "comment": " Sample from the second input every time an event occurs on the first input.\nFor example, `(sampleOn Mouse.clicks (Time.every Time.second))` will give the\napproximate time of the latest click. ", "type": "Signal a -> Signal b -> Signal b" }, { "name": "send", "comment": " Send a message to an `Address`.\n\n type Action = Undo | Remove Int\n\n address : Address Action\n\n requestUndo : Task x ()\n requestUndo =\n send address Undo\n\nThe `Signal` associated with `address` will receive the `Undo` message\nand push it through the Elm program.\n", "type": "Address a -> a -> Task x ()" } ], "binops": [] }, { "name": "Debug", "comment": " This library is for investigating bugs or performance problems. It should\n*not* be used in production code.\n\n# Console Debugging\n@docs log, crash\n\n# Time-Travel Debugging\n@docs watch, watchSummary, trace\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 data 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" }, { "name": "trace", "comment": " Trace all past positions of a `Form` in the debugger. Add this to a `Form`\nand you will see a line tracing its entire history.\n", "type": "String -> Form -> Form" }, { "name": "watch", "comment": " Watch a particular value in the debugger. Say we want to know the value of\na variable called `velocity` because it may not be updated correctly. Adding\n`Debug.watch` allows us to name the value and show it with the debugger. The\nresult of evaluating such an expression is unchanged.\n\n\t Debug.watch \"velocity\" velocity == velocity\n\nThat means it's easy to add `Debug.watch` to any value.\n\nNote that calling `Debug.watch` on a signal is not useful. Instead, it needs\nto be mapped into the signal (to act on the contained value). So if you want\nto watch a timer signal, instead of `Debug.watch \"time\" (Time.every 1000)`\nyou need `Signal.map (Debug.watch \"time\") (Time.every 1000)`.\n", "type": "String -> a -> a" }, { "name": "watchSummary", "comment": " Watch a summary of a particular value in the debugger. This function is\npretty much the same as `watch` but it lets you specify a way to summarize\nthe value you are interested in. For example, maybe you only want to see part\nof a record:\n\n\t Debug.watchSummary \"velocity\" .velocity object\n\nThis is the same as just writing `object`, but it creates a watch that *only*\nlooks at the value of `object.velocity`. You can also show summary statistics\nlike length of a list:\n\n\t Debug.watchSummary \"Number of clicks\" length clicks\n\nAgain, this evaluates to `clicks` but we get to see how long that list is in\nthe debugger.\n", "type": "String -> (a -> b) -> a -> a" } ], "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. Set equality with\n`(==)` is unreliable and should not be used.\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 -> comparable_) -> Set comparable -> Set comparable_" }, { "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": " A way to turn Json values into Elm values. A `Decoder a` represents a\ndecoding operation that will either produce a value of type `a`, or fail.\n\n# Decoders\n@docs Decoder, Value\n\n# Run a Decoder\n@docs decodeString, decodeValue\n\n# Primitives\n@docs string, int, float, bool, null\n\n# Arrays\n@docs list, array,\n tuple1, tuple2, tuple3, tuple4, tuple5, tuple6, tuple7, tuple8\n\n# Objects\n@docs (:=), at,\n object1, object2, object3, object4, object5, object6, object7, object8,\n keyValuePairs, dict\n\n# Oddly Shaped Values\n@docs maybe, oneOf, map, fail, succeed, andThen\n\n# \"Creative\" Values\n@docs value, customDecoder\n", "unions": [ { "name": "Decoder", "comment": " Represents a way of decoding JSON values. If you have a `(Decoder (List String))`\nit will attempt to take some JSON value and turn it into a list of strings.\nThese decoders are easy to put together so you can create more and more complex\ndecoders.\n", "args": [ "a" ], "cases": [] } ], "aliases": [ { "name": "Value", "comment": " Represents a JavaScript value.\n", "args": [], "type": "Value" } ], "values": [ { "name": "andThen", "comment": " Helpful when one field will determine the shape of a bunch of other fields.\n\n type Shape\n = Rectangle Float Float\n | Circle Float\n\n shape : Decoder Shape\n shape =\n (\"tag\" := string) `andThen` shapeInfo\n\n shapeInfo : String -> Decoder Shape\n shapeInfo tag =\n case tag of\n \"rectangle\" ->\n object2 Rectangle\n (\"width\" := float)\n (\"height\" := float)\n\n \"circle\" ->\n object1 Circle\n (\"radius\" := float)\n\n _ ->\n fail (tag ++ \" is not a recognized tag for shapes\")\n", "type": "Decoder a -> (a -> Decoder b) -> Decoder b" }, { "name": "array", "comment": " Extract an Array from a JS array.\n\n -- [1,2,3,4]\n\n numbers : Decoder (Array Int)\n numbers =\n array int\n", "type": "Decoder a -> Decoder (Array a)" }, { "name": "at", "comment": " Access a nested field, making it easy to dive into big structures. This is\nreally a helper function so you do not need to write `(:=)` so many times.\n\n -- object.target.value = 'hello'\n value : Decoder String\n value =\n at [\"target\", \"value\"] string\n\nIt is defined as\n\n at fields decoder =\n List.foldr (:=) decoder fields\n", "type": "List String -> Decoder a -> Decoder a" }, { "name": "bool", "comment": " Extract a boolean.\n\n -- { ... checked: true ... }\n\n checked : Decoder Bool\n checked =\n \"checked\" := bool\n", "type": "Decoder Bool" }, { "name": "customDecoder", "comment": " Create a custom decoder that may do some fancy computation. See the `value`\ndocumentation for an example usage.\n", "type": "Decoder a -> (a -> Result String b) -> Decoder b" }, { "name": "decodeString", "comment": " Using a certain decoder, attempt to parse a JSON string. If the decoder\nfails, you will get a string message telling you why.\n\n decodeString (tuple2 float float) \"[3,4]\" -- Ok (3,4)\n decodeString (tuple2 float float) \"{ \\\"x\\\": 3, \\\"y\\\": 4 }\" -- Err \"\"\n", "type": "Decoder a -> String -> Result String a" }, { "name": "decodeValue", "comment": " Using a certain decoder, attempt to parse a raw `Json.Value`. You can pass\na `Json.Value` into Elm through a port, so this can let you handle data with\nextra weird shapes or stuff that currently is not allowed through ports\nautomatically.\n\n port jsonValues : Signal Json.Value\n\n shapes : Signal (Result String Shape)\n shapes =\n Signal.map (decodeValue shape) jsonValues\n\n type Shape\n = Rectangle Float Float\n | Circle Float\n\n shape : Decoder Shape -- see definition in `andThen` docs\n", "type": "Decoder a -> Value -> Result String a" }, { "name": "dict", "comment": " Turn any object into a dictionary of key-value pairs.\n\n -- { mercury: 0.33, venus: 4.87, earth: 5.97, ... }\n planetMasses : Decoder (Dict String Float)\n planetMasses =\n dict float\n", "type": "Decoder a -> Decoder (Dict String a)" }, { "name": "fail", "comment": " A decoder that always fails. Useful when paired with `andThen` or `oneOf`\nto improve error messages when things go wrong. For example, the following\ndecoder is able to provide a much more specific error message when `fail` is\nthe last option.\n\n point : Decoder (Float,Float)\n point =\n oneOf\n [ tuple2 (,) float float\n , object2 (,) (\"x\" := float) (\"y\" := float)\n , fail \"expecting some kind of point\"\n ]\n", "type": "String -> Decoder a" }, { "name": "float", "comment": " Extract a float.\n\n -- [ 6.022, 3.1415, 1.618 ]\n\n numbers : Decoder (List Float)\n numbers =\n list float\n", "type": "Decoder Float" }, { "name": "int", "comment": " Extract an integer.\n\n -- { ... age: 42 ... }\n\n age : Decoder Int\n age =\n \"age\" := int\n", "type": "Decoder Int" }, { "name": "keyValuePairs", "comment": " Turn any object into a list of key-value pairs. Fails if _any_ key can't be\ndecoded with the given decoder.\n\n -- { tom: 89, sue: 92, bill: 97, ... }\n grades : Decoder (List (String, Int))\n grades =\n keyValuePairs int\n", "type": "Decoder a -> Decoder (List ( String, a ))" }, { "name": "list", "comment": " Extract a List from a JS array.\n\n -- [1,2,3,4]\n\n numbers : Decoder (List Int)\n numbers =\n list int\n", "type": "Decoder a -> Decoder (List a)" }, { "name": "map", "comment": " Transform the value returned by a decoder. Most useful when paired with\nthe `oneOf` function.\n\n nullOr : Decoder a -> Decoder (Maybe a)\n nullOr decoder =\n oneOf\n [ null Nothing\n , map Just decoder\n ]\n\n type UserID = OldID Int | NewID String\n\n -- 1234 or \"1234abc\"\n userID : Decoder UserID\n userID =\n oneOf\n [ map OldID int\n , map NewID string\n ]\n", "type": "(a -> b) -> Decoder a -> Decoder b" }, { "name": "maybe", "comment": " Extract a Maybe value, wrapping successes with `Just` and turning any\nfailure in `Nothing`. If you are expecting that a field can sometimes be `null`,\nit's better to check for it [explicitly](#null), as this function will swallow\nerrors from ill-formed JSON.\n\nThe following code decodes JSON objects that may not have a profession field.\n\n -- profession: Just \"plumber\"\n -- { name: \"Tom\", age: 31, profession: \"plumber\" }\n -- profession: Nothing\n -- { name: \"Sue\", age: 42 }\n -- { name: \"Amy\", age: 27, profession: null }\n -- { name: \"Joe\", age: 36, profession: [\"something\", \"unexpected\"] }\n\n type alias Person =\n { name : String\n , age : Int\n , profession : Maybe String\n }\n\n person : Decoder Person\n person =\n object3 Person\n (\"name\" := string)\n (\"age\" := int)\n (maybe (\"profession\" := string))\n", "type": "Decoder a -> Decoder (Maybe a)" }, { "name": "null", "comment": " Decode null as the value given, and fail otherwise. Primarily useful for\ncreating *other* decoders.\n\n numbers : Decoder [Int]\n numbers =\n list (oneOf [ int, null 0 ])\n\nThis decoder treats `null` as `Nothing`, and otherwise tries to produce a\n`Just`.\n\n nullOr : Decoder a -> Decoder (Maybe a)\n nullOr decoder =\n oneOf\n [ null Nothing\n , map Just decoder\n ]\n", "type": "a -> Decoder a" }, { "name": "object1", "comment": " Apply a function to a decoder. You can use this function as `map` if you\nmust (which can be done with any `objectN` function actually).\n\n object1 sqrt (\"x\" := float)\n", "type": "(a -> value) -> Decoder a -> Decoder value" }, { "name": "object2", "comment": " Use two different decoders on a JS value. This is nice for extracting\nmultiple fields from an object.\n\n point : Decoder (Float,Float)\n point =\n object2 (,)\n (\"x\" := float)\n (\"y\" := float)\n", "type": "(a -> b -> value) -> Decoder a -> Decoder b -> Decoder value" }, { "name": "object3", "comment": " Use three different decoders on a JS value. This is nice for extracting\nmultiple fields from an object.\n\n type alias Job = { name : String, id : Int, completed : Bool }\n\n point : Decoder Job\n point =\n object3 Job\n (\"name\" := string)\n (\"id\" := int)\n (\"completed\" := bool)\n", "type": "(a -> b -> c -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder value" }, { "name": "object4", "comment": "", "type": "(a -> b -> c -> d -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder value" }, { "name": "object5", "comment": "", "type": "(a -> b -> c -> d -> e -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder value" }, { "name": "object6", "comment": "", "type": "(a -> b -> c -> d -> e -> f -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder value" }, { "name": "object7", "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": "object8", "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": "oneOf", "comment": " Try out multiple different decoders. This is helpful when you are dealing\nwith something with a very strange shape and when `andThen` does not help\nnarrow things down so you can be more targeted.\n\n -- [ [3,4], { x:0, y:0 }, [5,12] ]\n\n points : Decoder (List (Float,Float))\n points =\n list point\n\n point : Decoder (Float,Float)\n point =\n oneOf\n [ tuple2 (,) float float\n , object2 (,) (\"x\" := float) (\"y\" := float)\n ]\n", "type": "List (Decoder a) -> Decoder a" }, { "name": "string", "comment": " Extract a string.\n\n -- [\"John\",\"Doe\"]\n\n name : Decoder (String, String)\n name =\n tuple2 (,) string string\n", "type": "Decoder String" }, { "name": "succeed", "comment": " A decoder that always succeeds. Useful when paired with `andThen` or\n`oneOf` but everything is supposed to work out at the end. For example,\nmaybe you have an optional field that can have a default value when it is\nmissing.\n\n -- { x:3, y:4 } or { x:3, y:4, z:5 }\n\n point3D : Decoder (Float,Float,Float)\n point3D =\n object3 (,,)\n (\"x\" := float)\n (\"y\" := float)\n (oneOf [ \"z\" := float, succeed 0 ])\n", "type": "a -> Decoder a" }, { "name": "tuple1", "comment": " Handle an array with exactly one element.\n\n extractString : Decoder String\n extractString = \n tuple1 identity string\n\n authorship : Decoder String\n authorship =\n oneOf\n [ tuple1 (\\author -> \"Author: \" ++ author) string\n , list string |> map (\\authors -> \"Co-authors: \" ++ String.join \", \" authors)\n ]\n", "type": "(a -> value) -> Decoder a -> Decoder value" }, { "name": "tuple2", "comment": " Handle an array with exactly two elements. Useful for points and simple\npairs.\n\n -- [3,4] or [0,0]\n point : Decoder (Float,Float)\n point =\n tuple2 (,) float float\n\n -- [\"John\",\"Doe\"] or [\"Hermann\",\"Hesse\"]\n name : Decoder Name\n name =\n tuple2 Name string string\n\n type alias Name = { first : String, last : String }\n", "type": "(a -> b -> value) -> Decoder a -> Decoder b -> Decoder value" }, { "name": "tuple3", "comment": " Handle an array with exactly three elements.\n\n -- [3,4,5] or [0,0,0]\n point3D : Decoder (Float,Float,Float)\n point3D =\n tuple3 (,,) float float float\n\n", "type": "(a -> b -> c -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder value" }, { "name": "tuple4", "comment": "", "type": "(a -> b -> c -> d -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder value" }, { "name": "tuple5", "comment": "", "type": "(a -> b -> c -> d -> e -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder value" }, { "name": "tuple6", "comment": "", "type": "(a -> b -> c -> d -> e -> f -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder d -> Decoder e -> Decoder f -> Decoder value" }, { "name": "tuple7", "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": "tuple8", "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": "value", "comment": " Bring in an arbitrary JSON value. Useful if you need to work with crazily\nformatted data. For example, this lets you create a parser for \"variadic\" lists\nwhere the first few types are different, followed by 0 or more of the same\ntype.\n\n variadic2 : (a -> b -> List c -> value) -> Decoder a -> Decoder b -> Decoder c -> Decoder value\n variadic2 f a b c =\n let\n combineResults = List.foldr (Result.map2 (::)) (Ok [])\n in\n customDecoder (list value) (\\jsonList ->\n case jsonList of\n one :: two :: rest ->\n Result.map3 f\n (decodeValue a one)\n (decodeValue b two)\n (combineResults (List.map (decodeValue c) rest))\n\n _ -> Result.Err \"expecting at least two elements in the array\")\n", "type": "Decoder Value" } ], "binops": [ { "name": ":=", "comment": " Applies the decoder to the field with the given name.\nFails if the JSON object has no such field.\n\n nameAndAge : Decoder (String,Int)\n nameAndAge =\n object2 (,)\n (\"name\" := string)\n (\"age\" := int)\n\n optionalProfession : Decoder (Maybe String)\n optionalProfession =\n maybe (\"profession\" := string)\n", "type": "String -> Decoder a -> Decoder a", "associativity": "left", "precedence": 9 } ] }, { "name": "Graphics.Collage", "comment": " The collage API is for freeform graphics. You can move, rotate, scale, etc.\nall sorts of forms including lines, shapes, images, and elements.\n\nCollages use the same coordinate system you might see in an algebra or physics\nproblem. The origin (0,0) is at the center of the collage, not the top left\ncorner as in some other graphics libraries. Furthermore, the y-axis points up,\nso moving a form 10 units in the y-axis will move it up on screen.\n\n# Unstructured Graphics\n@docs collage, Form\n\n# Creating Forms\n@docs toForm, filled, textured, gradient, outlined, traced, text, outlinedText\n\n# Transforming Forms\n@docs move, moveX, moveY, scale, rotate, alpha\n\n# Grouping Forms\nGrouping forms makes it easier to write modular graphics code. You can create\na form that is a composite of many subforms. From there it is easy to transform\nit as a single unit.\n\n@docs group, groupTransform\n\n# Shapes\n@docs Shape, rect, oval, square, circle, ngon, polygon\n\n# Paths\n@docs Path, segment, path\n\n# Line Styles\n@docs solid, dashed, dotted, LineStyle, LineCap, LineJoin, defaultLine\n\n", "unions": [ { "name": "Form", "comment": " A visual `Form` has a shape and texture. This can be anything from a red\nsquare to a circle textured with stripes.\n", "args": [], "cases": [] }, { "name": "LineCap", "comment": " The shape of the ends of a line. ", "args": [], "cases": [ [ "Flat", [] ], [ "Round", [] ], [ "Padded", [] ] ] }, { "name": "LineJoin", "comment": " The shape of the “joints” of a line, where each line segment\nmeets. `Sharp` takes an argument to limit the length of the joint. This\ndefaults to 10.\n", "args": [], "cases": [ [ "Smooth", [] ], [ "Sharp", [ "Float" ] ], [ "Clipped", [] ] ] }, { "name": "Path", "comment": " A 2D path. Paths are a sequence of points. They do not have a color.\n", "args": [], "cases": [] }, { "name": "Shape", "comment": " A 2D shape. Shapes are closed polygons. They do not have a color or\ntexture, that information can be filled in later.\n", "args": [], "cases": [] } ], "aliases": [ { "name": "LineStyle", "comment": " All of the attributes of a line style. This lets you build up a line style\nhowever you want. You can also update existing line styles with record updates.\n", "args": [], "type": "{ color : Color, width : Float, cap : LineCap, join : LineJoin, dashing : List Int, dashOffset : Int }" } ], "values": [ { "name": "alpha", "comment": " Set the alpha of a `Form`. The default is 1, and 0 is totally transparent. ", "type": "Float -> Form -> Form" }, { "name": "circle", "comment": " A circle with a given radius. ", "type": "Float -> Shape" }, { "name": "collage", "comment": " Create a collage with certain dimensions and content. It takes width and height\narguments to specify dimensions, and then a list of 2D forms to decribe the content.\n\nUnlike with `Element`s, these 2D forms can be moved and rotated however you like.\nThe forms are drawn in the order of the list, i.e., `collage w h [a, b]` will\ndraw `b` on top of `a`.\n", "type": "Int -> Int -> List Form -> Element" }, { "name": "dashed", "comment": " Create a dashed line style with a given color. Dashing equals `[8,4]`. ", "type": "Color -> LineStyle" }, { "name": "defaultLine", "comment": " The default line style, which is solid black with flat caps and sharp joints.\nYou can use record updates to build the line style you\nwant. For example, to make a thicker line, you could say:\n\n { defaultLine | width = 10 }\n", "type": "LineStyle" }, { "name": "dotted", "comment": " Create a dotted line style with a given color. Dashing equals `[3,3]`. ", "type": "Color -> LineStyle" }, { "name": "filled", "comment": " Create a filled in shape. ", "type": "Color -> Shape -> Form" }, { "name": "gradient", "comment": " Fill a shape with a [gradient](Color#linear). ", "type": "Gradient -> Shape -> Form" }, { "name": "group", "comment": " Flatten many forms into a single `Form`. This lets you move and rotate them\nas a single unit, making it possible to build small, modular components.\nForms will be drawn in the order that they are listed, as in `collage`.\n", "type": "List Form -> Form" }, { "name": "groupTransform", "comment": " Flatten many forms into a single `Form` and then apply a matrix\ntransformation. Forms will be drawn in the order that they are listed, as in\n`collage`.\n", "type": "Transform2D -> List Form -> Form" }, { "name": "move", "comment": " Move a form by the given amount (x, y). This is a relative translation so\n`(move (5,10) form)` would move `form` five pixels to the right and ten pixels up.\n", "type": "( Float, Float ) -> Form -> Form" }, { "name": "moveX", "comment": " Move a shape in the x direction. This is relative so `(moveX 10 form)` moves\n`form` 10 pixels to the right.\n", "type": "Float -> Form -> Form" }, { "name": "moveY", "comment": " Move a shape in the y direction. This is relative so `(moveY 10 form)` moves\n`form` upwards by 10 pixels.\n", "type": "Float -> Form -> Form" }, { "name": "ngon", "comment": " A regular polygon with N sides. The first argument specifies the number\nof sides and the second is the radius. So to create a pentagon with radius\n30 you would say:\n\n ngon 5 30\n", "type": "Int -> Float -> Shape" }, { "name": "outlined", "comment": " Outline a shape with a given line style. ", "type": "LineStyle -> Shape -> Form" }, { "name": "outlinedText", "comment": " Create some outlined text. Since we are just outlining the text, the color\nis taken from the `LineStyle` attribute instead of the `Text`.\n", "type": "LineStyle -> Text -> Form" }, { "name": "oval", "comment": " An oval with a given width and height. ", "type": "Float -> Float -> Shape" }, { "name": "path", "comment": " Create a path that follows a sequence of points. ", "type": "List ( Float, Float ) -> Path" }, { "name": "polygon", "comment": " Create an arbitrary polygon by specifying its corners in order.\n`polygon` will automatically close all shapes, so the given list\nof points does not need to start and end with the same position.\n", "type": "List ( Float, Float ) -> Shape" }, { "name": "rect", "comment": " A rectangle with a given width and height. ", "type": "Float -> Float -> Shape" }, { "name": "rotate", "comment": " Rotate a form by a given angle. Rotate takes standard Elm angles (radians)\nand turns things counterclockwise. So to turn `form` 30° to the left\nyou would say, `(rotate (degrees 30) form)`.\n", "type": "Float -> Form -> Form" }, { "name": "scale", "comment": " Scale a form by a given factor. Scaling by 2 doubles both dimensions,\nand quadruples the area.\n", "type": "Float -> Form -> Form" }, { "name": "segment", "comment": " Create a path along a given line segment. ", "type": "( Float, Float ) -> ( Float, Float ) -> Path" }, { "name": "solid", "comment": " Create a solid line style with a given color. ", "type": "Color -> LineStyle" }, { "name": "square", "comment": " A square with a given edge length. ", "type": "Float -> Shape" }, { "name": "text", "comment": " Create some text. Details like size and color are part of the `Text` value\nitself, so you can mix colors and sizes and fonts easily.\n", "type": "Text -> Form" }, { "name": "textured", "comment": " Create a textured shape. The texture is described by some url and is\ntiled to fill the entire shape.\n", "type": "String -> Shape -> Form" }, { "name": "toForm", "comment": " Turn any `Element` into a `Form`. This lets you use text, gifs, and video\nin your collage. This means you can move, rotate, and scale\nan `Element` however you want.\n", "type": "Element -> Form" }, { "name": "traced", "comment": " Trace a path with a given line style. ", "type": "LineStyle -> Path -> Form" } ], "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. Dictionary\nequality with `(==)` is unreliable and should not be used.\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# Combine\n@docs union, intersect, diff\n\n# Lists\n@docs keys, values, toList, fromList\n\n# Transform\n@docs map, foldl, foldr, filter, partition\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": "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": "Graphics.Element", "comment": " Graphical elements that snap together to build complex widgets and layouts.\nEach Element is a rectangle with a known width and height, making them easy to\ncombine and position.\n\n# Elements\n@docs Element\n\n# Show Anything\n@docs show\n\n# Images\n@docs image, fittedImage, croppedImage, tiledImage\n\n# Text\nEach of the following functions places [`Text`](Text) into a box. The function\nyou use determines the alignment of the text.\n\n@docs leftAligned, rightAligned, centered, justified\n\n# Styling\n@docs width, height, size, color, opacity, link, tag\n\n# Inspection\n@docs widthOf, heightOf, sizeOf\n\n# Layout\n@docs flow, Direction, up, down, left, right, inward, outward\n\n## Layout Aliases\nThere are also some convenience functions for working\nwith `flow` in specific cases:\n\n@docs layers, above, below, beside\n\n# Positioning\n@docs empty, spacer, container\n\n## Specific Positions\n\n@docs Position, middle, midTop, midBottom, midLeft, midRight, topLeft,\n topRight, bottomLeft, bottomRight\n\nIf you need more precision, you can create custom positions.\n\n@docs Pos, absolute, relative, middleAt, midTopAt, midBottomAt, midLeftAt,\n midRightAt, topLeftAt, topRightAt, bottomLeftAt, bottomRightAt\n", "unions": [ { "name": "Direction", "comment": " Represents a `flow` direction for a list of elements.\n", "args": [], "cases": [] }, { "name": "Element", "comment": " A graphical element that can be rendered on screen. Every element is a\nrectangle with a known width and height, so they can be composed and stacked\neasily.\n", "args": [], "cases": [] }, { "name": "Pos", "comment": " Specifies a distance from a particular location within a `container`, like\n“20 pixels right and up from the center”. You can use `absolute` or `relative`\nto specify a `Pos` in pixels or as a percentage of the container.\n", "args": [], "cases": [] }, { "name": "Position", "comment": " Specifies a position for an element within a `container`, like “the top\nleft corner”.\n", "args": [], "cases": [] } ], "aliases": [], "values": [ { "name": "above", "comment": " Stack elements vertically.\nTo put `a` above `b` you would say: ``a `above` b``\n", "type": "Element -> Element -> Element" }, { "name": "absolute", "comment": " A position specified in pixels. If you want something 10 pixels to the\nright of the middle of a container, you would write this:\n\n middleAt (absolute 10) (absolute 0)\n\n", "type": "Int -> Pos" }, { "name": "below", "comment": " Stack elements vertically.\nTo put `a` below `b` you would say: ``a `below` b``\n", "type": "Element -> Element -> Element" }, { "name": "beside", "comment": " Put elements beside each other horizontally.\nTo put `a` beside `b` you would say: ``a `beside` b``\n", "type": "Element -> Element -> Element" }, { "name": "bottomLeft", "comment": "", "type": "Position" }, { "name": "bottomLeftAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "bottomRight", "comment": "", "type": "Position" }, { "name": "bottomRightAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "centered", "comment": " Center text in the text block. There is equal spacing on either side of a\nline of text.\n", "type": "Text -> Element" }, { "name": "color", "comment": " Create an `Element` with a given background color. ", "type": "Color -> Element -> Element" }, { "name": "container", "comment": " Put an element in a container. This lets you position the element really\neasily, and there are tons of ways to set the `Position`.\nTo center `element` exactly in a 300-by-300 square you would say:\n\n container 300 300 middle element\n\nBy setting the color of the container, you can create borders.\n", "type": "Int -> Int -> Position -> Element -> Element" }, { "name": "croppedImage", "comment": " Create a cropped image. Take a rectangle out of the picture starting\nat the given top left coordinate. If you have a 140-by-140 image,\nthe following will cut a 100-by-100 square out of the middle of it.\n\n croppedImage (20,20) 100 100 \"yogi.jpg\"\n", "type": "( Int, Int ) -> Int -> Int -> String -> Element" }, { "name": "down", "comment": "", "type": "Direction" }, { "name": "empty", "comment": " An Element that takes up no space. Good for things that appear conditionally:\n\n flow down [ img1, if showMore then img2 else empty ]\n", "type": "Element" }, { "name": "fittedImage", "comment": " Create a fitted image given a width, height, and image source.\nThis will crop the picture to best fill the given dimensions.\n", "type": "Int -> Int -> String -> Element" }, { "name": "flow", "comment": " Have a list of elements flow in a particular direction.\nThe `Direction` starts from the first element in the list.\n\n flow right [a,b,c]\n\n +---+---+---+\n | a | b | c |\n +---+---+---+\n", "type": "Direction -> List Element -> Element" }, { "name": "height", "comment": " Create an `Element` with a given height. ", "type": "Int -> Element -> Element" }, { "name": "heightOf", "comment": " Get the height of an Element ", "type": "Element -> Int" }, { "name": "image", "comment": " Create an image given a width, height, and image source. ", "type": "Int -> Int -> String -> Element" }, { "name": "inward", "comment": "", "type": "Direction" }, { "name": "justified", "comment": " Align text along the left and right sides of the text block. Word spacing is\nadjusted to make this possible.\n", "type": "Text -> Element" }, { "name": "layers", "comment": " Layer elements on top of each other, starting from the bottom:\n`layers == flow outward`\n", "type": "List Element -> Element" }, { "name": "left", "comment": "", "type": "Direction" }, { "name": "leftAligned", "comment": " Align text along the left side of the text block. This is sometimes known as\n*ragged right*.\n", "type": "Text -> Element" }, { "name": "link", "comment": " Create an `Element` that is a hyper-link. ", "type": "String -> Element -> Element" }, { "name": "midBottom", "comment": "", "type": "Position" }, { "name": "midBottomAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "midLeft", "comment": "", "type": "Position" }, { "name": "midLeftAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "midRight", "comment": "", "type": "Position" }, { "name": "midRightAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "midTop", "comment": "", "type": "Position" }, { "name": "midTopAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "middle", "comment": "", "type": "Position" }, { "name": "middleAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "opacity", "comment": " Create an `Element` with a given opacity. Opacity is a number between 0 and 1\nwhere 0 means totally clear.\n", "type": "Float -> Element -> Element" }, { "name": "outward", "comment": "", "type": "Direction" }, { "name": "relative", "comment": " A position specified as a percentage. If you want something 10% away from\nthe top left corner, you would say:\n\n topLeftAt (relative 0.1) (relative 0.1)\n", "type": "Float -> Pos" }, { "name": "right", "comment": "", "type": "Direction" }, { "name": "rightAligned", "comment": " Align text along the right side of the text block. This is sometimes known\nas *ragged left*.\n", "type": "Text -> Element" }, { "name": "show", "comment": " Convert anything to its textual representation and make it displayable in\nthe browser. Excellent for debugging.\n\n main : Element\n main =\n show \"Hello World!\"\n\n show value =\n leftAligned (Text.monospace (Text.fromString (toString value)))\n", "type": "a -> Element" }, { "name": "size", "comment": " Create an `Element` with a new width and height. ", "type": "Int -> Int -> Element -> Element" }, { "name": "sizeOf", "comment": " Get the width and height of an Element ", "type": "Element -> ( Int, Int )" }, { "name": "spacer", "comment": " Create an empty box. This is useful for getting your spacing right and\nfor making borders.\n", "type": "Int -> Int -> Element" }, { "name": "tag", "comment": " Create an `Element` with a tag. This lets you link directly to it.\nThe element `(tag \"all-about-badgers\" thirdParagraph)` can be reached\nwith a link like this: `/facts-about-animals.elm#all-about-badgers`\n", "type": "String -> Element -> Element" }, { "name": "tiledImage", "comment": " Create a tiled image. Repeat the image to fill the given width and height.\n\n tiledImage 100 100 \"yogi.jpg\"\n", "type": "Int -> Int -> String -> Element" }, { "name": "topLeft", "comment": "", "type": "Position" }, { "name": "topLeftAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "topRight", "comment": "", "type": "Position" }, { "name": "topRightAt", "comment": "", "type": "Pos -> Pos -> Position" }, { "name": "up", "comment": "", "type": "Direction" }, { "name": "width", "comment": " Create an `Element` with a given width. ", "type": "Int -> Element -> Element" }, { "name": "widthOf", "comment": " Get the width of an Element ", "type": "Element -> Int" } ], "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": "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. ", "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. ", "type": "Int -> String -> String" }, { "name": "dropRight", "comment": " Drop *n* characters from the right side of a string. ", "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. ", "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. ", "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 toFloat \"123\" == Ok 123.0\n toFloat \"-42\" == Ok -42.0\n toFloat \"3.1\" == Ok 3.1\n toFloat \"31a\" == Err \"could not convert string '31a' to a Float\"\n", "type": "String -> Result String Float" }, { "name": "toInt", "comment": " Try to convert a string into an int, failing on improperly formatted strings.\n\n toInt \"123\" == Ok 123\n toInt \"-42\" == Ok -42\n toInt \"3.1\" == Err \"could not convert string '3.1' to an Int\"\n toInt \"31a\" == Err \"could not convert string '31a' to an Int\"\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. ", "type": "String -> String" }, { "name": "toUpper", "comment": " Convert a string to all upper case. Useful for case-insensitive comparisons\nand VIRTUAL YELLING.\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": "Text", "comment": " A library for styling and displaying text. While the\n[`String`](String) library focuses on representing and manipulating\nstrings of character strings, the `Text` library focuses on how those\nstrings should look on screen. It lets you make text bold or italic,\nset the typeface, set the text size, etc.\n\n# Text\n@docs Text\n\n# Creating Text\n@docs fromString, empty, append, concat, join\n\n# Links and Style\n@docs link, typeface, monospace, height, color, bold, italic, line, Line,\n style, Style, defaultStyle\n\n", "unions": [ { "name": "Line", "comment": " Styles for lines on text. This allows you to add an underline, an overline,\nor a strike out text:\n\n line Under (fromString \"underline\")\n line Over (fromString \"overline\")\n line Through (fromString \"strike out\")\n", "args": [], "cases": [ [ "Under", [] ], [ "Over", [] ], [ "Through", [] ] ] }, { "name": "Text", "comment": " Represents styled text. It can be rendered with collages or with elements.\n", "args": [], "cases": [] } ], "aliases": [ { "name": "Style", "comment": " Represents all the ways you can style `Text`. If the `typeface` list is\nempty or the `height` is `Nothing`, the users will fall back on their browser's\ndefault settings. The following `Style` is black, 16 pixel tall, underlined, and\nTimes New Roman (assuming that typeface is available on the user's computer):\n\n { typeface = [ \"Times New Roman\", \"serif\" ]\n , height = Just 16\n , color = black\n , bold = False\n , italic = False\n , line = Just Under\n }\n", "args": [], "type": "{ typeface : List String, height : Maybe Float, color : Color, bold : Bool, italic : Bool, line : Maybe Line }" } ], "values": [ { "name": "append", "comment": " Put two chunks of text together.\n\n append (fromString \"hello \") (fromString \"world\") == fromString \"hello world\"\n", "type": "Text -> Text -> Text" }, { "name": "bold", "comment": " Make text bold.\n\n fromString \"sometimes you want \" ++ bold (fromString \"emphasis\")\n", "type": "Text -> Text" }, { "name": "color", "comment": " Set the color of some text.\n\n color red (fromString \"Red\")\n", "type": "Color -> Text -> Text" }, { "name": "concat", "comment": " Put many chunks of text together.\n\n concat\n [ fromString \"type \"\n , bold (fromString \"Maybe\")\n , fromString \" = Just a | Nothing\"\n ]\n", "type": "List Text -> Text" }, { "name": "defaultStyle", "comment": " Plain black text. It uses the browsers default typeface and text height.\nNo decorations are used.\n\n { typeface = []\n , height = Nothing\n , color = black\n , bold = False\n , italic = False\n , line = Nothing\n }\n", "type": "Style" }, { "name": "empty", "comment": " Text with nothing in it.\n\n empty = fromString \"\"\n", "type": "Text" }, { "name": "fromString", "comment": " Convert a string into text which can be styled and displayed. To show the\nstring `\"Hello World!\"` on screen in italics, you could say:\n\n main = leftAligned (italic (fromString \"Hello World!\"))\n", "type": "String -> Text" }, { "name": "height", "comment": " Set the height of some text.\n\n height 40 (fromString \"Title\")\n", "type": "Float -> Text -> Text" }, { "name": "italic", "comment": " Make text italic.\n\n fromString \"make it \" ++ italic (fromString \"important\")\n", "type": "Text -> Text" }, { "name": "join", "comment": " Put many chunks of text together with a separator.\n\n chunks : List Text\n chunks = List.map fromString [\"lions\",\"tigers\",\"bears\"]\n\n join (fromString \", \") chunks == fromString \"lions, tigers, bears\"\n", "type": "Text -> List Text -> Text" }, { "name": "line", "comment": " Put lines on text.\n\n line Under (fromString \"underlined\")\n line Over (fromString \"overlined\")\n line Through (fromString \"strike out\")\n", "type": "Line -> Text -> Text" }, { "name": "link", "comment": " Create a link by providing a URL and the text of the link.\n\n link \"http://elm-lang.org\" (fromString \"Elm Website\")\n", "type": "String -> Text -> Text" }, { "name": "monospace", "comment": " Switch to a monospace typeface. Good for code snippets.\n\n monospace (fromString \"foldl (+) 0 [1,2,3]\")\n", "type": "Text -> Text" }, { "name": "style", "comment": " Set the style of some text. For example, if you design a `Style` called\n`footerStyle` that is specifically for the bottom of your page, you could apply\nit to text like this:\n\n style footerStyle (fromString \"the old prince / 2007\")\n", "type": "Style -> Text -> Text" }, { "name": "typeface", "comment": " Provide a list of preferred typefaces for some text.\n\n [\"helvetica\",\"arial\",\"sans-serif\"]\n\nNot every browser has access to the same typefaces, so rendering will use the\nfirst typeface in the list that is found on the user's computer. If there are\nno matches, it will use their default typeface. This works the same as the CSS\nfont-family property.\n", "type": "List String -> Text -> Text" } ], "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..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,1,2]) == Just 0\n get 2 (fromList [0,1,2]) == Just 2\n get 5 (fromList [0,1,2]) == Nothing\n get -1 (fromList [0,1,2]) == 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": "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\nYou use a `Generator` by running the [`generate`](#generate) function. If you\nneed random values across many frames, you will probably want to store the\nmost recent seed in your application state.\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# Run a Generator\n@docs generate, 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 `andThen` \\b ->\n if b then uppercaseLetter else lowercaseLetter\n\n -- bool : Generator Bool\n -- uppercaseLetter : Generator Char\n -- lowercaseLetter : Generator Char\n", "type": "Generator a -> (a -> Generator b) -> 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": " 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 `generate` we need to provide\na seed. 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 `generate` call and\nthread that through.\n\n seed0 = initialSeed 31415\n\n -- generate (int 0 100) seed0 ==> (42, seed1)\n -- generate (int 0 100) seed1 ==> (31, seed2)\n -- generate (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 -- generate (int 0 100) seed0 ==> (42, seed1)\n -- generate (int 0 100) seed0 ==> (42, seed1)\n -- generate (int 0 100) seed0 ==> (42, seed1)\n", "type": "Generator a -> Seed -> ( a, Seed )" }, { "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. ", "type": "Int" }, { "name": "minInt", "comment": " The minimum value for randomly generated 32-bit ints. ", "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 )" } ], "binops": [] }, { "name": "Task", "comment": " Tasks make it easy to describe asynchronous operations that may fail, like HTTP requests or writing to a database.\nFor more information, see the [Elm documentation on Tasks](http://elm-lang.org/guide/reactivity#tasks).\n\n# Basics\n@docs Task, succeed, fail\n\n# Mapping\n@docs map, map2, map3, map4, map5, andMap\n\n# Chaining\n@docs andThen, sequence\n\n# Errors\n@docs onError, mapError, toMaybe, fromMaybe, toResult, fromResult\n\n# Threads\n@docs spawn, sleep, ThreadID\n", "unions": [ { "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": [ "x", "a" ], "cases": [] }, { "name": "ThreadID", "comment": " Abstract type that uniquely identifies a thread.\n", "args": [], "cases": [] } ], "aliases": [], "values": [ { "name": "andMap", "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\nThis function makes it possible to chain tons of tasks together and pipe them\nall into a single function.\n\n (f `map` task1 `andMap` task2 `andMap` task3) == map3 f task1 task2 task3\n", "type": "Task x (a -> b) -> Task x a -> Task x b" }, { "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 `andThen` (\\n -> succeed (n + 2)) == 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": "Task x a -> (a -> Task x b) -> Task x b" }, { "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": "fromMaybe", "comment": " If you are chaining together a bunch of tasks, it may be useful to treat\na maybe value like a task.\n\n fromMaybe \"file not found\" Nothing == fail \"file not found\"\n fromMaybe \"file not found\" (Just 42) == succeed 42\n", "type": "x -> Maybe a -> Task x a" }, { "name": "fromResult", "comment": " If you are chaining together a bunch of tasks, it may be useful to treat\na result like a task.\n\n fromResult (Err \"file not found\") == fail \"file not found\"\n fromResult (Ok 42) == succeed 42\n", "type": "Result x a -> 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\" `onError` (\\msg -> succeed 42) -- succeed 42\n succeed 9 `onError` (\\msg -> succeed 42) -- succeed 9\n", "type": "Task x a -> (x -> Task y a) -> Task y a" }, { "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": "sleep", "comment": " Make a thread sleep for a certain amount of time. The following example\nsleeps for 1 second and then succeeds with 42.\n\n sleep 1000 `andThen` \\_ -> succeed 42\n", "type": "Time -> Task x ()" }, { "name": "spawn", "comment": " Run a task on a separate thread. This lets you start working with basic\nconcurrency. In the following example, `task1` and `task2` will be interleaved.\nIf `task1` makes a long HTTP request, we can hop over to `task2` and do some\nwork there.\n\n spawn task1 `andThen` \\_ -> task2\n", "type": "Task x a -> Task y ThreadID" }, { "name": "succeed", "comment": " A task that succeeds immediately when run.\n\n succeed 42 -- results in 42\n", "type": "a -> Task x a" }, { "name": "toMaybe", "comment": " Translate a task that can fail into a task that can never fail, by\nconverting any failure into `Nothing` and any success into `Just` something.\n\n toMaybe (fail \"file not found\") == succeed Nothing\n toMaybe (succeed 42) == succeed (Just 42)\n\nThis means you can handle the error with the `Maybe` module instead.\n", "type": "Task x a -> Task never (Maybe a)" }, { "name": "toResult", "comment": " Translate a task that can fail into a task that can never fail, by\nconverting any failure into `Err` something and any success into `Ok` something.\n\n toResult (fail \"file not found\") == succeed (Err \"file not found\")\n toResult (succeed 42) == succeed (Ok 42)\n\nThis means you can handle the error with the `Result` module instead.\n", "type": "Task x a -> Task never (Result x a)" } ], "binops": [] }, { "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": " In this library, we use integers to represent the key codes coming from the\nkeyboard. You can use [`toCode`](#toCode) and [`fromCode`](#fromCode)\nto convert between key codes and characters.\n", "args": [], "type": "Int" } ], "values": [ { "name": "fromCode", "comment": " Convert from unicode. ", "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 letters. ", "type": "Char -> Bool" }, { "name": "isOctDigit", "comment": " True for ASCII octal digits `[0-7]`. ", "type": "Char -> Bool" }, { "name": "isUpper", "comment": " True for upper case letters. ", "type": "Char -> Bool" }, { "name": "toCode", "comment": " Convert to unicode. Used with the [`Keyboard`](Keyboard) library,\nwhich expects the input to be uppercase.\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": "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 repeat, (::), 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", "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..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 String.toInt : String -> Maybe Int\n\n filterMap String.toInt [\"3\", \"4.0\", \"5\", \"hats\"] == [3,5]\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..5] == ([0,1,2], [3,4,5])\n partition isEven [0..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..4] == 24\n", "type": "List number -> number" }, { "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..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": "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..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..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": "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, formatError\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 : Result e a -> (a -> Result e b) -> Result e b\n andThen result callback =\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 `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": "Result x a -> (a -> Result x b) -> Result x b" }, { "name": "formatError", "comment": " Format the error value of a result. If the result is `Ok`, it stays exactly\nthe same, but if the result is an `Err` we will format the error. For example,\nsay the errors we get have too much information:\n\n parseInt : String -> Result ParseError Int\n\n type ParseError =\n { message : String\n , code : Int\n , position : (Int,Int)\n }\n\n formatError .message (parseInt \"123\") == Ok 123\n formatError .message (parseInt \"abc\") == Err \"char 'a' is not a number\"\n", "type": "(error -> error_) -> Result error a -> Result error_ a" }, { "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": "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": "Transform2D", "comment": " A library for performing [2D matrix transformations][affine]. It\nis used primarily with the `groupTransform` function from\n[`Graphics.Collage`](Graphics-Collage) and allows you to do things\nlike rotation, scaling, translation, shearing, and reflection.\n\nNote that all the matrices in this library are 3x3 matrices of homogeneous\ncoordinates, used for [affine transformations][affine]. Since the bottom row as\nalways `0 0 1` in these matrices, it is omitted in the diagrams below.\n\n [affine]: http://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations\n\n# Transforms\n@docs Transform2D, identity, matrix, rotation, translation, scale, scaleX, scaleY\n\n# Multiplication\n@docs multiply\n", "unions": [ { "name": "Transform2D", "comment": " A matrix representing a 2D transformation.\n", "args": [], "cases": [] } ], "aliases": [], "values": [ { "name": "identity", "comment": " Create an identity transform. Transforming by the identity does\nnot change anything, but it can come in handy as a default or\nbase case.\n\n / 1 0 0 \\\n \\ 0 1 0 /\n", "type": "Transform2D" }, { "name": "matrix", "comment": " Create a transformation matrix. This lets you create transforms\nsuch as scales, shears, reflections, and translations.\n\n matrix a b c d x y\n\n / a b x \\\n \\ c d y /\n\nNote that `x` and `y` are the translation values.\n", "type": "Float -> Float -> Float -> Float -> Float -> Float -> Transform2D" }, { "name": "multiply", "comment": " Multiply two transforms together.\n\n multiply m n\n\n / ma mb mx \\ / na nb nx \\\n | mc md my | . | nc nd ny |\n \\ 0 0 1 / \\ 0 0 1 /\n", "type": "Transform2D -> Transform2D -> Transform2D" }, { "name": "rotation", "comment": " Create a [rotation matrix](http://en.wikipedia.org/wiki/Rotation_matrix).\nGiven an angle t, it creates a counterclockwise rotation matrix:\n\n rotation t\n\n / cos t -sin t 0 \\\n \\ sin t cos t 0 /\n", "type": "Float -> Transform2D" }, { "name": "scale", "comment": " Creates a transformation matrix for scaling by a all directions.\n\n scale s\n\n / s 0 0 \\\n \\ 0 s 0 /\n", "type": "Float -> Transform2D" }, { "name": "scaleX", "comment": " Create a transformation for horizontal scaling. ", "type": "Float -> Transform2D" }, { "name": "scaleY", "comment": " Create a transformation for vertical scaling. ", "type": "Float -> Transform2D" }, { "name": "translation", "comment": " Create a transformation matrix for translation.\n\n translation x y\n\n / 1 0 x \\\n \\ 0 1 y /\n", "type": "Float -> Float -> Transform2D" } ], "binops": [] }, { "name": "Bitwise", "comment": " Library for [bitwise operations](http://en.wikipedia.org/wiki/Bitwise_operation).\n\n# Basic Operations\n\n@docs and, or, xor, complement\n\n# Bit Shifts\n\n@docs shiftLeft, shiftRight, shiftRightLogical\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": "shiftLeft", "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 8 `shiftLeft` 1 == 16\n 8 `shiftLeft` 2 == 32\n", "type": "Int -> Int -> Int" }, { "name": "shiftRight", "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 32 `shiftRight` 1 == 16\n 32 `shiftRight` 2 == 8\n -32 `shiftRight` 1 == -16\n\nThis is called an [arithmetic right\nshift](http://en.wikipedia.org/wiki/Bitwise_operation#Arithmetic_shift),\noften written (>>), and sometimes called a sign-propagating\nright shift because it fills empty spots with copies of the highest bit.\n", "type": "Int -> Int -> Int" }, { "name": "shiftRightLogical", "comment": " Shift bits to the right by a given offset, filling new bits with\nzeros.\n\n 32 `shiftRightLogical` 1 == 16\n 32 `shiftRightLogical` 2 == 8\n -32 `shiftRightLogical` 1 == 2147483632\n\nThis is called an [logical right\nshift](http://en.wikipedia.org/wiki/Bitwise_operation#Logical_shift), often written (>>>),\nand sometimes called a zero-fill right shift because it fills empty spots\nwith zeros.\n", "type": "Int -> Int -> Int" }, { "name": "xor", "comment": " Bitwise XOR\n", "type": "Int -> Int -> Int" } ], "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# Tuples\n@docs fst, snd\n\n# Higher-Order Helpers\n@docs identity, always, (<|), (|>), (<<), (>>), flip, curry, uncurry\n\n", "unions": [ { "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 [constant function](http://en.wikipedia.org/wiki/Constant_function),\na function that *always* returns the same value regardless of what input you give.\nIt is defined as:\n\n always a b = a\n\nIt totally ignores the second argument, so `always 42` is a function that always\nreturns 42. When you are dealing with higher-order functions, this comes in\nhandy more often than you might expect. For example, creating a zeroed out list\nof length ten would be:\n\n map (always 0) [0..9]\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": "fst", "comment": " Given a 2-tuple, returns the first value. ", "type": "( a, b ) -> a" }, { "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": "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 7 `rem` 2 == 1\n -1 `rem` 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": "snd", "comment": " Given a 2-tuple, returns the second value. ", "type": "( a, b ) -> b" }, { "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`.\nThis operator short-circuits to `False` if the first argument is `False`.\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": "", "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 parenthesis. 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": "", "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 parenthesis 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`.\nThis operator short-circuits to `True` if the first argument is `True`.\n", "type": "Bool -> Bool -> Bool", "associativity": "right", "precedence": 2 } ] }, { "name": "Trampoline", "comment": " A [trampoline](http://en.wikipedia.org/wiki/Tail-recursive_function#Through_trampolining)\nmakes it possible to recursively call a function without growing the stack.\n\nPopular JavaScript implementations do not perform any tail-call elimination, so\nrecursive functions can cause a stack overflow if they go too deep. Trampolines\npermit unbounded recursion despite limitations in JavaScript.\n\nThis strategy may create many intermediate closures, which is very expensive in\nJavaScript, so use this library only when it is essential that you recurse deeply.\n\n# Trampolines\n@docs trampoline, Trampoline\n", "unions": [ { "name": "Trampoline", "comment": " A way to build computations that may be deeply recursive. We will take an\nexample of a tail-recursive function and rewrite it in a way that lets us use\na trampoline:\n\n length : List a -> Int\n length list = length' 0 list\n\n length' : Int -> List a -> Int\n length' accum list =\n case list of\n [] -> accum\n hd::tl -> length' (accum+1) tl\n\nThis finds the length of a list, but if the list is too long, it may cause a\nstack overflow. We can rewrite it as follows:\n\n length : List a -> Int\n length list = trampoline (length' 0 list)\n\n length' : Int -> List a -> Trampoline Int\n length' accum list =\n case list of\n [] -> Done accum\n hd::tl -> Continue (\\() -> length' (accum+1) tl)\n\nNow it uses a trampoline and can recurse without growing the stack!\n", "args": [ "a" ], "cases": [ [ "Done", [ "a" ] ], [ "Continue", [ "() -> Trampoline a" ] ] ] } ], "aliases": [], "values": [ { "name": "trampoline", "comment": " Evaluate a trampolined value in constant space. ", "type": "Trampoline 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, oneOf, map, map2, map3, map4, map5\n\n# Chaining Maybes\n@docs andThen\n\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 : Maybe a -> (a -> Maybe b) -> Maybe b\n andThen maybe callback =\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 `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": "Maybe a -> (a -> Maybe b) -> 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": "oneOf", "comment": " Pick the first `Maybe` that actually has a value. Useful when you want to\ntry a couple different things, but there is no default value.\n\n oneOf [ Nothing, Just 42, Just 71 ] == Just 42\n oneOf [ Nothing, Nothing, Just 71 ] == Just 71\n oneOf [ Nothing, Nothing, Nothing ] == Nothing\n", "type": "List (Maybe a) -> Maybe a" }, { "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": [] } ]