@liascript/editor 1.1.6--0.15.12 → 1.1.7--0.16.0

package/.elm/0.19.1/packages/elm/url/1.0.0/docs.json

@@ -1 +0,0 @@
-[{"name":"Url","comment":"\n\n# URLs\n@docs Url, Protocol, toString, fromString\n\n# Percent-Encoding\n@docs percentEncode, percentDecode\n\n","unions":[{"name":"Protocol","comment":" Is the URL served over a secure connection or not?\n","args":[],"cases":[["Http",[]],["Https",[]],["File",[]],["File2",[]],["Ipfs",[]],["Ipns",[]],["Dat",[]],["Ftp",[]],["Hyper",[]]]}],"aliases":[{"name":"Url","comment":" In [the URI spec](https://tools.ietf.org/html/rfc3986), Tim Berners-Lee\nsays a URL looks like this:\n\n```\n  https://example.com:8042/over/there?name=ferret#nose\n  \\___/   \\______________/\\_________/ \\_________/ \\__/\n    |            |            |            |        |\n  scheme     authority       path        query   fragment\n```\n\nWhen you are creating a single-page app with [`Browser.fullscreen`][fs], you\nuse the [`Url.Parser`](Url-Parser) module to turn a `Url` into even nicer data.\n\nIf you want to create your own URLs, check out the [`Url.Builder`](Url-Builder)\nmodule as well!\n\n[fs]: /packages/elm/browser/latest/Browser#fullscreen\n\n**Note:** This is a subset of all the full possibilities listed in the URI\nspec. Specifically, it does not accept the `userinfo` segment you see in email\naddresses like `tom@example.com`.\n","args":[],"type":"{ protocol : Url.Protocol, host : String.String, port_ : Maybe.Maybe Basics.Int, path : String.String, query : Maybe.Maybe String.String, fragment : Maybe.Maybe String.String }"}],"values":[{"name":"fromString","comment":" Attempt to break a URL up into [`Url`](#Url). This is useful in\nsingle-page apps when you want to parse certain chunks of a URL to figure out\nwhat to show on screen.\n\n    fromString \"https://example.com:443\"\n    -- Just\n    --   { protocol = Https\n    --   , host = \"example.com\"\n    --   , port_ = Just 443\n    --   , path = \"/\"\n    --   , query = Nothing\n    --   , fragment = Nothing\n    --   }\n\n    fromString \"https://example.com/hats?q=top%20hat\"\n    -- Just\n    --   { protocol = Https\n    --   , host = \"example.com\"\n    --   , port_ = Nothing\n    --   , path = \"/hats\"\n    --   , query = Just \"q=top%20hat\"\n    --   , fragment = Nothing\n    --   }\n\n    fromString \"http://example.com/core/List/#map\"\n    -- Just\n    --   { protocol = Http\n    --   , host = \"example.com\"\n    --   , port_ = Nothing\n    --   , path = \"/core/List/\"\n    --   , query = Nothing\n    --   , fragment = Just \"map\"\n    --   }\n\nThe conversion to segments can fail in some cases as well:\n\n    fromString \"example.com:443\"        == Nothing  -- no protocol\n    fromString \"http://tom@example.com\" == Nothing  -- userinfo disallowed\n    fromString \"http://#cats\"           == Nothing  -- no host\n\n**Note:** This function does not use [`percentDecode`](#percentDecode) anything.\nIt just splits things up. [`Url.Parser`](Url-Parser) actually _needs_ the raw\n`query` string to parse it properly. Otherwise it could get confused about `=`\nand `&` characters!\n","type":"String.String -> Maybe.Maybe Url.Url"},{"name":"percentDecode","comment":" **Use [Url.Parser](Url-Parser) instead!** It will decode query\nparameters appropriately already! `percentDecode` is only available so that\nextremely custom cases are possible, if needed.\n\nCheck out the `percentEncode` function to learn about percent-encoding.\nThis function does the opposite! Here are the reverse examples:\n\n    -- ASCII\n    percentDecode \"99%25\"     == Just \"hat\"\n    percentDecode \"to%20be\"   == Just \"to be\"\n    percentDecode \"hat\"       == Just \"99%\"\n\n    -- UTF-8\n    percentDecode \"%24\"       == Just \"$\"\n    percentDecode \"%C2%A2\"    == Just \"¢\"\n    percentDecode \"%E2%82%AC\" == Just \"€\"\n\nWhy is it a `Maybe` though? Well, these strings come from strangers on the\ninternet as a bunch of bits and may have encoding problems. For example:\n\n    percentDecode \"%\"   == Nothing  -- not followed by two hex digits\n    percentDecode \"%XY\" == Nothing  -- not followed by two HEX digits\n    percentDecode \"%C2\" == Nothing  -- half of the \"¢\" encoding \"%C2%A2\"\n\nThis is the same behavior as JavaScript's [`decodeURIComponent`][js] function.\n\n[js]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent\n","type":"String.String -> Maybe.Maybe String.String"},{"name":"percentEncode","comment":" **Use [Url.Builder](Url-Builder) instead!** Functions like `absolute`,\n`relative`, and `crossOrigin` already do this automatically! `percentEncode`\nis only available so that extremely custom cases are possible, if needed.\n\nPercent-encoding is how [the official URI spec][uri] “escapes” special\ncharacters. You can still represent a `?` even though it is reserved for\nqueries.\n\nThis function exists in case you want to do something extra custom. Here are\nsome examples:\n\n    -- standard ASCII encoding\n    percentEncode \"hat\"   == \"hat\"\n    percentEncode \"to be\" == \"to%20be\"\n    percentEncode \"99%\"   == \"99%25\"\n\n    -- non-standard, but widely accepted, UTF-8 encoding\n    percentEncode \"$\" == \"%24\"\n    percentEncode \"¢\" == \"%C2%A2\"\n    percentEncode \"€\" == \"%E2%82%AC\"\n\nThis is the same behavior as JavaScript's [`encodeURIComponent`][js] function,\nand the rules are described in more detail officially [here][s2] and with some\nnotes about Unicode [here][wiki].\n\n[js]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent\n[uri]: https://tools.ietf.org/html/rfc3986\n[s2]: https://tools.ietf.org/html/rfc3986#section-2.1\n[wiki]: https://en.wikipedia.org/wiki/Percent-encoding\n","type":"String.String -> String.String"},{"name":"toString","comment":" Turn a [`Url`](#Url) into a `String`.\n","type":"Url.Url -> String.String"}],"binops":[]},{"name":"Url.Builder","comment":" In [the URI spec](https://tools.ietf.org/html/rfc3986), Tim Berners-Lee\nsays a URL looks like this:\n\n```\n  https://example.com:8042/over/there?name=ferret#nose\n  \\___/   \\______________/\\_________/ \\_________/ \\__/\n    |            |            |            |        |\n  scheme     authority       path        query   fragment\n```\n\nThis module helps you create these!\n\n\n# Builders\n@docs absolute, relative, crossOrigin, custom, Root\n\n# Queries\n@docs QueryParameter, string, int, toQuery\n\n","unions":[{"name":"QueryParameter","comment":" Represents query parameter. Builder functions like `absolute` percent-encode\nall the query parameters they get, so you do not need to worry about it!\n","args":[],"cases":[]},{"name":"Root","comment":" Specify whether a [`custom`](#custom) URL is absolute, relative, or\ncross-origin.\n","args":[],"cases":[["Absolute",[]],["Relative",[]],["CrossOrigin",["String.String"]]]}],"aliases":[],"values":[{"name":"absolute","comment":" Create an absolute URL:\n\n    absolute [] []\n    -- \"/\"\n\n    absolute [ \"packages\", \"elm\", \"core\" ] []\n    -- \"/packages/elm/core\"\n\n    absolute [ \"blog\", String.fromInt 42 ] []\n    -- \"/blog/42\"\n\n    absolute [ \"products\" ] [ string \"search\" \"hat\", int \"page\" 2 ]\n    -- \"/products?search=hat&page=2\"\n\nNotice that the URLs start with a slash!\n","type":"List.List String.String -> List.List Url.Builder.QueryParameter -> String.String"},{"name":"crossOrigin","comment":" Create a cross-origin URL.\n\n    crossOrigin \"https://example.com\" [ \"products\" ] []\n    -- \"https://example.com/products\"\n\n    crossOrigin \"https://example.com\" [] []\n    -- \"https://example.com/\"\n\n    crossOrigin\n      \"https://example.com:8042\"\n      [ \"over\", \"there\" ]\n      [ string \"name\" \"ferret\" ]\n    -- \"https://example.com:8042/over/there?name=ferret\"\n\n**Note:** Cross-origin requests are slightly restricted for security.\nFor example, the [same-origin policy][sop] applies when sending HTTP requests,\nso the appropriate `Access-Control-Allow-Origin` header must be enabled on the\n*server* to get things working. Read more about the security rules [here][cors].\n\n[sop]: https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy\n[cors]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS\n","type":"String.String -> List.List String.String -> List.List Url.Builder.QueryParameter -> String.String"},{"name":"custom","comment":" Create custom URLs that may have a hash on the end:\n\n    custom Absolute\n      [ \"packages\", \"elm\", \"core\", \"latest\", \"String\" ]\n      []\n      (Just \"length\")\n    -- \"/packages/elm/core/latest/String#length\"\n\n    custom Relative [ \"there\" ] [ string \"name\" \"ferret\" ] Nothing\n    -- \"there?name=ferret\"\n\n    custom\n      (CrossOrigin \"https://example.com:8042\")\n      [ \"over\", \"there\" ]\n      [ string \"name\" \"ferret\" ]\n      (Just \"nose\")\n    -- \"https://example.com:8042/over/there?name=ferret#nose\"\n","type":"Url.Builder.Root -> List.List String.String -> List.List Url.Builder.QueryParameter -> Maybe.Maybe String.String -> String.String"},{"name":"int","comment":" Create a percent-encoded query parameter.\n\n    absolute [\"products\"] [ string \"search\" \"hat\", int \"page\" 2 ]\n    -- \"/products?search=hat&page=2\"\n\nWriting `int key n` is the same as writing `string key (String.fromInt n)`.\nSo this is just a convenience function, making your code a bit shorter!\n","type":"String.String -> Basics.Int -> Url.Builder.QueryParameter"},{"name":"relative","comment":" Create a relative URL:\n\n    relative [] []\n    -- \"\"\n\n    relative [ \"elm\", \"core\" ] []\n    -- \"elm/core\"\n\n    relative [ \"blog\", String.fromInt 42 ] []\n    -- \"blog/42\"\n\n    relative [ \"products\" ] [ string \"search\" \"hat\", int \"page\" 2 ]\n    -- \"products?search=hat&page=2\"\n\nNotice that the URLs **do not** start with a slash!\n","type":"List.List String.String -> List.List Url.Builder.QueryParameter -> String.String"},{"name":"string","comment":" Create a percent-encoded query parameter.\n\n    absolute [\"products\"] [ string \"search\" \"hat\" ]\n    -- \"/products?search=hat\"\n\n    absolute [\"products\"] [ string \"search\" \"coffee table\" ]\n    -- \"/products?search=coffee%20table\"\n","type":"String.String -> String.String -> Url.Builder.QueryParameter"},{"name":"toQuery","comment":" Convert a list of query parameters to a percent-encoded query. This\nfunction is used by `absolute`, `relative`, etc.\n\n    toQuery [ string \"search\" \"hat\" ]\n    -- \"?search=hat\"\n\n    toQuery [ string \"search\" \"coffee table\" ]\n    -- \"?search=coffee%20table\"\n\n    toQuery [ string \"search\" \"hat\", int \"page\" 2 ]\n    -- \"?search=hat&page=2\"\n\n    toQuery []\n    -- \"\"\n","type":"List.List Url.Builder.QueryParameter -> String.String"}],"binops":[]},{"name":"Url.Parser","comment":" In [the URI spec](https://tools.ietf.org/html/rfc3986), Tim Berners-Lee\nsays a URL looks like this:\n\n```\n  https://example.com:8042/over/there?name=ferret#nose\n  \\___/   \\______________/\\_________/ \\_________/ \\__/\n    |            |            |            |        |\n  scheme     authority       path        query   fragment\n```\n\nThis module is primarily for parsing the `path` part.\n\n\n# Primitives\n@docs Parser, string, int, s\n\n# Path\n@docs (</>), map, oneOf, top, custom\n\n# Query\n@docs (<?>), query\n\n# Fragment\n@docs fragment\n\n# Run Parsers\n@docs parse\n\n","unions":[{"name":"Parser","comment":" Turn URLs like `/blog/42/cat-herding-techniques` into nice Elm data.\n","args":["a","b"],"cases":[]}],"aliases":[],"values":[{"name":"custom","comment":" Create a custom path segment parser. Here is how it is used to define the\n`int` parser:\n\n    int : Parser (Int -> a) a\n    int =\n      custom \"NUMBER\" String.toInt\n\nYou can use it to define something like “only CSS files” like this:\n\n    css : Parser (String -> a) a\n    css =\n      custom \"CSS_FILE\" <| \\segment ->\n        if String.endsWith \".css\" segment then\n          Just segment\n        else\n          Nothing\n","type":"String.String -> (String.String -> Maybe.Maybe a) -> Url.Parser.Parser (a -> b) b"},{"name":"fragment","comment":" Create a parser for the URL fragment, the stuff after the `#`. This can\nbe handy for handling links to DOM elements within a page. Pages like this one!\n\n    type alias Docs =\n      (String, Maybe String)\n\n    docs : Parser (Docs -> a) a\n    docs =\n      map Tuple.pair (string </> fragment identity)\n\n    -- /List/map   ==>  Nothing\n    -- /List/#map  ==>  Just (\"List\", Just \"map\")\n    -- /List#map   ==>  Just (\"List\", Just \"map\")\n    -- /List#      ==>  Just (\"List\", Just \"\")\n    -- /List       ==>  Just (\"List\", Nothing)\n    -- /           ==>  Nothing\n\n","type":"(Maybe.Maybe String.String -> fragment) -> Url.Parser.Parser (fragment -> a) a"},{"name":"int","comment":" Parse a segment of the path as an `Int`.\n\n    -- /alice/  ==>  Nothing\n    -- /bob     ==>  Nothing\n    -- /42/     ==>  Just 42\n    -- /        ==>  Nothing\n","type":"Url.Parser.Parser (Basics.Int -> a) a"},{"name":"map","comment":" Transform a path parser.\n\n    type alias Comment = { user : String, id : Int }\n\n    userAndId : Parser (String -> Int -> a) a\n    userAndId =\n      s \"user\" </> string </> s \"comment\" </> int\n\n    comment : Parser (Comment -> a) a\n    comment =\n      map Comment userAndId\n\n    -- /user/bob/comment/42  ==>  Just { user = \"bob\", id = 42 }\n    -- /user/tom/comment/35  ==>  Just { user = \"tom\", id = 35 }\n    -- /user/sam/             ==>  Nothing\n","type":"a -> Url.Parser.Parser a b -> Url.Parser.Parser (b -> c) c"},{"name":"oneOf","comment":" Try a bunch of different path parsers.\n\n    type Route\n      = Topic String\n      | Blog Int\n      | User String\n      | Comment String Int\n\n    route : Parser (Route -> a) a\n    route =\n      oneOf\n        [ map Topic   (s \"topic\" </> string)\n        , map Blog    (s \"blog\" </> int)\n        , map User    (s \"user\" </> string)\n        , map Comment (s \"user\" </> string </> s \"comment\" </> int)\n        ]\n\n    -- /topic/wolf           ==>  Just (Topic \"wolf\")\n    -- /topic/               ==>  Nothing\n\n    -- /blog/42               ==>  Just (Blog 42)\n    -- /blog/wolf             ==>  Nothing\n\n    -- /user/sam/             ==>  Just (User \"sam\")\n    -- /user/bob/comment/42  ==>  Just (Comment \"bob\" 42)\n    -- /user/tom/comment/35  ==>  Just (Comment \"tom\" 35)\n    -- /user/                 ==>  Nothing\n\nIf there are multiple parsers that could succeed, the first one wins.\n","type":"List.List (Url.Parser.Parser a b) -> Url.Parser.Parser a b"},{"name":"parse","comment":" Actually run a parser! You provide some [`Url`](Url#Url) that\nrepresent a valid URL. From there `parse` runs your parser on the path, query\nparameters, and fragment.\n\n    import Url\n    import Url.Parser exposing (Parser, parse, int, map, oneOf, s, top)\n\n    type Route = Home | Blog Int | NotFound\n\n    route : Parser (Route -> a) a\n    route =\n      oneOf\n        [ map Home top\n        , map Blog (s \"blog\" </> int)\n        ]\n\n    toRoute : String -> Route\n    toRoute string =\n      case Url.fromString string of\n        Nothing ->\n          NotFound\n\n        Just url ->\n          Maybe.withDefault NotFound (parse route url)\n\n    -- toRoute \"/blog/42\"                            ==  NotFound\n    -- toRoute \"https://example.com/\"                ==  Home\n    -- toRoute \"https://example.com/blog\"            ==  NotFound\n    -- toRoute \"https://example.com/blog/42\"         ==  Blog 42\n    -- toRoute \"https://example.com/blog/42/\"        ==  Blog 42\n    -- toRoute \"https://example.com/blog/42#wolf\"    ==  Blog 42\n    -- toRoute \"https://example.com/blog/42?q=wolf\"  ==  Blog 42\n    -- toRoute \"https://example.com/settings\"        ==  NotFound\n\nFunctions like `toRoute` are useful when creating single-page apps with\n[`Browser.fullscreen`][fs]. I use them in `init` and `onNavigation` to handle\nthe initial URL and any changes.\n\n[fs]: /packages/elm/browser/latest/Browser#fullscreen\n","type":"Url.Parser.Parser (a -> a) a -> Url.Url -> Maybe.Maybe a"},{"name":"query","comment":" The [`Url.Parser.Query`](Url-Parser-Query) module defines its own\n[`Parser`](Url-Parser-Query#Parser) type. This function is a helper to convert\nthose into normal parsers.\n\n    import Url.Parser.Query as Query\n\n    -- the following expressions are both the same!\n    --\n    -- s \"blog\" <?> Query.string \"search\"\n    -- s \"blog\" </> query (Query.string \"search\")\n\nThis may be handy if you need query parameters but are not parsing any path\nsegments.\n","type":"Url.Parser.Query.Parser query -> Url.Parser.Parser (query -> a) a"},{"name":"s","comment":" Parse a segment of the path if it matches a given string. It is almost\nalways used with [`</>`](#</>) or [`oneOf`](#oneOf). For example:\n\n    blog : Parser (Int -> a) a\n    blog =\n      s \"blog\" </> int\n\n    -- /blog/42  ==>  Just 42\n    -- /tree/42  ==>  Nothing\n\nThe path segment must be an exact match!\n","type":"String.String -> Url.Parser.Parser a a"},{"name":"string","comment":" Parse a segment of the path as a `String`.\n\n    -- /alice/  ==>  Just \"alice\"\n    -- /bob     ==>  Just \"bob\"\n    -- /42/     ==>  Just \"42\"\n    -- /        ==>  Nothing\n","type":"Url.Parser.Parser (String.String -> a) a"},{"name":"top","comment":" A parser that does not consume any path segments.\n\n    type Route = Overview | Post Int\n\n    blog : Parser (BlogRoute -> a) a\n    blog =\n      s \"blog\" </>\n        oneOf\n          [ map Overview top\n          , map Post (s \"post\" </> int)\n          ]\n\n    -- /blog/         ==>  Just Overview\n    -- /blog/post/42  ==>  Just (Post 42)\n","type":"Url.Parser.Parser a a"}],"binops":[{"name":"</>","comment":" Parse a path with multiple segments.\n\n    blog : Parser (Int -> a) a\n    blog =\n      s \"blog\" </> int\n\n    -- /blog/35/  ==>  Just 35\n    -- /blog/42   ==>  Just 42\n    -- /blog/     ==>  Nothing\n    -- /42/       ==>  Nothing\n\n    search : Parser (String -> a) a\n    search =\n      s \"search\" </> string\n\n    -- /search/wolf/  ==>  Just \"wolf\"\n    -- /search/frog   ==>  Just \"frog\"\n    -- /search/       ==>  Nothing\n    -- /wolf/         ==>  Nothing\n","type":"Url.Parser.Parser a b -> Url.Parser.Parser b c -> Url.Parser.Parser a c","associativity":"right","precedence":7},{"name":"<?>","comment":" The [`Url.Parser.Query`](Url-Parser-Query) module defines its own\n[`Parser`](Url-Parser-Query#Parser) type. This function helps you use those\nwith normal parsers. For example, maybe you want to add a search feature to\nyour blog website:\n\n    import Url.Parser.Query as Query\n\n    type Route\n      = Overview (Maybe String)\n      | Post Int\n\n    blog : Parser (Route -> a) a\n    blog =\n      oneOf\n        [ map Overview (s \"blog\" <?> Query.string \"q\")\n        , map Post (s \"blog\" </> int)\n        ]\n\n    -- /blog/           ==>  Just (Overview Nothing)\n    -- /blog/?q=wolf    ==>  Just (Overview (Just \"wolf\"))\n    -- /blog/wolf       ==>  Nothing\n    -- /blog/42         ==>  Just (Post 42)\n    -- /blog/42?q=wolf  ==>  Just (Post 42)\n    -- /blog/42/wolf    ==>  Nothing\n","type":"Url.Parser.Parser a (query -> b) -> Url.Parser.Query.Parser query -> Url.Parser.Parser a b","associativity":"left","precedence":8}]},{"name":"Url.Parser.Query","comment":" In [the URI spec](https://tools.ietf.org/html/rfc3986), Tim Berners-Lee\nsays a URL looks like this:\n\n```\n  https://example.com:8042/over/there?name=ferret#nose\n  \\___/   \\______________/\\_________/ \\_________/ \\__/\n    |            |            |            |        |\n  scheme     authority       path        query   fragment\n```\n\nThis module is for parsing the `query` part.\n\nIn this library, a valid query looks like `?search=hats&page=2` where each\nquery parameter has the format `key=value` and is separated from the next\nparameter by the `&` character.\n\n# Parse Query Parameters\n@docs Parser, string, int, enum, custom\n\n# Mapping\n@docs map, map2, map3, map4, map5, map6, map7, map8\n\n","unions":[],"aliases":[{"name":"Parser","comment":" Parse a query like `?search=hat&page=2` into nice Elm data.\n","args":["a"],"type":"Url.Parser.Internal.QueryParser a"}],"values":[{"name":"custom","comment":" Create a custom query parser. The [`string`](#string), [`int`](#int), and\n[`enum`](#enum) parsers are defined using this function. It can help you handle\nanything though!\n\nSay you are unlucky enough to need to handle `?post=2&post=7` to show a couple\nposts on screen at once. You could say:\n\n    posts : Parser (Maybe (List Int))\n    posts =\n      custom \"post\" (List.maybeMap String.toInt)\n\n    -- ?post=2        == [2]\n    -- ?post=2&post=7 == [2, 7]\n    -- ?post=2&post=x == [2]\n    -- ?hats=2        == []\n","type":"String.String -> (List.List String.String -> a) -> Url.Parser.Query.Parser a"},{"name":"enum","comment":" Handle enumerated parameters. Maybe you want a true-or-false parameter:\n\n    import Dict\n\n    debug : Parser (Maybe Bool)\n    debug =\n      enum \"debug\" (Dict.fromList [ (\"true\", True), (\"false\", False) ])\n\n    -- ?debug=true            == Just True\n    -- ?debug=false           == Just False\n    -- ?debug=1               == Nothing\n    -- ?debug=0               == Nothing\n    -- ?true=true             == Nothing\n    -- ?debug=true&debug=true == Nothing\n\nYou could add `0` and `1` to the dictionary if you want to handle those as\nwell. You can also use [`map`](#map) to say `map (Result.withDefault False) debug`\nto get a parser of type `Parser Bool` that swallows any errors and defaults to\n`False`.\n\n**Note:** Parameters like `?debug` with no `=` are not supported by this library.\n","type":"String.String -> Dict.Dict String.String a -> Url.Parser.Query.Parser (Maybe.Maybe a)"},{"name":"int","comment":" Handle `Int` parameters. Maybe you want to show paginated search results:\n\n    page : Parser (Maybe Int)\n    page =\n      int \"page\"\n\n    -- ?page=2        == Just 2\n    -- ?page=17       == Just 17\n    -- ?page=two      == Nothing\n    -- ?sort=date     == Nothing\n    -- ?page=2&page=3 == Nothing\n\nCheck out [`custom`](#custom) if you need to handle multiple `page` parameters\nor something like that.\n","type":"String.String -> Url.Parser.Query.Parser (Maybe.Maybe Basics.Int)"},{"name":"map","comment":" Transform a parser in some way. Maybe you want your `page` query parser to\ndefault to `1` if there is any problem?\n\n    page : Parser Int\n    page =\n      map (Result.withDefault 1) (int \"page\")\n\n","type":"(a -> b) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b"},{"name":"map2","comment":" Combine two parsers. A query like `?search=hats&page=2` could be parsed\nwith something like this:\n\n    type alias Query =\n      { search : Maybe String\n      , page : Maybe Int\n      }\n\n    query : Parser Query\n    query =\n      map2 Query (string \"search\") (int \"page\")\n\n","type":"(a -> b -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser result"},{"name":"map3","comment":" Combine three parsers. A query like `?search=hats&page=2&sort=ascending`\ncould be parsed with something like this:\n\n    import Dict\n\n    type alias Query =\n      { search : Maybe String\n      , page : Maybe Int\n      , sort : Maybe Order\n      }\n\n    type Order = Ascending | Descending\n\n    query : Parser Query\n    query =\n      map3 Query (string \"search\") (int \"page\") (enum \"sort\" order)\n\n    order : Dict.Dict String Order\n    order =\n      Dict.fromList\n        [ ( \"ascending\", Ascending )\n        , ( \"descending\", Descending )\n        ]\n","type":"(a -> b -> c -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser c -> Url.Parser.Query.Parser result"},{"name":"map4","comment":"","type":"(a -> b -> c -> d -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser c -> Url.Parser.Query.Parser d -> Url.Parser.Query.Parser result"},{"name":"map5","comment":"","type":"(a -> b -> c -> d -> e -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser c -> Url.Parser.Query.Parser d -> Url.Parser.Query.Parser e -> Url.Parser.Query.Parser result"},{"name":"map6","comment":"","type":"(a -> b -> c -> d -> e -> f -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser c -> Url.Parser.Query.Parser d -> Url.Parser.Query.Parser e -> Url.Parser.Query.Parser f -> Url.Parser.Query.Parser result"},{"name":"map7","comment":"","type":"(a -> b -> c -> d -> e -> f -> g -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser c -> Url.Parser.Query.Parser d -> Url.Parser.Query.Parser e -> Url.Parser.Query.Parser f -> Url.Parser.Query.Parser g -> Url.Parser.Query.Parser result"},{"name":"map8","comment":" If you need higher than eight, you can define a function like this:\n\n    apply : Parser a -> Parser (a -> b) -> Parser b\n    apply argParser funcParser =\n      map2 (<|) funcParser argParser\n\nAnd then you can chain it to do as many of these as you would like:\n\n    map func (string \"search\")\n      |> apply (int \"page\")\n      |> apply (int \"per-page\")\n\n","type":"(a -> b -> c -> d -> e -> f -> g -> h -> result) -> Url.Parser.Query.Parser a -> Url.Parser.Query.Parser b -> Url.Parser.Query.Parser c -> Url.Parser.Query.Parser d -> Url.Parser.Query.Parser e -> Url.Parser.Query.Parser f -> Url.Parser.Query.Parser g -> Url.Parser.Query.Parser h -> Url.Parser.Query.Parser result"},{"name":"string","comment":" Handle `String` parameters.\n\n    search : Parser (Maybe String)\n    search =\n      string \"search\"\n\n    -- ?search=cats             == Just \"cats\"\n    -- ?search=42               == Just \"42\"\n    -- ?branch=left             == Nothing\n    -- ?search=cats&search=dogs == Nothing\n\nCheck out [`custom`](#custom) if you need to handle multiple `search`\nparameters for some reason.\n","type":"String.String -> Url.Parser.Query.Parser (Maybe.Maybe String.String)"}],"binops":[]}]

package/.elm/0.19.1/packages/elm/virtual-dom/1.0.3/LICENSE

@@ -1,30 +0,0 @@
-Copyright (c) 2016-present, Evan Czaplicki
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * Neither the name of Evan Czaplicki nor the names of other
-      contributors may be used to endorse or promote products derived
-      from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/.elm/0.19.1/packages/elm/virtual-dom/1.0.3/README.md

@@ -1,5 +0,0 @@
-# Virtual DOM for Elm
-
-A virtual DOM implementation that backs Elm's core libraries for [HTML](https://package.elm-lang.org/packages/elm/html/latest/) and [SVG](https://package.elm-lang.org/packages/elm/svg/latest/). You should almost certainly use those higher-level libraries directly.
-
-It is pretty fast! You can read about that [here](https://elm-lang.org/blog/blazing-fast-html-round-two).

package/.elm/0.19.1/packages/elm/virtual-dom/1.0.3/docs.json

@@ -1 +0,0 @@
-[{"name":"VirtualDom","comment":" API to the core diffing algorithm. Can serve as a foundation for libraries\nthat expose more helper functions for HTML or SVG.\n\n# Create\n@docs Node, text, node, nodeNS\n\n# Attributes\n@docs Attribute, style, property, attribute, attributeNS\n\n# Events\n@docs on, Handler\n\n# Routing Messages\n@docs map, mapAttribute\n\n# Keyed Nodes\n@docs keyedNode, keyedNodeNS\n\n# Lazy Nodes\n@docs lazy, lazy2, lazy3, lazy4, lazy5, lazy6, lazy7, lazy8\n\n","unions":[{"name":"Attribute","comment":" When using HTML and JS, there are two ways to specify parts of a DOM node.\n\n  1. Attributes &mdash; You can set things in HTML itself. So the `class`\n     in `<div class=\"greeting\"></div>` is called an *attribute*.\n\n  2. Properties &mdash; You can also set things in JS. So the `className`\n     in `div.className = 'greeting'` is called a *property*.\n\nSo the `class` attribute corresponds to the `className` property. At first\nglance, perhaps this distinction is defensible, but it gets much crazier.\n*There is not always a one-to-one mapping between attributes and properties!*\nYes, that is a true fact. Sometimes an attribute exists, but there is no\ncorresponding property. Sometimes changing an attribute does not change the\nunderlying property. For example, as of this writing, the `webkit-playsinline`\nattribute can be used in HTML, but there is no corresponding property!\n","args":["msg"],"cases":[]},{"name":"Handler","comment":" When using `on` you can customize the event behavior\na bit. There are two ways to do this:\n\n  - [`stopPropagation`][sp] means the event stops traveling through the DOM.\n  So if propagation of a click is stopped, it will not trigger any other event\n  listeners.\n\n  - [`preventDefault`][pd] means any built-in browser behavior related to the\n  event is prevented. This can be handy with key presses or touch gestures.\n\n**Note 1:** A [passive][] event listener will be created if you use `Normal`\nor `MayStopPropagation`. In both cases `preventDefault` cannot be used, so\nwe can enable optimizations for touch, scroll, and wheel events in some\nbrowsers.\n\n**Note 2:** Some actions, like uploading and downloading files, are only\nallowed when the JavaScript event loop is running because of user input. This\nis for security! So when an event occurs, we call `update` and send any `port`\nmessages immediately, all within the same tick of the event loop. This makes\nit possible to handle user-instigated events in ports.\n\n**Note 3:** Normally the `view` is shown in the next `requestAnimationFrame`\ncall. This allows us to save some work if messages are coming in very quickly.\nBut if `stopPropagation` is used, we update the DOM immediately, within the\nsame tick of the event loop. This is useful for DOM nodes that hold their own\nstate, like `<input type=\"text\">`. If someone types very fast, the state in the\nDOM can diverge from the state in your `Model` while waiting on the next\n`requestAnimationFrame` call. So updating the DOM synchronously makes this\ndivergence impossible.\n\n[sp]: https://developer.mozilla.org/en-US/docs/Web/API/Event/stopPropagation\n[pd]: https://developer.mozilla.org/en-US/docs/Web/API/Event/preventDefault\n[passive]: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md\n","args":["msg"],"cases":[["Normal",["Json.Decode.Decoder msg"]],["MayStopPropagation",["Json.Decode.Decoder ( msg, Basics.Bool )"]],["MayPreventDefault",["Json.Decode.Decoder ( msg, Basics.Bool )"]],["Custom",["Json.Decode.Decoder { message : msg, stopPropagation : Basics.Bool, preventDefault : Basics.Bool }"]]]},{"name":"Node","comment":" An immutable chunk of data representing a DOM node. This can be HTML or SVG.\n","args":["msg"],"cases":[]}],"aliases":[],"values":[{"name":"attribute","comment":" Create an attribute. This uses JavaScript’s `setAttribute` function\nbehind the scenes.\n\n    buttonLabel : Node msg\n    buttonLabel =\n      node \"label\" [ attribute \"for\" \"button\" ] [ text \"Label\" ]\n\nNotice that you must give the *attribute* name, so we use `for` as it would\nbe in HTML, not `htmlFor` as it would appear in JS.\n","type":"String.String -> String.String -> VirtualDom.Attribute msg"},{"name":"attributeNS","comment":" Would you believe that there is another way to do this?! This uses\nJavaScript's `setAttributeNS` function behind the scenes. It is doing pretty\nmuch the same thing as `attribute` but you are able to have namespaced\nattributes. As an example, the `elm/svg` package defines an attribute\nlike this:\n\n    xlinkHref : String -> Attribute msg\n    xlinkHref value =\n      attributeNS \"http://www.w3.org/1999/xlink\" \"xlink:href\" value\n","type":"String.String -> String.String -> String.String -> VirtualDom.Attribute msg"},{"name":"keyedNode","comment":" Works just like `node`, but you add a unique identifier to each child\nnode. You want this when you have a list of nodes that is changing: adding\nnodes, removing nodes, etc. In these cases, the unique identifiers help make\nthe DOM modifications more efficient.\n","type":"String.String -> List.List (VirtualDom.Attribute msg) -> List.List ( String.String, VirtualDom.Node msg ) -> VirtualDom.Node msg"},{"name":"keyedNodeNS","comment":" Create a keyed and namespaced DOM node. For example, an SVG `<g>` node\ncould be defined like this:\n\n    g : List (Attribute msg) -> List ( String, Node msg ) -> Node msg\n    g =\n      keyedNodeNS \"http://www.w3.org/2000/svg\" \"g\"\n","type":"String.String -> String.String -> List.List (VirtualDom.Attribute msg) -> List.List ( String.String, VirtualDom.Node msg ) -> VirtualDom.Node msg"},{"name":"lazy","comment":" A performance optimization that delays the building of virtual DOM nodes.\n\nCalling `(view model)` will definitely build some virtual DOM, perhaps a lot of\nit. Calling `(lazy view model)` delays the call until later. During diffing, we\ncan check to see if `model` is referentially equal to the previous value used,\nand if so, we just stop. No need to build up the tree structure and diff it,\nwe know if the input to `view` is the same, the output must be the same!\n","type":"(a -> VirtualDom.Node msg) -> a -> VirtualDom.Node msg"},{"name":"lazy2","comment":" Same as `lazy` but checks on two arguments.\n","type":"(a -> b -> VirtualDom.Node msg) -> a -> b -> VirtualDom.Node msg"},{"name":"lazy3","comment":" Same as `lazy` but checks on three arguments.\n","type":"(a -> b -> c -> VirtualDom.Node msg) -> a -> b -> c -> VirtualDom.Node msg"},{"name":"lazy4","comment":" Same as `lazy` but checks on four arguments.\n","type":"(a -> b -> c -> d -> VirtualDom.Node msg) -> a -> b -> c -> d -> VirtualDom.Node msg"},{"name":"lazy5","comment":" Same as `lazy` but checks on five arguments.\n","type":"(a -> b -> c -> d -> e -> VirtualDom.Node msg) -> a -> b -> c -> d -> e -> VirtualDom.Node msg"},{"name":"lazy6","comment":" Same as `lazy` but checks on six arguments.\n","type":"(a -> b -> c -> d -> e -> f -> VirtualDom.Node msg) -> a -> b -> c -> d -> e -> f -> VirtualDom.Node msg"},{"name":"lazy7","comment":" Same as `lazy` but checks on seven arguments.\n","type":"(a -> b -> c -> d -> e -> f -> g -> VirtualDom.Node msg) -> a -> b -> c -> d -> e -> f -> g -> VirtualDom.Node msg"},{"name":"lazy8","comment":" Same as `lazy` but checks on eight arguments.\n","type":"(a -> b -> c -> d -> e -> f -> g -> h -> VirtualDom.Node msg) -> a -> b -> c -> d -> e -> f -> g -> h -> VirtualDom.Node msg"},{"name":"map","comment":" This function is useful when nesting components with [the Elm\nArchitecture](https://github.com/evancz/elm-architecture-tutorial/). It lets\nyou transform the messages produced by a subtree.\n\nSay you have a node named `button` that produces `()` values when it is\nclicked. To get your model updating properly, you will probably want to tag\nthis `()` value like this:\n\n    type Msg = Click | ...\n\n    update msg model =\n      case msg of\n        Click ->\n          ...\n\n    view model =\n      map (\\_ -> Click) button\n\nSo now all the events produced by `button` will be transformed to be of type\n`Msg` so they can be handled by your update function!\n","type":"(a -> msg) -> VirtualDom.Node a -> VirtualDom.Node msg"},{"name":"mapAttribute","comment":" Transform the messages produced by a `Attribute`.\n","type":"(a -> b) -> VirtualDom.Attribute a -> VirtualDom.Attribute b"},{"name":"node","comment":" Create a DOM node with a tag name, a list of HTML properties that can\ninclude styles and event listeners, a list of CSS properties like `color`, and\na list of child nodes.\n\n    import Json.Encode as Json\n\n    hello : Node msg\n    hello =\n      node \"div\" [] [ text \"Hello!\" ]\n\n    greeting : Node msg\n    greeting =\n      node \"div\"\n        [ property \"id\" (Json.string \"greeting\") ]\n        [ text \"Hello!\" ]\n","type":"String.String -> List.List (VirtualDom.Attribute msg) -> List.List (VirtualDom.Node msg) -> VirtualDom.Node msg"},{"name":"nodeNS","comment":" Create a namespaced DOM node. For example, an SVG `<path>` node could be\ndefined like this:\n\n    path : List (Attribute msg) -> List (Node msg) -> Node msg\n    path attrubutes children =\n      nodeNS \"http://www.w3.org/2000/svg\" \"path\" attributes children\n","type":"String.String -> String.String -> List.List (VirtualDom.Attribute msg) -> List.List (VirtualDom.Node msg) -> VirtualDom.Node msg"},{"name":"on","comment":" Create custom event handlers.\n\nYou can define `onClick` like this:\n\n    import Json.Decode as Decode\n\n    onClick : msg -> Attribute msg\n    onClick msg =\n      on \"click\" (Normal (Decode.succeed msg))\n\n**Note:** These event handlers trigger in the bubble phase. You can learn more\nabout what that means [here][]. There is not support within Elm for doing\ntricks with the capture phase. We recommend doing that in JS through ports.\n\n[here]: https://github.com/elm/virtual-dom/blob/master/hints/capture-vs-bubble.md\n","type":"String.String -> VirtualDom.Handler msg -> VirtualDom.Attribute msg"},{"name":"property","comment":" Create a property.\n\n    import Json.Encode as Encode\n\n    buttonLabel : Node msg\n    buttonLabel =\n      node \"label\" [ property \"htmlFor\" (Encode.string \"button\") ] [ text \"Label\" ]\n\nNotice that you must give the *property* name, so we use `htmlFor` as it\nwould be in JavaScript, not `for` as it would appear in HTML.\n","type":"String.String -> Json.Decode.Value -> VirtualDom.Attribute msg"},{"name":"style","comment":" Specify a style.\n\n    greeting : Node msg\n    greeting =\n      node \"div\"\n        [ style \"backgroundColor\" \"red\"\n        , style \"height\" \"90px\"\n        , style \"width\" \"100%\"\n        ]\n        [ text \"Hello!\"\n        ]\n\n","type":"String.String -> String.String -> VirtualDom.Attribute msg"},{"name":"text","comment":" Just put plain text in the DOM. It will escape the string so that it appears\nexactly as you specify.\n\n    text \"Hello World!\"\n","type":"String.String -> VirtualDom.Node msg"}],"binops":[]}]

package/.elm/0.19.1/packages/elm-community/list-extra/8.7.0/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 CircuitHub Inc., Elm Community members
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/.elm/0.19.1/packages/elm-community/list-extra/8.7.0/README.md

@@ -1,19 +0,0 @@
-# Convenience functions for working with `List`
-
-Feedback and contributions are very welcome!
-
-## Tests
-
-This package uses [elm-test](https://github.com/elm-explorations/test) and [elm-verify-examples](https://github.com/stoeffel/elm-verify-examples).
-
-## Contributing
-
-Pull requests are welcome. You can expect some kind of response within 14 days.
-
-If you are proposing a new function be added, please adhere to the following..
-
-1. Include [documentation](http://package.elm-lang.org/help/documentation-format) and make sure your documentation has a code snippet demonstrating what the function does. We use [elm-verify-examples](https://github.com/stoeffel/elm-verify-examples) in our travis set up which verifies our examples that our example code is correct, so please take advantage of that.
-2. Provide a detailed use case where your new function would be useful. Also, compare your new function to the best possible implementation that doesn't include use your function.
-3. Add tests to `Tests/Tests.elm`
-
-If you are improving existing functions please demonstrate the performance gains in something like [Ellie](https://ellie-app.com/) and by using a benchmark library like [this one](https://github.com/elm-explorations/benchmark). I usually copy and paste the last ellie bench mark I made, like [this one](https://ellie-app.com/gm9X8yfPLXMa1), so I don't have to set up the whole benchmark from scratch every time.

package/.elm/0.19.1/packages/elm-community/list-extra/8.7.0/docs.json

@@ -1 +0,0 @@
-[{"name":"List.Extra","comment":" Convenience functions for working with List\n\n\n# Basics\n\n@docs last, init, getAt, uncons, unconsLast, maximumBy, maximumWith, minimumBy, minimumWith, andMap, andThen, reverseMap, takeWhile, dropWhile, unique, uniqueBy, allDifferent, allDifferentBy, setIf, setAt, remove, updateIf, updateAt, updateIfIndex, removeAt, removeIfIndex, filterNot, swapAt, stableSortWith\n\n\n# List transformations\n\n@docs intercalate, transpose, subsequences, permutations, interweave, cartesianProduct, uniquePairs\n\n\n# Folds\n\n@docs foldl1, foldr1, indexedFoldl, indexedFoldr, Step, stoppableFoldl\n\n\n# Building lists\n\n@docs scanl, scanl1, scanr, scanr1, mapAccuml, mapAccumr, unfoldr, iterate, initialize, cycle, reverseRange\n\n\n# Sublists\n\n@docs splitAt, splitWhen, takeWhileRight, dropWhileRight, span, break, stripPrefix, group, groupWhile, inits, tails, select, selectSplit, gatherEquals, gatherEqualsBy, gatherWith, subsequencesNonEmpty, frequencies\n\n\n# Predicates\n\n@docs isPrefixOf, isSuffixOf, isInfixOf, isSubsequenceOf, isPermutationOf\n\n\n# Searching\n\n@docs notMember, find, elemIndex, elemIndices, findIndex, findIndices, findMap, count\n\n\n# Zipping\n\n@docs zip, zip3\n\n\n# Lift functions onto multiple lists of arguments\n\n@docs lift2, lift3, lift4\n\n\n# Split to groups of given size\n\n@docs groupsOf, groupsOfWithStep, groupsOfVarying, greedyGroupsOf, greedyGroupsOfWithStep\n\n\n# Joins\n\n@docs joinOn\n\n","unions":[{"name":"Step","comment":" A custom type used for stoppable folds.\n","args":["a"],"cases":[["Continue",["a"]],["Stop",["a"]]]}],"aliases":[],"values":[{"name":"allDifferent","comment":" Indicate if list has duplicate values.\n\n    allDifferent [ 0, 1, 1, 0, 1 ]\n    --> False\n\n    allDifferent [ 0, 1, 2]\n    --> True\n\n","type":"List.List a -> Basics.Bool"},{"name":"allDifferentBy","comment":" Indicate if list has duplicate values when supplied function are applied on each values.\n","type":"(a -> b) -> List.List a -> Basics.Bool"},{"name":"andMap","comment":" Map functions taking multiple arguments over multiple lists. Each list should be of the same length.\n\n    toIntFunctions : List (Float -> Int)\n    toIntFunctions =\n        [ round\n        , floor\n        , ceiling\n        , truncate\n        ]\n\n    toIntFunctions\n        |> andMap [ -1.5, -1.5, -1.5, -1.5 ]\n        --> [ -1, -2, -1, -1 ]\n\n\n    math : List (Int -> Int)\n    math =\n        [ (+) 1\n        , (*) 2\n        , (*) 3 >> (+) 1\n        ]\n\n    math\n        |> andMap [ 1, 2, 3 ]\n        --> [ 2, 4, 10 ]\n\n","type":"List.List a -> List.List (a -> b) -> List.List b"},{"name":"andThen","comment":" Equivalent to `concatMap`. For example, suppose you want to have a cartesian product of [1,2] and [3,4]:\n\n    [ 1, 2 ]\n        |> andThen\n            (\\x ->\n                [ 3, 4 ]\n                    |> andThen (\\y -> [ ( x, y ) ])\n            )\n        --> [ ( 1, 3 ), ( 1, 4 ), ( 2, 3 ), ( 2, 4 ) ]\n\nNow suppose we want to have a cartesian product between the first list and the second list and its doubles:\n\n    [ 1, 2 ]\n        |> andThen\n            (\\x ->\n                [ 3, 4 ]\n                    |> andThen\n                        (\\y ->\n                            [ y, y * 2 ]\n                                |> andThen (\\z -> [ ( x, z ) ])\n                        )\n            )\n        --> [ ( 1, 3 ), ( 1, 6 ), ( 1, 4 ), ( 1, 8 ), ( 2, 3 ), ( 2, 6 ), ( 2, 4 ), ( 2, 8 )]\n\nAdvanced functional programmers will recognize this as the implementation of bind operator (>>=) for lists from the `Monad` typeclass.\n\n","type":"(a -> List.List b) -> List.List a -> List.List b"},{"name":"break","comment":" Take a predicate and a list, return a tuple. The first part of the tuple is the longest prefix of that list, for each element of which the predicate _does not_ hold. The second part of the tuple is the remainder of the list. `break p xs` is equivalent to `(takeWhile (not p) xs, dropWhile (not p) xs)`.\n\n    break ((<) 3) [ 1, 2, 3, 4, 1, 2, 3, 4 ]\n    --> ( [ 1, 2, 3 ], [ 4, 1, 2, 3, 4 ] )\n\n    break ((>) 5) [ 1, 2, 3 ]\n    --> ( [], [ 1, 2, 3 ] )\n\n    break ((<) 5) [ 1, 2, 3 ]\n    --> ( [ 1, 2, 3 ], [] )\n\n","type":"(a -> Basics.Bool) -> List.List a -> ( List.List a, List.List a )"},{"name":"cartesianProduct","comment":" Return the cartesian product of a list of lists.\nIf one list is empty, the result is an empty list.\nIf the list of lists is empty, the result is an empty singleton.\n\n    cartesianProduct [ [ 1, 2 ], [ 3, 4, 5 ], [ 6 ] ]\n    --> [ [ 1, 3, 6 ], [ 1, 4, 6 ], [ 1, 5, 6 ], [ 2, 3, 6 ], [ 2, 4, 6 ], [ 2, 5, 6 ] ]\n\n    cartesianProduct [ [ 1, 2 ] ]\n    --> [ [ 1 ], [ 2 ] ]\n\n    cartesianProduct [ [ 1, 2 ], [], [ 6 ] ]\n    --> []\n\n    cartesianProduct [ [] ]\n    --> []\n\n    cartesianProduct []\n    --> [ [] ]\n\n","type":"List.List (List.List a) -> List.List (List.List a)"},{"name":"count","comment":" Returns the number of elements in a list that satisfy a given predicate.\nEquivalent to `List.length (List.filter pred list)` but more efficient.\n\n    count\n        (modBy 2 >> (==) 1) [ 1, 2, 3, 4, 5, 6, 7 ]\n    --> 4\n\n    count\n        ((==) \"yeah\")\n        [ \"She\", \"loves\", \"you\", \"yeah\", \"yeah\", \"yeah\" ]\n    --> 3\n\n","type":"(a -> Basics.Bool) -> List.List a -> Basics.Int"},{"name":"cycle","comment":" Creates a list of the given length whose elements are obtained by cycling\nthrough the elements of the given list. If the given list is empty, the\nresulting list will be empty.\n\n    cycle 6 [ 4, 7, 8 ]\n    --> [ 4, 7, 8, 4, 7, 8 ]\n\n    cycle 4 [ 'a', 'b', 'c' ]\n    --> [ 'a', 'b', 'c', 'a' ]\n\n    cycle 9001 []\n    --> []\n\n    cycle 2 [ 1, 2, 3, 4, 5 ]\n    --> [ 1, 2 ]\n\n","type":"Basics.Int -> List.List a -> List.List a"},{"name":"dropWhile","comment":" Drop elements in order as long as the predicate evaluates to `True`\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"dropWhileRight","comment":" Drop elements from the right, while predicate still holds.\n\n    dropWhileRight ((<) 5) (List.range 1 10)\n    --> [ 1, 2, 3, 4, 5 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"elemIndex","comment":" Return the index of the first occurrence of the element. Otherwise, return `Nothing`. Indexing starts from 0.\n\n    elemIndex 1 [ 1, 2, 3 ]\n    --> Just 0\n\n    elemIndex 4 [ 1, 2, 3 ]\n    --> Nothing\n\n    elemIndex 1 [ 1, 2, 1 ]\n    --> Just 0\n\n","type":"a -> List.List a -> Maybe.Maybe Basics.Int"},{"name":"elemIndices","comment":" Return all indices of occurrences of the element. If element is not found, return empty list. Indexing starts from 0.\n\n    elemIndices 1 [ 1, 2, 3 ]\n    --> [ 0 ]\n\n    elemIndices 4 [ 1, 2, 3 ]\n    --> []\n\n    elemIndices 1 [ 1, 2, 1 ]\n    --> [ 0, 2 ]\n\n","type":"a -> List.List a -> List.List Basics.Int"},{"name":"filterNot","comment":" Take a predicate and a list, and return a list that contains elements which fails to satisfy the predicate.\nThis is equivalent to `List.filter (not << predicate) list`.\n\n    isEven : Int -> Bool\n    isEven i =\n        modBy 2 i == 0\n\n    filterNot isEven [ 1, 2, 3, 4 ]\n    --> [ 1, 3 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"find","comment":" Find the first element that satisfies a predicate and return\nJust that element. If none match, return Nothing.\n\n    find (\\num -> num > 5) [ 2, 4, 6, 8 ]\n    --> Just 6\n\n","type":"(a -> Basics.Bool) -> List.List a -> Maybe.Maybe a"},{"name":"findIndex","comment":" Take a predicate and a list, return the index of the first element that satisfies the predicate. Otherwise, return `Nothing`. Indexing starts from 0.\n\n    isEven : Int -> Bool\n    isEven i =\n        modBy 2 i == 0\n\n    findIndex isEven [ 1, 2, 3 ]\n    --> Just 1\n\n    findIndex isEven [ 1, 3, 5 ]\n    --> Nothing\n\n    findIndex isEven [ 1, 2, 4 ]\n    --> Just 1\n\n","type":"(a -> Basics.Bool) -> List.List a -> Maybe.Maybe Basics.Int"},{"name":"findIndices","comment":" Take a predicate and a list, return indices of all elements satisfying the predicate. Otherwise, return empty list. Indexing starts from 0.\n\n    isEven : Int -> Bool\n    isEven i =\n        modBy 2 i == 0\n\n    findIndices isEven [ 1, 2, 3 ]\n    --> [ 1 ]\n\n    findIndices isEven [ 1, 3, 5 ]\n    --> []\n\n    findIndices isEven [ 1, 2, 4 ]\n    --> [ 1, 2 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List Basics.Int"},{"name":"findMap","comment":" Apply a function that may succeed to values in the list and return the result of the first successful match. If none match, then return Nothing.\n\n    mapOverFive : Int -> Maybe Int\n    mapOverFive num =\n        if num > 5 then\n            Just (num * 2)\n        else\n            Nothing\n\n    findMap mapOverFive [2, 4, 6, 8]\n    --> Just 12\n\nThis is particularly useful in cases where you have a complex type in a list, and you need to pick out the the first one\n\n    type alias HouseModel =\n        {}\n\n    type Property\n        = Rental\n        | House HouseModel\n        | Commercial\n\n    toHouse : Property -> Maybe HouseModel\n    toHouse property =\n        case property of\n            House house ->\n                Just house\n\n            _ ->\n                Nothing\n\n    viewFirstHomeOfInterest : Viewer -> List Property -> Html msg\n    viewFirstHomeOfInterest viewer propertiesQuery =\n        propertiesQuery\n            |> findMap toHouse\n            |> Maybe.map homeView\n            |> Maybe.withDefault noHomeView\n\n","type":"(a -> Maybe.Maybe b) -> List.List a -> Maybe.Maybe b"},{"name":"foldl1","comment":" Variant of `foldl` that has no starting value argument and treats the head of the list as its starting value. If the list is empty, return `Nothing`.\n\n    foldl1 (-) [ 1, 2, 3, 4 ]\n    --> Just 2\n\n    foldl1 (++) [ \"a\", \"b\", \"c\" ]\n    --> Just \"cba\"\n\n    foldl1 min []\n    --> Nothing\n\n**Note:** This function changed in a major way between version 7.0.0 and 8.0.0 of this package. The function `foldl1` took in 7.0.0 was `b -> a -> b` consistent with the Haskell implementation of `foldl`, but now its `a -> b -> b`, consistent with `List.foldl`. This function behaves differently in a breaking way, even though its type signature is the same.\n\n","type":"(a -> a -> a) -> List.List a -> Maybe.Maybe a"},{"name":"foldr1","comment":" Variant of `foldr` that has no starting value argument and treats the last element of the list as its starting value. If the list is empty, return `Nothing`.\n\n    foldr1 (-) [ 1, 2, 3, 4 ]\n    --> Just -2\n\n    foldr1 (++) [ \"a\", \"b\", \"c\" ]\n    --> Just \"abc\"\n\n    foldr1 min []\n    --> Nothing\n\n","type":"(a -> a -> a) -> List.List a -> Maybe.Maybe a"},{"name":"frequencies","comment":" Calculate the number of occurences for each element in a list. Elements\nwill be ordered ascendingly, then grouped in a tuple with the number of\noccurences.\n\n    frequencies [2,1,3,2,3,3]\n    --> [(1,1),(2,2),(3,3)]\n\n","type":"List.List comparable -> List.List ( comparable, Basics.Int )"},{"name":"gatherEquals","comment":" Group equal elements together. This is different from `group` as each sublist\nwill contain _all_ equal elements of the original list. Elements will be grouped\nin the same order as they appear in the original list. The same applies to elements\nwithin each group.\n\n    gatherEquals [1,2,1,3,2]\n    --> [(1,[1]),(2,[2]),(3,[])]\n\n","type":"List.List a -> List.List ( a, List.List a )"},{"name":"gatherEqualsBy","comment":" Group equal elements together. A function is applied to each element of the list\nand then the equality check is performed against the results of that function evaluation.\nElements will be grouped in the same order as they appear in the original list. The\nsame applies to elements within each group.\n\n    gatherEqualsBy .age [{age=25},{age=23},{age=25}]\n    --> [({age=25},[{age=25}]),({age=23},[])]\n\n","type":"(a -> b) -> List.List a -> List.List ( a, List.List a )"},{"name":"gatherWith","comment":" Group equal elements together using a custom equality function. Elements will be\ngrouped in the same order as they appear in the original list. The same applies to\nelements within each group.\n\n    gatherWith (==) [1,2,1,3,2]\n    --> [(1,[1]),(2,[2]),(3,[])]\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List ( a, List.List a )"},{"name":"getAt","comment":" Returns `Just` the element at the given index in the list,\nor `Nothing` if the index is out of range.\n","type":"Basics.Int -> List.List a -> Maybe.Maybe a"},{"name":"greedyGroupsOf","comment":" Greedily split list into groups of length `size`. The last group of\nelements will be included regardless of whether there are enough elements in\nthe list to completely fill it. This is equivalent to calling\n`greedyGroupsOfWithStep` with the same `size` and `step`.\n\n    greedyGroupsOf 3 (List.range 1 10)\n    --> [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ], [ 10 ] ]\n\n","type":"Basics.Int -> List.List a -> List.List (List.List a)"},{"name":"greedyGroupsOfWithStep","comment":" Greedily split list into groups of length `size` at offsets `step` apart.\nThe last group of elements will be included regardless of whether there are\nenough elements in the list to completely fill it. (See `groupsOfWithStep`\nfor the non-greedy version of this function).\n\n    greedyGroupsOfWithStep 4 4 (List.range 1 10)\n    --> [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ], [ 9, 10 ] ]\n\n    greedyGroupsOfWithStep 3 2 (List.range 1 6)\n    --> [ [ 1, 2, 3 ], [ 3, 4, 5 ], [ 5, 6 ] ]\n\n    greedyGroupsOfWithStep 3 6 (List.range 1 20)\n    --> [ [ 1, 2, 3 ], [ 7, 8, 9 ], [ 13, 14, 15 ], [ 19, 20 ] ]\n\nIf `step == size`, every element will appear in exactly one group. If\n`step < size`, there will be an overlap between groups. If `step > size`, some\nelements will be skipped and not appear in any groups.\n\n","type":"Basics.Int -> Basics.Int -> List.List a -> List.List (List.List a)"},{"name":"group","comment":" Group similar elements together. `group` is equivalent to `groupWhile (==)`.\n\n    group [ 1, 2, 2, 3, 3, 3, 2, 2, 1 ]\n    --> [ (1, []), (2, [ 2 ]), (3, [ 3, 3 ]), (2, [ 2 ]), ( 1,  []) ]\n\n","type":"List.List a -> List.List ( a, List.List a )"},{"name":"groupWhile","comment":" Group elements together, using a custom comparison test (`a -> a -> Bool`). Start a new group each time the comparison test doesn't hold for two adjacent elements.\n\n`groupWhile` uses a non-empty list type `(a, List a)` since groups necessarily must have at least one member since they are determined by comparing two members.\n\n    groupWhile\n        (==)\n        [ 1, 2, 3 ]\n    --> [ ( 1, [] ), ( 2, [] ), ( 3, [] ) ]\n\n    groupWhile\n        (<)\n        [ 1, 2, 3, 2, 4, 1, 3, 2, 1 ]\n    --> [ ( 1, [ 2, 3 ] ), ( 2, [ 4 ] ), ( 1, [ 3 ] ), ( 2, [] ), ( 1, [] ) ]\n\n    groupWhile\n        (\\a b -> a.id == b.id)\n        [ { value = 4, id = 9 }, { value = 7, id = 2 }, { value = 1, id = 2 } ]\n    --> [ ( { value = 4, id = 9 }, [] ), ( { value = 7, id = 2 }, [ { value = 1, id = 2 } ] ) ]\n\n**Note:**\nThe behavior of this function has changed between major versions 7 and 8. In version 7 there was `groupWhile` and `groupWhileTransitively`. The behavior of the two was almost identical, however the transitive function was closer to what users found intuitive about grouping. `groupWhileTransitively` has been deleted, and `groupWhile` has been replaced with the version 7s `groupWhileTransitively` behavior. Furthermore the group type was changed from `List a` to the non-empty list type `(a, List a)`. Sorry for any inconvenience this may cause.\n\n","type":"(a -> a -> Basics.Bool) -> List.List a -> List.List ( a, List.List a )"},{"name":"groupsOf","comment":" Split list into groups of length `size`. If there are not enough elements\nto completely fill the last group, it will not be included. This is equivalent\nto calling `groupsOfWithStep` with the same `size` and `step`.\n\n    groupsOf 3 (List.range 1 10)\n    --> [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ]\n\n","type":"Basics.Int -> List.List a -> List.List (List.List a)"},{"name":"groupsOfVarying","comment":" `groupsOfVarying ns` takes `n` elements from a list for each `n` in `ns`, splitting the list into variably sized segments\n\n    groupsOfVarying [ 2, 3, 1 ] [ \"a\", \"b\", \"c\", \"d\", \"e\", \"f\" ]\n    --> [ [ \"a\", \"b\" ], [ \"c\", \"d\", \"e\" ], [ \"f\" ] ]\n\n    groupsOfVarying [ 2 ] [ \"a\", \"b\", \"c\", \"d\", \"e\", \"f\" ]\n    --> [ [ \"a\", \"b\" ] ]\n\n    groupsOfVarying [ 2, 3, 1, 5, 6 ] [ \"a\", \"b\", \"c\", \"d\", \"e\" ]\n    --> [ [ \"a\", \"b\" ], [ \"c\", \"d\", \"e\" ] ]\n\n","type":"List.List Basics.Int -> List.List a -> List.List (List.List a)"},{"name":"groupsOfWithStep","comment":" Split list into groups of length `size` at offsets `step` apart. If there\nare not enough elements to completely fill the last group, it will not be\nincluded. (See `greedyGroupsOfWithStep` if you would like the last group to be\nincluded regardless.)\n\n    groupsOfWithStep 4 4 (List.range 1 10)\n    --> [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ] ]\n\n    groupsOfWithStep 3 1 (List.range 1 5)\n    --> [ [ 1, 2, 3 ], [ 2, 3, 4 ], [ 3, 4, 5 ] ]\n\n    groupsOfWithStep 3 6 (List.range 1 20)\n    --> [ [ 1, 2, 3 ], [ 7, 8, 9 ], [ 13, 14, 15 ] ]\n\nIf `step == size`, every element (except for perhaps the last few due to the\nnon-greedy behavior) will appear in exactly one group. If `step < size`, there\nwill be an overlap between groups. If `step > size`, some elements will be\nskipped and not appear in any groups.\n\n","type":"Basics.Int -> Basics.Int -> List.List a -> List.List (List.List a)"},{"name":"indexedFoldl","comment":" Variant of `foldl` that passes the index of the current element to the step function. `indexedFoldl` is to `List.foldl` as `List.indexedMap` is to `List.map`.\n","type":"(Basics.Int -> a -> b -> b) -> b -> List.List a -> b"},{"name":"indexedFoldr","comment":" Variant of `foldr` that passes the index of the current element to the step function. `indexedFoldr` is to `List.foldr` as `List.indexedMap` is to `List.map`.\n","type":"(Basics.Int -> a -> b -> b) -> b -> List.List a -> b"},{"name":"init","comment":" Return all elements of the list except the last one.\n\n    init [ 1, 2, 3 ]\n    --> Just [ 1, 2 ]\n\n    init []\n    --> Nothing\n\n","type":"List.List a -> Maybe.Maybe (List.List a)"},{"name":"initialize","comment":" Initialize a list of some length with some function.\n\n`initialize n f` creates a list of length `n` with the element at index `i` initialized to the result of `f i`.\n\n","type":"Basics.Int -> (Basics.Int -> a) -> List.List a"},{"name":"inits","comment":" Return all initial segments of a list, from shortest to longest, empty list first, the list itself last.\n\n    inits [ 1, 2, 3 ]\n    --> [ [], [ 1 ], [ 1, 2 ], [ 1, 2, 3 ] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"intercalate","comment":" Take a list and a list of lists, insert that list between every list in the list of lists, concatenate the result. `intercalate xs xss` is equivalent to `concat (intersperse xs xss)`.\n\n    intercalate [ 0, 0 ] [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]\n    --> [ 1, 2, 0, 0, 3, 4, 0, 0, 5, 6 ]\n\n","type":"List.List a -> List.List (List.List a) -> List.List a"},{"name":"interweave","comment":" Return a list that contains elements from the two provided, in alternate order.\nIf one list runs out of items, append the items from the remaining list.\n\n    interweave [ 1, 3 ] [ 2, 4 ]\n    --> [ 1, 2, 3, 4 ]\n\n    interweave [ 1, 3, 5, 7 ] [ 2, 4 ]\n    --> [ 1, 2, 3, 4, 5, 7 ]\n\n    interweave [ 4, 9, 16 ] [ 2, 3, 5, 7 ]\n    --> [ 4, 2, 9, 3, 16, 5, 7 ]\n\n","type":"List.List a -> List.List a -> List.List a"},{"name":"isInfixOf","comment":" Return True if all the elements of the first list occur in-order and\nconsecutively anywhere within the second.\n\n    isInfixOf [ 5, 7, 11 ] [ 2, 3, 5, 7, 11, 13 ]\n    --> True\n\n    isInfixOf [ 5, 7, 13 ] [ 2, 3, 5, 7, 11, 13 ]\n    --> False\n\n    isInfixOf [ 3, 5, 2 ] [ 2, 3, 5, 7, 11, 13 ]\n    --> False\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isPermutationOf","comment":" Take two lists and return `True`, if the first list is a permutation of the second list.\nIn other words: Do the 2 `List`s contain the same elements but in a different order?\n\n    [ 3, 1, 2 ]\n        |> isPermutationOf\n            [ 1, 2, 3 ]\n    --> True\n\n    [ 3, 1, 0 ]\n        |> isPermutationOf\n            [ 1, 2, 3 ]\n    --> False\n\n    [ 3, 1, 2, 2 ]\n        |> isPermutationOf\n            [ 1, 2, 3 ]\n    --> False\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isPrefixOf","comment":" Take two lists and return `True`, if the first list is the prefix of the second list.\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isSubsequenceOf","comment":" Return True if all the elements of the first list occur, in order, in the\nsecond. The elements do not have to occur consecutively.\n\n    isSubsequenceOf\n        [ \"E\", \"l\", \"m\" ]\n        [ \"E\", \"a\", \"t\", \" \", \"l\", \"i\", \"m\", \"e\", \"s\" ]\n    --> True\n\n    isSubsequenceOf\n        [ \"E\", \"l\", \"m\" ]\n        [ \"E\", \"m\", \"a\", \"i\", \"l\" ]\n    --> False\n\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"isSuffixOf","comment":" Take two lists and return `True`, if the first list is the suffix of the second list.\n","type":"List.List a -> List.List a -> Basics.Bool"},{"name":"iterate","comment":" Returns a list of repeated applications of `f`. If `f` returns `Nothing`\nthe iteration will stop. If it returns `Just y` then `y` will be added to the\nlist and the iteration will continue with `f y`.\n\n    collatz : Int -> Maybe Int\n    collatz n =\n        if n == 1 then\n            Nothing\n        else\n            Just <|\n                if modBy 2 n == 0 then\n                    n // 2\n                else\n                    3 * n + 1\n\n    iterate collatz 13\n    --> [13,40,20,10,5,16,8,4,2,1]\n\n","type":"(a -> Maybe.Maybe a) -> a -> List.List a"},{"name":"joinOn","comment":" Performs an inner join, combining data items from both lists if they match by their respective key functions.\n\n    employees : List { name : String, departmentId : Int }\n    employees =\n        [ { name = \"Rafferty\", departmentId = 31 }\n        , { name = \"Jones\", departmentId = 33 }\n        , { name = \"Heisenberg\", departmentId = 33 }\n        , { name = \"Robinson\", departmentId = 34 }\n        , { name = \"Smith\", departmentId = 34 }\n        ]\n\n    departments : List { name : String, departmentId : Int }\n    departments =\n        [ { departmentId = 31, name = \"Sales\" }\n        , { departmentId = 33, name = \"Engineering\" }\n        , { departmentId = 34, name = \"Clerical\" }\n        , { departmentId = 35, name = \"Marketing\" }\n        ]\n\n    joinOn (\\empl dep -> { employee = empl.name, department = dep.name}) .departmentId .departmentId employees departments\n    --> [ { department = \"Clerical\", employee = \"Robinson\" }\n    --> , { department = \"Clerical\", employee = \"Smith\" }\n    --> , { department = \"Engineering\", employee = \"Jones\" }\n    --> , { department = \"Engineering\", employee = \"Heisenberg\" }\n    --> , { department = \"Sales\", employee = \"Rafferty\" }\n    --> ]\n\nThis is akin to the SQL query:\n\n    SELECT employee.name, department.name\n    FROM employee\n    INNER JOIN department\n    ON employee.departmentId = department.departmentId\n\n","type":"(a -> b -> c) -> (a -> comparable) -> (b -> comparable) -> List.List a -> List.List b -> List.List c"},{"name":"last","comment":" Extract the last element of a list.\n\n    last [ 1, 2, 3 ]\n    --> Just 3\n\n    last []\n    --> Nothing\n\n","type":"List.List a -> Maybe.Maybe a"},{"name":"lift2","comment":" Map functions taking multiple arguments over multiple lists, regardless of list length.\nAll possible combinations will be explored.\n\n    lift2 (+) [1,2,3][4,5]\n    --> [5,6,6,7,7,8]\n\n","type":"(a -> b -> c) -> List.List a -> List.List b -> List.List c"},{"name":"lift3","comment":" ","type":"(a -> b -> c -> d) -> List.List a -> List.List b -> List.List c -> List.List d"},{"name":"lift4","comment":" ","type":"(a -> b -> c -> d -> e) -> List.List a -> List.List b -> List.List c -> List.List d -> List.List e"},{"name":"mapAccuml","comment":" The mapAccuml function behaves like a combination of map and foldl; it applies a\nfunction to each element of a list, passing an accumulating parameter from left to right,\nand returning a final value of this accumulator together with the new list.\n\n    mapAccuml f a0 [ x1, x2, x3 ] == ( a3, [ y1, y2, y3 ] )\n\n    --        x1    x2    x3\n    --        |     |     |\n    --  a0 -- f --- f --- f -> a3\n    --        |     |     |\n    --        y1    y2    y3\n\nAdd a running total to a list of numbers:\n\n    mapAccuml (\\a x -> ( a + x, ( x, a + x ) )) 0 [ 2, 4, 8 ]\n        --> ( 14, [ ( 2, 2 ), ( 4, 6 ), ( 8, 14 ) ] )\n\nMap number by multiplying with accumulated sum:\n\n    mapAccuml (\\a x -> ( a + x, a * x )) 5 [ 2, 4, 8 ]\n        --> ( 19, [ 10, 28, 88 ] )\n\n","type":"(a -> b -> ( a, c )) -> a -> List.List b -> ( a, List.List c )"},{"name":"mapAccumr","comment":" The mapAccumr function behaves like a combination of map and foldr; it applies a\nfunction to each element of a list, passing an accumulating parameter from right to left,\nand returning a final value of this accumulator together with the new list.\n\n    mapAccumr f a0 [ x1, x2, x3 ] == ( a3, [ y1, y2, y3 ] )\n\n    --        x1    x2    x3\n    --        |     |     |\n    --  a3 <- f --- f --- f -- a0\n    --        |     |     |\n    --        y1    y2    y3\n\nAdd a count of remaining elements:\n\n    mapAccumr (\\a x -> ( a + 1, ( x, a ) )) 0 [ 2, 4, 8 ]\n        --> ( 3, [ ( 2, 2 ), ( 4, 1 ), ( 8, 0 ) ] )\n\nMap number by multiplying with right-to-left accumulated sum:\n\n    mapAccumr (\\a x -> ( a + x, a * x )) 5 [ 2, 4, 8 ]\n        --> ( 19, [ 34, 52, 40 ] )\n\n","type":"(a -> b -> ( a, c )) -> a -> List.List b -> ( a, List.List c )"},{"name":"maximumBy","comment":" Find the first maximum element in a list using a comparable transformation\n","type":"(a -> comparable) -> List.List a -> Maybe.Maybe a"},{"name":"maximumWith","comment":" Find the first maximum element in a list using a comparison function\n\n    maximumWith compare []\n    --> Nothing\n\n    maximumWith\n      (\\x y -> compare x.val y.val)\n      [{id=1, val=1}, {id=2, val=2}, {id=3,val=2}]\n    --> Just { id = 2, val = 2 }\n\n","type":"(a -> a -> Basics.Order) -> List.List a -> Maybe.Maybe a"},{"name":"minimumBy","comment":" Find the first minimum element in a list using a comparable transformation\n","type":"(a -> comparable) -> List.List a -> Maybe.Maybe a"},{"name":"minimumWith","comment":" Find the first minimum element in a list using a comparison function\n\n    minimumWith compare []\n    --> Nothing\n    minimumWith\n      (\\x y -> compare x.val y.val)\n      [{id=1, val=2}, {id=2, val=1}, {id=3,val=1}]\n    --> Just { id = 2, val = 1 }\n\n","type":"(a -> a -> Basics.Order) -> List.List a -> Maybe.Maybe a"},{"name":"notMember","comment":" Negation of `member`.\n\n    notMember 1 [ 1, 2, 3 ]\n    --> False\n\n    notMember 4 [ 1, 2, 3 ]\n    --> True\n\n","type":"a -> List.List a -> Basics.Bool"},{"name":"permutations","comment":" Return the list of of all permutations of a list. The result is in lexicographic order.\n\n    permutations [ 1, 2, 3 ]\n    --> [ [ 1, 2, 3 ], [ 1, 3, 2 ], [ 2, 1, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ], [ 3, 2, 1 ] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"remove","comment":" Remove the first occurrence of a value from a list.\n","type":"a -> List.List a -> List.List a"},{"name":"removeAt","comment":" Remove the element at an index from a list. Return the original list if the index is out of range.\n\n    removeAt 0 [ 1, 2, 3 ]\n    --> [ 2, 3 ]\n\nSee also `removeIfIndex`.\n\n","type":"Basics.Int -> List.List a -> List.List a"},{"name":"removeIfIndex","comment":" Remove an element at an index that satisfies a predicate.\n\n    removeIfIndex ((==) 2) [ 1, 2, 3 ]\n    --> [ 1, 2 ]\n\nSee also `removeAt`.\n\n","type":"(Basics.Int -> Basics.Bool) -> List.List a -> List.List a"},{"name":"reverseMap","comment":" `reverseMap f xs` gives the same result as `List.reverse (List.map f xs)`,\nbut is tail-recursive and slightly more efficient.\n\n    reverseMap sqrt [ 1, 4, 9 ]\n    --> [ 3, 2, 1 ]\n\n","type":"(a -> b) -> List.List a -> List.List b"},{"name":"reverseRange","comment":" Create a list of numbers, every element decreasing by one.\nYou give the highest and lowest number that should be in the list.\nMore efficient than calling `List.reverse (List.range lo hi)`\n\n    range 6 3 == [ 6, 5, 4, 3 ]\n\n    range 3 3 == [ 3 ]\n\n    range 3 6 == []\n\n","type":"Basics.Int -> Basics.Int -> List.List Basics.Int"},{"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 ]\n    --> [ 0, 1, 3, 6, 10 ]\n\n","type":"(a -> b -> b) -> b -> List.List a -> List.List b"},{"name":"scanl1","comment":" `scanl1` is a variant of `scanl` that has no starting value argument.\n\nCompare:\n\n    scanl (+) 0 [ 1, 2, 3 ]\n    --> [ 0, 1, 3, 6 ]\n\n    scanl1 (+) [ 1, 2, 3 ]\n    --> [ 1, 3, 6 ]\n\n    scanl (-) 0 [ 1, 2, 3 ]\n    --> [ 0, 1, 1, 2 ]\n\n    scanl1 (-) [ 1, 2, 3 ]\n    --> [ 1, 1, 2 ]\n\n","type":"(a -> a -> a) -> List.List a -> List.List a"},{"name":"scanr","comment":" `scanr` is a right-to-left dual of `scanl`. Note that:\n\n    head (scanr f z xs) == foldr f z xs\n\nExamples:\n\n    scanr (+) 0 [ 1, 2, 3 ]\n    --> [ 6, 5, 3, 0 ]\n\n    scanr (-) 0 [ 1, 2, 3 ]\n    --> [ 2, -1, 3, 0 ]\n\n","type":"(a -> b -> b) -> b -> List.List a -> List.List b"},{"name":"scanr1","comment":" `scanr1` is a variant of `scanr` that has no starting value argument.\n\n    scanr1 (+) [ 1, 2, 3 ]\n    --> [ 6, 5, 3 ]\n\n    scanr1 (-) [ 1, 2, 3 ]\n    --> [ 2, -1, 3 ]\n\n","type":"(a -> a -> a) -> List.List a -> List.List a"},{"name":"select","comment":" Return all combinations in the form of (element, rest of the list). Read [Haskell Libraries proposal](https://mail.haskell.org/pipermail/libraries/2008-February/009270.html) for further ideas on how to use this function.\n\n    select [ 1, 2, 3, 4 ]\n    --> [ ( 1, [ 2, 3, 4 ] ), ( 2, [ 1, 3, 4 ] ), ( 3, [ 1, 2, 4 ] ), ( 4, [ 1, 2, 3 ] ) ]\n\n","type":"List.List a -> List.List ( a, List.List a )"},{"name":"selectSplit","comment":" Return all combinations in the form of (elements before, element, elements after).\n\n    selectSplit [ 1, 2, 3 ]\n    --> [ ( [], 1, [ 2, 3 ] ), ( [ 1 ], 2, [ 3 ] ), ( [ 1, 2 ], 3, [] ) ]\n\n","type":"List.List a -> List.List ( List.List a, a, List.List a )"},{"name":"setAt","comment":" Set a value in a list by index. Return the original list if the index is out of range.\n\n    setAt 0 42 [ 1, 2, 3 ]\n    --> [ 42, 2, 3 ]\n\n","type":"Basics.Int -> a -> List.List a -> List.List a"},{"name":"setIf","comment":" Replace all values that satisfy a predicate with a replacement value.\n","type":"(a -> Basics.Bool) -> a -> List.List a -> List.List a"},{"name":"span","comment":" Take a predicate and a list, return a tuple. The first part of the tuple is the longest prefix of that list, for each element of which the predicate holds. The second part of the tuple is the remainder of the list. `span p xs` is equivalent to `(takeWhile p xs, dropWhile p xs)`.\n\n    span ((>) 3) [ 1, 2, 3, 4, 1, 2, 3, 4 ]\n    --> ( [ 1, 2 ], [ 3, 4, 1, 2, 3, 4 ] )\n\n    span ((>) 5) [ 1, 2, 3 ]\n    --> ( [ 1, 2, 3 ], [] )\n\n    span ((>) 0) [ 1, 2, 3 ]\n    --> ( [], [ 1, 2, 3 ] )\n\n","type":"(a -> Basics.Bool) -> List.List a -> ( List.List a, List.List a )"},{"name":"splitAt","comment":" Take a number and a list, return a tuple of lists, where first part is prefix of the list of length equal the number, and second part is the remainder of the list. `splitAt n xs` is equivalent to `(take n xs, drop n xs)`.\n\n    splitAt 3 [ 1, 2, 3, 4, 5 ]\n    --> ( [ 1, 2, 3 ], [ 4, 5 ] )\n\n    splitAt 1 [ 1, 2, 3 ]\n    --> ( [ 1 ], [ 2, 3 ] )\n\n    splitAt 3 [ 1, 2, 3 ]\n    --> ( [ 1, 2, 3 ], [] )\n\n    splitAt 4 [ 1, 2, 3 ]\n    --> ( [ 1, 2, 3 ], [] )\n\n    splitAt 0 [ 1, 2, 3 ]\n    --> ( [], [ 1, 2, 3 ] )\n\n    splitAt -1 [ 1, 2, 3 ]\n    --> ( [], [ 1, 2, 3 ] )\n\n","type":"Basics.Int -> List.List a -> ( List.List a, List.List a )"},{"name":"splitWhen","comment":" Attempts to split the list at the first element where the given predicate is true. If the predicate is not true for any elements in the list, return nothing. Otherwise, return the split list.\n\n    splitWhen (\\n -> n == 3) [ 1, 2, 3, 4, 5 ]\n    --> Just ( [ 1, 2 ], [ 3, 4, 5 ] )\n\n    splitWhen (\\n -> n == 6) [ 1, 2, 3, 4, 5 ]\n    --> Nothing\n\n","type":"(a -> Basics.Bool) -> List.List a -> Maybe.Maybe ( List.List a, List.List a )"},{"name":"stableSortWith","comment":" Similar to List.sortWith, this sorts values with a custom comparison function.\nUnlike List.sortWith, this sort is guaranteed to be a stable sort.\nNote that List.sortWith is faster and is preferred if sort stability is not required.\n","type":"(a -> a -> Basics.Order) -> List.List a -> List.List a"},{"name":"stoppableFoldl","comment":" A `foldl` that can stop early instead of traversing the whole list.\n\n    stoppableFoldl\n        (\\n acc ->\n            if acc >= 50 then\n                Stop acc\n            else\n                Continue (n + acc)\n        )\n        0\n        (List.range 1 10000)\n    --> 55\n\n","type":"(a -> b -> List.Extra.Step b) -> b -> List.List a -> b"},{"name":"stripPrefix","comment":" Drop the given prefix from the list. If the list doesn't start with that prefix, return `Nothing`.\n\n    stripPrefix [ 1, 2 ] [ 1, 2, 3, 4 ]\n    --> Just [ 3, 4 ]\n\n    stripPrefix [ 1, 2, 3 ] [ 1, 2, 3, 4, 5 ]\n    --> Just [ 4, 5 ]\n\n    stripPrefix [ 1, 2, 3 ] [ 1, 2, 3 ]\n    --> Just []\n\n    stripPrefix [ 1, 2, 3 ] [ 1, 2 ]\n    --> Nothing\n\n    stripPrefix [ 3, 2, 1 ] [ 1, 2, 3, 4, 5 ]\n    --> Nothing\n\n","type":"List.List a -> List.List a -> Maybe.Maybe (List.List a)"},{"name":"subsequences","comment":" Return the list of all subsequences of a list.\n\n    subsequences [ 1, 2, 3 ]\n    --> [ [], [ 1 ], [ 2 ], [ 1, 2 ], [ 3 ], [ 1, 3 ], [ 2, 3 ], [ 1, 2, 3 ] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"subsequencesNonEmpty","comment":" Return the list of all subsequences of the argument, except for the empty list.\n\n    subsequencesNonEmpty [ 1, 2, 3 ]\n        == [ [ 1 ], [ 2 ], [ 1, 2 ], [ 3 ], [ 1, 3 ], [ 2, 3 ], [ 1, 2, 3 ] ]\n\n","type":"List.List a -> List.List ( a, List.List a )"},{"name":"swapAt","comment":" Swap two values in a list by index. Return the original list if the index is out of range.\nIf the same index is supplied twice the operation has no effect.\n\n    swapAt 1 2 [ 1, 2, 3 ]\n    --> [ 1, 3, 2 ]\n\n","type":"Basics.Int -> Basics.Int -> List.List a -> List.List a"},{"name":"tails","comment":" Return all final segments of a list, from longest to shortest, the list itself first, empty list last.\n\n    tails [ 1, 2, 3 ]\n    --> [ [ 1, 2, 3 ], [ 2, 3 ], [ 3 ], [] ]\n\n","type":"List.List a -> List.List (List.List a)"},{"name":"takeWhile","comment":" Take elements in order as long as the predicate evaluates to `True`\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"takeWhileRight","comment":" Take elements from the right, while predicate still holds.\n\n    takeWhileRight ((<) 5) (List.range 1 10)\n    --> [ 6, 7, 8, 9, 10 ]\n\n","type":"(a -> Basics.Bool) -> List.List a -> List.List a"},{"name":"transpose","comment":" Transpose rows and columns of the list of lists.\n\n    transpose [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]\n    --> [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]\n\n    transpose [ [ 10, 11 ], [ 20, 40 ], [ 30, 31, 32, 400 ] ]\n    --> [ [ 10, 20, 30 ], [ 11, 40, 31 ] ]\n\n","type":"List.List (List.List a) -> List.List (List.List a)"},{"name":"uncons","comment":" Decompose a list into its head and tail. If the list is empty, return `Nothing`. Otherwise, return `Just (x, xs)`, where `x` is head and `xs` is tail.\n\n    uncons [1,2,3]\n    --> Just (1, [2,3])\n\n    uncons []\n    --> Nothing\n\n","type":"List.List a -> Maybe.Maybe ( a, List.List a )"},{"name":"unconsLast","comment":" Decompose a list into its body and last element. If the list is empty, return `Nothing`. Otherwise, return `Just (x, xs)`, where `x` is the last element and `xs` is the body.\n\n    unconsLast [1,2,3]\n    --> Just (3, [1,2])\n\n    unconsLast []\n    --> Nothing\n\n","type":"List.List a -> Maybe.Maybe ( a, List.List a )"},{"name":"unfoldr","comment":" The `unfoldr` function is \"dual\" to `foldr`. `foldr` reduces a list to a summary value, `unfoldr` builds a list from a seed. The function takes a function and a starting element. It applies the function to the element. If the result is `Just (a, b)`, `a` is accumulated and the function is applied to `b`. If the result is `Nothing`, the list accumulated so far is returned.\n\n    subtractOneUntilZero : Int -> Maybe (Int, Int)\n    subtractOneUntilZero i =\n        if i /= 0 then\n            Just (i, i - 1)\n        else\n            Nothing\n\n    unfoldr subtractOneUntilZero 5\n    --> [ 5, 4, 3, 2, 1 ]\n\n","type":"(b -> Maybe.Maybe ( a, b )) -> b -> List.List a"},{"name":"unique","comment":" Remove duplicate values, keeping the first instance of each element which appears more than once.\n\n    unique [ 0, 1, 1, 0, 1 ]\n    --> [ 0, 1 ]\n\n","type":"List.List a -> List.List a"},{"name":"uniqueBy","comment":" Drop duplicates where what is considered to be a duplicate is the result of first applying the supplied function to the elements of the list.\n","type":"(a -> b) -> List.List a -> List.List a"},{"name":"uniquePairs","comment":" Return all ways to pair the elements of the list.\n(Essentially, enumerate the possible \"handshakes.\")\n\nThe order of the pair elements doesn't matter, so if `(1,2)` is a returned pair,\nwe don't return `(2,1)`.\n\nIn more mathematical terms these are 2-combinations without repetition.\n\n    uniquePairs [ 1, 2, 3, 4 ]\n    --> [ ( 1, 2 ), ( 1, 3 ), ( 1, 4 ), ( 2, 3 ), ( 2, 4 ), ( 3, 4 ) ]\n\nIn this example, everybody shakes hands with three other people.\n\n","type":"List.List a -> List.List ( a, a )"},{"name":"updateAt","comment":" Replace a value at a specific index by calling an update function. Return the original list if the index is out of range.\n\n    updateAt 0 ((+) 1) [ 1, 2, 3 ]\n    --> [ 2, 2, 3 ]\n\nSee also `updateIfIndex`.\n\n","type":"Basics.Int -> (a -> a) -> List.List a -> List.List a"},{"name":"updateIf","comment":" Replace all values that satisfy a predicate by calling an update function.\n","type":"(a -> Basics.Bool) -> (a -> a) -> List.List a -> List.List a"},{"name":"updateIfIndex","comment":" Replace a value at an index that satisfies a predicate, by calling an update function.\n\n    updateIfIndex ((==) 2) ((+) 1) [ 1, 2, 3 ]\n    --> [ 1, 2, 4 ]\n\nSee also `updateAt`.\n\n","type":"(Basics.Int -> Basics.Bool) -> (a -> a) -> List.List a -> List.List a"},{"name":"zip","comment":" Take two lists and returns a list of corresponding pairs\n","type":"List.List a -> List.List b -> List.List ( a, b )"},{"name":"zip3","comment":" Take three lists and returns a list of triples\n","type":"List.List a -> List.List b -> List.List c -> List.List ( a, b, c )"}],"binops":[]}]

package/.elm/0.19.1/packages/elm-community/random-extra/3.2.0/LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2017, Elm Community
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/.elm/0.19.1/packages/elm-community/random-extra/3.2.0/README.md

@@ -1,31 +0,0 @@
-# elm-community/random-extra
-This library includes lots of extra helper functions for the Random module. It makes generating pseudo-random values much easier.
-
-If you want to add one or find a bug, please [open an issue](https://github.com/elm-community/random-extra/issues/new). If you want to contribute, you can open a PR adding tests.
-
-## Changelog
-### 3.2.0
-* Add `Random.List.choices`
-* Use a uniform shuffle for both `Random.List.shuffle` and `Random.Array.shuffle`.
-
-### 3.1.0
-* Add `sequence` and `traverse` functions
-* Improve the performance of `Random.List.shuffle` and `Random.Array.shuffle`, especially on long lists/arrays.
-
-### 3.0.0
-* Update for Elm 0.19, including switching to `elm/random`.
-* Remove `Color` module.
-* Rename `Random.Date.day` to `Random.Date.weekday`.
-* Remove many trivial functions in `Random.Date`.
-* Add `Random.Extra.bool`.
-* Remove `Random.Extra.constant`; it's present in the official library.
-* Change the signatures of `Random.Extra.choices` and `Random.Extra.frequency` to require an element and a list, avoid the issue of an empty list.
-
-
-### 2.0.0
-* Update dependencies for Elm 0.18.
-* Remove `flatMap` as core's `andThen` is identical.
-* Rename `flatMapN` to `andThenN`, for similar reasons.
-* Rename `together` to `combine`; see #1.
-* Change signature of `Random.Extra.Float.normal`; see #2.
-* Add `Random.Extra.List` module; see #4.

package/.elm/0.19.1/packages/elm-community/random-extra/3.2.0/docs.json

@@ -1 +0,0 @@
-[{"name":"Random.Array","comment":" Extra randomized functions on arrays.\n\n\n# Create an Array\n\n@docs array, rangeLengthArray\n\n\n# Work with an Array\n\n@docs sample, choose, shuffle\n\n","unions":[],"aliases":[],"values":[{"name":"array","comment":" Generate a random array of given size given a random generator\n\n    randomLength5IntArray =\n        array 5 (int 0 100)\n\n","type":"Basics.Int -> Random.Generator a -> Random.Generator (Array.Array a)"},{"name":"choose","comment":" Sample without replacement: produce a randomly selected element of the\narray, and the array with that element omitted (shifting all later elements\ndown). If the array is empty, the selected element will be `Nothing`.\n","type":"Array.Array a -> Random.Generator ( Maybe.Maybe a, Array.Array a )"},{"name":"rangeLengthArray","comment":" Generate a random array of random length given a minimum length and\na maximum length.\n","type":"Basics.Int -> Basics.Int -> Random.Generator a -> Random.Generator (Array.Array a)"},{"name":"sample","comment":" Sample with replacement: produce a randomly selected element of the\narray, or `Nothing` for an empty array. Takes O(1) time.\n","type":"Array.Array a -> Random.Generator (Maybe.Maybe a)"},{"name":"shuffle","comment":" Shuffle the list. Takes O(_n_ log _n_) time and no extra space.\n","type":"Array.Array a -> Random.Generator (Array.Array a)"}],"binops":[]},{"name":"Random.Char","comment":" Extra randomized functions on characters.\n\n\n# Basic Generators\n\n@docs char, lowerCaseLatin, upperCaseLatin, latin, english, ascii, unicode\n\n\n# Unicode Generators (UTF-8)\n\n@docs basicLatin, latin1Supplement, latinExtendedA, latinExtendedB, ipaExtensions, spacingModifier, combiningDiacriticalMarks, greekAndCoptic, cyrillic, cyrillicSupplement, armenian, hebrew, arabic, syriac, arabicSupplement, thaana, nko, samaritan, mandaic, arabicExtendedA, devanagari, bengali, gurmukhi, gujarati, oriya, tamil, telugu, kannada, malayalam, sinhala, thai, lao, tibetan, myanmar, georgian, hangulJamo, ethiopic, ethiopicSupplement, cherokee, unifiedCanadianAboriginalSyllabic, ogham, runic, tagalog, hanunoo, buhid, tagbanwa, khmer, mongolian, unifiedCanadianAboriginalSyllabicExtended, limbu, taiLe, newTaiLue, khmerSymbol, buginese, taiTham, balinese, sundanese, batak, lepcha, olChiki, sundaneseSupplement, vedicExtensions, phoneticExtensions, phoneticExtensionsSupplement, combiningDiacriticalMarksSupplement, latinExtendedAdditional, greekExtended, generalPunctuation, superscriptOrSubscript, currencySymbol, combiningDiacriticalMarksForSymbols, letterlikeSymbol, numberForm, arrow, mathematicalOperator, miscellaneousTechnical, controlPicture, opticalCharacterRecognition, enclosedAlphanumeric, boxDrawing, blockElement, geometricShape, miscellaneousSymbol, dingbat, miscellaneousMathematicalSymbolA, supplementalArrowA, braillePattern, supplementalArrowB, miscellaneousMathematicalSymbolB, supplementalMathematicalOperator, miscellaneousSymbolOrArrow, glagolitic, latinExtendedC, coptic, georgianSupplement, tifinagh, ethiopicExtended, cyrillicExtendedA, supplementalPunctuation, cjkRadicalSupplement, kangxiRadical, ideographicDescription, cjkSymbolOrPunctuation, hiragana, katakana, bopomofo, hangulCompatibilityJamo, kanbun, bopomofoExtended, cjkStroke, katakanaPhoneticExtension, enclosedCJKLetterOrMonth, cjkCompatibility, cjkUnifiedIdeographExtensionA, yijingHexagramSymbol, cjkUnifiedIdeograph, yiSyllable, yiRadical, lisu, vai, cyrillicExtendedB, bamum, modifierToneLetter, latinExtendedD, sylotiNagri, commonIndicNumberForm, phagsPa, saurashtra, devanagariExtended, kayahLi, rejang, hangulJamoExtendedA, javanese, cham, myanmarExtendedA, taiViet, meeteiMayekExtension, ethiopicExtendedA, meeteiMayek, hangulSyllable, hangulJamoExtendedB, highSurrogate, highPrivateUseSurrogate, lowSurrogate, privateUseArea, cjkCompatibilityIdeograph, alphabeticPresentationForm, arabicPresentationFormA, variationSelector, verticalForm, combiningHalfMark, cjkCompatibilityForm, smallFormVariant, arabicPresentationFormB, halfwidthOrFullwidthForm, special, linearBSyllable, linearBIdeogram, aegeanNumber, ancientGreekNumber, ancientSymbol, phaistosDisc, lycian, carian, oldItalic, gothic, ugaritic, oldPersian, deseret, shavian, osmanya, cypriotSyllable, imperialAramaic, phoenician, lydian, meroiticHieroglyph, meroiticCursive, kharoshthi, oldSouthArabian, avestan, inscriptionalParthian, inscriptionalPahlavi, oldTurkic, rumiNumericalSymbol, brahmi, kaithi, soraSompeng, chakma, sharada, takri, cuneiform, cuneiformNumberOrPunctuation, egyptianHieroglyph, bamumSupplement, miao, kanaSupplement, byzantineMusicalSymbol, musicalSymbol, ancientGreekMusicalNotationSymbol, taiXuanJingSymbol, countingRodNumeral, mathematicalAlphanumericSymbol, arabicMathematicalAlphabeticSymbol, mahjongTile, dominoTile, playingCard, enclosedAlphanumericSupplement, enclosedIdeographicSupplement, miscellaneousSymbolOrPictograph, emoticon, transportOrMapSymbol, alchemicalSymbol, cjkUnifiedIdeographExtensionB, cjkUnifiedIdeographExtensionC, cjkUnifiedIdeographExtensionD, cjkCompatibilityIdeographSupplement, tag, variationSelectorSupplement, supplementaryPrivateUseAreaA, supplementaryPrivateUseAreaB\n\n","unions":[],"aliases":[],"values":[{"name":"aegeanNumber","comment":" ","type":"Random.Generator Char.Char"},{"name":"alchemicalSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"alphabeticPresentationForm","comment":" ","type":"Random.Generator Char.Char"},{"name":"ancientGreekMusicalNotationSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"ancientGreekNumber","comment":" ","type":"Random.Generator Char.Char"},{"name":"ancientSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"arabic","comment":" ","type":"Random.Generator Char.Char"},{"name":"arabicExtendedA","comment":" ","type":"Random.Generator Char.Char"},{"name":"arabicMathematicalAlphabeticSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"arabicPresentationFormA","comment":" ","type":"Random.Generator Char.Char"},{"name":"arabicPresentationFormB","comment":" ","type":"Random.Generator Char.Char"},{"name":"arabicSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"armenian","comment":" ","type":"Random.Generator Char.Char"},{"name":"arrow","comment":" ","type":"Random.Generator Char.Char"},{"name":"ascii","comment":" Generate a random ASCII Character\n","type":"Random.Generator Char.Char"},{"name":"avestan","comment":" ","type":"Random.Generator Char.Char"},{"name":"balinese","comment":" ","type":"Random.Generator Char.Char"},{"name":"bamum","comment":" ","type":"Random.Generator Char.Char"},{"name":"bamumSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"basicLatin","comment":" UTF-8\n","type":"Random.Generator Char.Char"},{"name":"batak","comment":" ","type":"Random.Generator Char.Char"},{"name":"bengali","comment":" ","type":"Random.Generator Char.Char"},{"name":"blockElement","comment":" ","type":"Random.Generator Char.Char"},{"name":"bopomofo","comment":" ","type":"Random.Generator Char.Char"},{"name":"bopomofoExtended","comment":" ","type":"Random.Generator Char.Char"},{"name":"boxDrawing","comment":" ","type":"Random.Generator Char.Char"},{"name":"brahmi","comment":" ","type":"Random.Generator Char.Char"},{"name":"braillePattern","comment":" ","type":"Random.Generator Char.Char"},{"name":"buginese","comment":" ","type":"Random.Generator Char.Char"},{"name":"buhid","comment":" ","type":"Random.Generator Char.Char"},{"name":"byzantineMusicalSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"carian","comment":" ","type":"Random.Generator Char.Char"},{"name":"chakma","comment":" ","type":"Random.Generator Char.Char"},{"name":"cham","comment":" ","type":"Random.Generator Char.Char"},{"name":"char","comment":" Generate a random character within a certain keyCode range\n\n    lowerCaseLetter =\n        char 65 90\n\n","type":"Basics.Int -> Basics.Int -> Random.Generator Char.Char"},{"name":"cherokee","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkCompatibility","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkCompatibilityForm","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkCompatibilityIdeograph","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkCompatibilityIdeographSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkRadicalSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkStroke","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkSymbolOrPunctuation","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkUnifiedIdeograph","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkUnifiedIdeographExtensionA","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkUnifiedIdeographExtensionB","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkUnifiedIdeographExtensionC","comment":" ","type":"Random.Generator Char.Char"},{"name":"cjkUnifiedIdeographExtensionD","comment":" ","type":"Random.Generator Char.Char"},{"name":"combiningDiacriticalMarks","comment":" ","type":"Random.Generator Char.Char"},{"name":"combiningDiacriticalMarksForSymbols","comment":" ","type":"Random.Generator Char.Char"},{"name":"combiningDiacriticalMarksSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"combiningHalfMark","comment":" ","type":"Random.Generator Char.Char"},{"name":"commonIndicNumberForm","comment":" ","type":"Random.Generator Char.Char"},{"name":"controlPicture","comment":" ","type":"Random.Generator Char.Char"},{"name":"coptic","comment":" ","type":"Random.Generator Char.Char"},{"name":"countingRodNumeral","comment":" ","type":"Random.Generator Char.Char"},{"name":"cuneiform","comment":" ","type":"Random.Generator Char.Char"},{"name":"cuneiformNumberOrPunctuation","comment":" ","type":"Random.Generator Char.Char"},{"name":"currencySymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"cypriotSyllable","comment":" ","type":"Random.Generator Char.Char"},{"name":"cyrillic","comment":" ","type":"Random.Generator Char.Char"},{"name":"cyrillicExtendedA","comment":" ","type":"Random.Generator Char.Char"},{"name":"cyrillicExtendedB","comment":" ","type":"Random.Generator Char.Char"},{"name":"cyrillicSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"deseret","comment":" ","type":"Random.Generator Char.Char"},{"name":"devanagari","comment":" ","type":"Random.Generator Char.Char"},{"name":"devanagariExtended","comment":" ","type":"Random.Generator Char.Char"},{"name":"dingbat","comment":" ","type":"Random.Generator Char.Char"},{"name":"dominoTile","comment":" ","type":"Random.Generator Char.Char"},{"name":"egyptianHieroglyph","comment":" ","type":"Random.Generator Char.Char"},{"name":"emoticon","comment":" ","type":"Random.Generator Char.Char"},{"name":"enclosedAlphanumeric","comment":" ","type":"Random.Generator Char.Char"},{"name":"enclosedAlphanumericSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"enclosedCJKLetterOrMonth","comment":" ","type":"Random.Generator Char.Char"},{"name":"enclosedIdeographicSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"english","comment":" Generate a random English Letter (alias for `latin`)\n","type":"Random.Generator Char.Char"},{"name":"ethiopic","comment":" ","type":"Random.Generator Char.Char"},{"name":"ethiopicExtended","comment":" ","type":"Random.Generator Char.Char"},{"name":"ethiopicExtendedA","comment":" ","type":"Random.Generator Char.Char"},{"name":"ethiopicSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"generalPunctuation","comment":" ","type":"Random.Generator Char.Char"},{"name":"geometricShape","comment":" ","type":"Random.Generator Char.Char"},{"name":"georgian","comment":" ","type":"Random.Generator Char.Char"},{"name":"georgianSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"glagolitic","comment":" ","type":"Random.Generator Char.Char"},{"name":"gothic","comment":" ","type":"Random.Generator Char.Char"},{"name":"greekAndCoptic","comment":" ","type":"Random.Generator Char.Char"},{"name":"greekExtended","comment":" ","type":"Random.Generator Char.Char"},{"name":"gujarati","comment":" ","type":"Random.Generator Char.Char"},{"name":"gurmukhi","comment":" ","type":"Random.Generator Char.Char"},{"name":"halfwidthOrFullwidthForm","comment":" ","type":"Random.Generator Char.Char"},{"name":"hangulCompatibilityJamo","comment":" ","type":"Random.Generator Char.Char"},{"name":"hangulJamo","comment":" ","type":"Random.Generator Char.Char"},{"name":"hangulJamoExtendedA","comment":" ","type":"Random.Generator Char.Char"},{"name":"hangulJamoExtendedB","comment":" ","type":"Random.Generator Char.Char"},{"name":"hangulSyllable","comment":" ","type":"Random.Generator Char.Char"},{"name":"hanunoo","comment":" ","type":"Random.Generator Char.Char"},{"name":"hebrew","comment":" ","type":"Random.Generator Char.Char"},{"name":"highPrivateUseSurrogate","comment":" ","type":"Random.Generator Char.Char"},{"name":"highSurrogate","comment":" ","type":"Random.Generator Char.Char"},{"name":"hiragana","comment":" ","type":"Random.Generator Char.Char"},{"name":"ideographicDescription","comment":" ","type":"Random.Generator Char.Char"},{"name":"imperialAramaic","comment":" ","type":"Random.Generator Char.Char"},{"name":"inscriptionalPahlavi","comment":" ","type":"Random.Generator Char.Char"},{"name":"inscriptionalParthian","comment":" ","type":"Random.Generator Char.Char"},{"name":"ipaExtensions","comment":" ","type":"Random.Generator Char.Char"},{"name":"javanese","comment":" ","type":"Random.Generator Char.Char"},{"name":"kaithi","comment":" ","type":"Random.Generator Char.Char"},{"name":"kanaSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"kanbun","comment":" ","type":"Random.Generator Char.Char"},{"name":"kangxiRadical","comment":" ","type":"Random.Generator Char.Char"},{"name":"kannada","comment":" ","type":"Random.Generator Char.Char"},{"name":"katakana","comment":" ","type":"Random.Generator Char.Char"},{"name":"katakanaPhoneticExtension","comment":" ","type":"Random.Generator Char.Char"},{"name":"kayahLi","comment":" ","type":"Random.Generator Char.Char"},{"name":"kharoshthi","comment":" ","type":"Random.Generator Char.Char"},{"name":"khmer","comment":" ","type":"Random.Generator Char.Char"},{"name":"khmerSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"lao","comment":" ","type":"Random.Generator Char.Char"},{"name":"latin","comment":" Generate a random Latin Letter\n","type":"Random.Generator Char.Char"},{"name":"latin1Supplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"latinExtendedA","comment":" ","type":"Random.Generator Char.Char"},{"name":"latinExtendedAdditional","comment":" ","type":"Random.Generator Char.Char"},{"name":"latinExtendedB","comment":" ","type":"Random.Generator Char.Char"},{"name":"latinExtendedC","comment":" ","type":"Random.Generator Char.Char"},{"name":"latinExtendedD","comment":" ","type":"Random.Generator Char.Char"},{"name":"lepcha","comment":" ","type":"Random.Generator Char.Char"},{"name":"letterlikeSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"limbu","comment":" ","type":"Random.Generator Char.Char"},{"name":"linearBIdeogram","comment":" ","type":"Random.Generator Char.Char"},{"name":"linearBSyllable","comment":" ","type":"Random.Generator Char.Char"},{"name":"lisu","comment":" ","type":"Random.Generator Char.Char"},{"name":"lowSurrogate","comment":" ","type":"Random.Generator Char.Char"},{"name":"lowerCaseLatin","comment":" Generate a random lower-case Latin Letter\n","type":"Random.Generator Char.Char"},{"name":"lycian","comment":" ","type":"Random.Generator Char.Char"},{"name":"lydian","comment":" ","type":"Random.Generator Char.Char"},{"name":"mahjongTile","comment":" ","type":"Random.Generator Char.Char"},{"name":"malayalam","comment":" ","type":"Random.Generator Char.Char"},{"name":"mandaic","comment":" ","type":"Random.Generator Char.Char"},{"name":"mathematicalAlphanumericSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"mathematicalOperator","comment":" ","type":"Random.Generator Char.Char"},{"name":"meeteiMayek","comment":" ","type":"Random.Generator Char.Char"},{"name":"meeteiMayekExtension","comment":" ","type":"Random.Generator Char.Char"},{"name":"meroiticCursive","comment":" ","type":"Random.Generator Char.Char"},{"name":"meroiticHieroglyph","comment":" ","type":"Random.Generator Char.Char"},{"name":"miao","comment":" ","type":"Random.Generator Char.Char"},{"name":"miscellaneousMathematicalSymbolA","comment":" ","type":"Random.Generator Char.Char"},{"name":"miscellaneousMathematicalSymbolB","comment":" ","type":"Random.Generator Char.Char"},{"name":"miscellaneousSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"miscellaneousSymbolOrArrow","comment":" ","type":"Random.Generator Char.Char"},{"name":"miscellaneousSymbolOrPictograph","comment":" ","type":"Random.Generator Char.Char"},{"name":"miscellaneousTechnical","comment":" ","type":"Random.Generator Char.Char"},{"name":"modifierToneLetter","comment":" ","type":"Random.Generator Char.Char"},{"name":"mongolian","comment":" ","type":"Random.Generator Char.Char"},{"name":"musicalSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"myanmar","comment":" ","type":"Random.Generator Char.Char"},{"name":"myanmarExtendedA","comment":" ","type":"Random.Generator Char.Char"},{"name":"newTaiLue","comment":" ","type":"Random.Generator Char.Char"},{"name":"nko","comment":" ","type":"Random.Generator Char.Char"},{"name":"numberForm","comment":" ","type":"Random.Generator Char.Char"},{"name":"ogham","comment":" ","type":"Random.Generator Char.Char"},{"name":"olChiki","comment":" ","type":"Random.Generator Char.Char"},{"name":"oldItalic","comment":" ","type":"Random.Generator Char.Char"},{"name":"oldPersian","comment":" ","type":"Random.Generator Char.Char"},{"name":"oldSouthArabian","comment":" ","type":"Random.Generator Char.Char"},{"name":"oldTurkic","comment":" ","type":"Random.Generator Char.Char"},{"name":"opticalCharacterRecognition","comment":" ","type":"Random.Generator Char.Char"},{"name":"oriya","comment":" ","type":"Random.Generator Char.Char"},{"name":"osmanya","comment":" ","type":"Random.Generator Char.Char"},{"name":"phagsPa","comment":" ","type":"Random.Generator Char.Char"},{"name":"phaistosDisc","comment":" ","type":"Random.Generator Char.Char"},{"name":"phoenician","comment":" ","type":"Random.Generator Char.Char"},{"name":"phoneticExtensions","comment":" ","type":"Random.Generator Char.Char"},{"name":"phoneticExtensionsSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"playingCard","comment":" ","type":"Random.Generator Char.Char"},{"name":"privateUseArea","comment":" ","type":"Random.Generator Char.Char"},{"name":"rejang","comment":" ","type":"Random.Generator Char.Char"},{"name":"rumiNumericalSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"runic","comment":" ","type":"Random.Generator Char.Char"},{"name":"samaritan","comment":" ","type":"Random.Generator Char.Char"},{"name":"saurashtra","comment":" ","type":"Random.Generator Char.Char"},{"name":"sharada","comment":" ","type":"Random.Generator Char.Char"},{"name":"shavian","comment":" ","type":"Random.Generator Char.Char"},{"name":"sinhala","comment":" ","type":"Random.Generator Char.Char"},{"name":"smallFormVariant","comment":" ","type":"Random.Generator Char.Char"},{"name":"soraSompeng","comment":" ","type":"Random.Generator Char.Char"},{"name":"spacingModifier","comment":" ","type":"Random.Generator Char.Char"},{"name":"special","comment":" ","type":"Random.Generator Char.Char"},{"name":"sundanese","comment":" ","type":"Random.Generator Char.Char"},{"name":"sundaneseSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"superscriptOrSubscript","comment":" ","type":"Random.Generator Char.Char"},{"name":"supplementalArrowA","comment":" ","type":"Random.Generator Char.Char"},{"name":"supplementalArrowB","comment":" ","type":"Random.Generator Char.Char"},{"name":"supplementalMathematicalOperator","comment":" ","type":"Random.Generator Char.Char"},{"name":"supplementalPunctuation","comment":" ","type":"Random.Generator Char.Char"},{"name":"supplementaryPrivateUseAreaA","comment":" ","type":"Random.Generator Char.Char"},{"name":"supplementaryPrivateUseAreaB","comment":" ","type":"Random.Generator Char.Char"},{"name":"sylotiNagri","comment":" ","type":"Random.Generator Char.Char"},{"name":"syriac","comment":" ","type":"Random.Generator Char.Char"},{"name":"tag","comment":" ","type":"Random.Generator Char.Char"},{"name":"tagalog","comment":" ","type":"Random.Generator Char.Char"},{"name":"tagbanwa","comment":" ","type":"Random.Generator Char.Char"},{"name":"taiLe","comment":" ","type":"Random.Generator Char.Char"},{"name":"taiTham","comment":" ","type":"Random.Generator Char.Char"},{"name":"taiViet","comment":" ","type":"Random.Generator Char.Char"},{"name":"taiXuanJingSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"takri","comment":" ","type":"Random.Generator Char.Char"},{"name":"tamil","comment":" ","type":"Random.Generator Char.Char"},{"name":"telugu","comment":" ","type":"Random.Generator Char.Char"},{"name":"thaana","comment":" ","type":"Random.Generator Char.Char"},{"name":"thai","comment":" ","type":"Random.Generator Char.Char"},{"name":"tibetan","comment":" ","type":"Random.Generator Char.Char"},{"name":"tifinagh","comment":" ","type":"Random.Generator Char.Char"},{"name":"transportOrMapSymbol","comment":" ","type":"Random.Generator Char.Char"},{"name":"ugaritic","comment":" ","type":"Random.Generator Char.Char"},{"name":"unicode","comment":" Generate a random Character in the valid unicode range.\nNote: This can produce garbage values as unicode doesn't use all valid values.\nTo test for specific languages and character sets, use the appropriate one\nfrom the list.\n","type":"Random.Generator Char.Char"},{"name":"unifiedCanadianAboriginalSyllabic","comment":" ","type":"Random.Generator Char.Char"},{"name":"unifiedCanadianAboriginalSyllabicExtended","comment":" ","type":"Random.Generator Char.Char"},{"name":"upperCaseLatin","comment":" Generate a random upper-case Latin Letter\n","type":"Random.Generator Char.Char"},{"name":"vai","comment":" ","type":"Random.Generator Char.Char"},{"name":"variationSelector","comment":" ","type":"Random.Generator Char.Char"},{"name":"variationSelectorSupplement","comment":" ","type":"Random.Generator Char.Char"},{"name":"vedicExtensions","comment":" ","type":"Random.Generator Char.Char"},{"name":"verticalForm","comment":" ","type":"Random.Generator Char.Char"},{"name":"yiRadical","comment":" ","type":"Random.Generator Char.Char"},{"name":"yiSyllable","comment":" ","type":"Random.Generator Char.Char"},{"name":"yijingHexagramSymbol","comment":" ","type":"Random.Generator Char.Char"}],"binops":[]},{"name":"Random.Date","comment":" Extra randomized functions on dates (see `elm/time`).\n\nWe only provide generators for days and months. Other generators are trivial for you to implement yourself and can be made specific to your needs.\n\n\n# Generators\n\n@docs weekday, month\n\n","unions":[],"aliases":[],"values":[{"name":"month","comment":" Generate a random month of the year.\n","type":"Random.Generator Time.Month"},{"name":"weekday","comment":" Generate a random day of the week.\n","type":"Random.Generator Time.Weekday"}],"binops":[]},{"name":"Random.Dict","comment":" Extra randomized functions on dicts.\n\n\n# Generators\n\n@docs dict, rangeLengthDict\n\n","unions":[],"aliases":[],"values":[{"name":"dict","comment":" Generate a random dict with given length, key generator, and value generator\n\n    randomLength10StringIntDict =\n        dict 10 (englishWord 10) (int 0 100)\n\n","type":"Basics.Int -> Random.Generator comparable -> Random.Generator value -> Random.Generator (Dict.Dict comparable value)"},{"name":"rangeLengthDict","comment":" Generate a random dict of random length given a minimum length and\na maximum length.\n","type":"Basics.Int -> Basics.Int -> Random.Generator comparable -> Random.Generator value -> Random.Generator (Dict.Dict comparable value)"}],"binops":[]},{"name":"Random.Extra","comment":" This module provides many common and general-purpose helper functions for\ncore's Random library. You can find even more useful functions for a particular\ntype in the other modules.\n\n\n# Values\n\n@docs bool\n\n\n# Maps\n\nFor `map` and `mapN` up through N=5, use the core library.\n\n@docs map6, andMap\n\n\n# New Generators\n\n@docs oneIn, maybe, result, choice\n\n\n# Working with Lists\n\n@docs sequence, traverse, choices, frequency, sample, combine, rangeLengthList\n\n\n# Filtered Generators\n\n@docs filter\n\n\n# andThenN\n\nThese functions are like `mapN` except the function you pass in does not return\nan exact value, but instead another generator. That means you can take in several\nrandom arguments to drive more randomness.\n\n@docs andThen2, andThen3, andThen4, andThen5, andThen6\n\n","unions":[],"aliases":[],"values":[{"name":"andMap","comment":" Map over any number of generators.\n\n    type alias Person = -- some large record\n\n    randomPerson : Generator Person\n    randomPerson =\n      map Person genFirstName\n        |> andMap genLastName\n        |> andMap genBirthday\n        |> andMap genPhoneNumber\n        |> andMap genAddress\n        |> andMap genEmail\n\n","type":"Random.Generator a -> Random.Generator (a -> b) -> Random.Generator b"},{"name":"andThen2","comment":" ","type":"(a -> b -> Random.Generator c) -> Random.Generator a -> Random.Generator b -> Random.Generator c"},{"name":"andThen3","comment":" ","type":"(a -> b -> c -> Random.Generator d) -> Random.Generator a -> Random.Generator b -> Random.Generator c -> Random.Generator d"},{"name":"andThen4","comment":" ","type":"(a -> b -> c -> d -> Random.Generator e) -> Random.Generator a -> Random.Generator b -> Random.Generator c -> Random.Generator d -> Random.Generator e"},{"name":"andThen5","comment":" ","type":"(a -> b -> c -> d -> e -> Random.Generator f) -> Random.Generator a -> Random.Generator b -> Random.Generator c -> Random.Generator d -> Random.Generator e -> Random.Generator f"},{"name":"andThen6","comment":" ","type":"(a -> b -> c -> d -> e -> f -> Random.Generator g) -> Random.Generator a -> Random.Generator b -> Random.Generator c -> Random.Generator d -> Random.Generator e -> Random.Generator f -> Random.Generator g"},{"name":"bool","comment":" An unbiased generator of `Bool` values.\n","type":"Random.Generator Basics.Bool"},{"name":"choice","comment":" Choose between two values with equal probability.\n\n    type Flip\n        = Heads\n        | Tails\n\n    coinFlip : Generator Flip\n    coinFlip =\n        choice Heads Tails\n\nNote that this function takes values, not generators. That's because it's meant\nto be a lightweight helper for a specific use. If you need to choose between two\ngenerators, use `choices [gen1, gen2]`.\n\n","type":"a -> a -> Random.Generator a"},{"name":"choices","comment":" Create a generator that chooses a generator from a list of generators\nwith equal probability.\n\nWe guarantee a nonempty list is passed by splitting it into two arguments.\n\n","type":"Random.Generator a -> List.List (Random.Generator a) -> Random.Generator a"},{"name":"combine","comment":" Turn a list of generators into a generator of lists.\n","type":"List.List (Random.Generator a) -> Random.Generator (List.List a)"},{"name":"filter","comment":" Filter a generator so that all generated values satisfy the given predicate.\n\n    evens : Generator Int\n    evens =\n        filter (\\i -> i % 2 == 0) (int minInt maxInt)\n\n**Warning:** If the predicate is unsatisfiable, the generator will not\nterminate, your application will crash with a stack overflow, and you will be\nsad. You should also avoid predicates that are merely very difficult to satisfy.\n\n    badCrashingGenerator =\n        filter (\\_ -> False) anotherGenerator\n\n    likelyCrashingGenerator =\n        filter (\\i -> i % 2000 == 0) (int minInt maxInt)\n\n","type":"(a -> Basics.Bool) -> Random.Generator a -> Random.Generator a"},{"name":"frequency","comment":" Create a generator that chooses a generator from a list of generators\nbased on the provided weight. The likelihood of a given generator being\nchosen is its weight divided by the total weight (which doesn't have to equal 1).\n\nWe guarantee a nonempty list is passed by splitting it into two arguments.\n\n","type":"( Basics.Float, Random.Generator a ) -> List.List ( Basics.Float, Random.Generator a ) -> Random.Generator a"},{"name":"map6","comment":" Map a function of six arguments over six generators.\n","type":"(a -> b -> c -> d -> e -> f -> g) -> Random.Generator a -> Random.Generator b -> Random.Generator c -> Random.Generator d -> Random.Generator e -> Random.Generator f -> Random.Generator g"},{"name":"maybe","comment":" Produce `Just` a value on `True`, and `Nothing` on `False`.\n\nYou can use `bool` or `oneIn n` for the first argument.\n\n","type":"Random.Generator Basics.Bool -> Random.Generator a -> Random.Generator (Maybe.Maybe a)"},{"name":"oneIn","comment":" Produce `True` one-in-n times on average.\n\nDo not pass a value less then one to this function.\n\n    flippedHeads =\n        oneIn 2\n\n    rolled6 =\n        oneIn 6\n\n","type":"Basics.Int -> Random.Generator Basics.Bool"},{"name":"rangeLengthList","comment":" Generate a random list of random length given a minimum length and\na maximum length.\n","type":"Basics.Int -> Basics.Int -> Random.Generator a -> Random.Generator (List.List a)"},{"name":"result","comment":" Produce an `Ok` a value on `True`, and an `Err` value on `False`.\n\nYou can use `bool` or `oneIn n` for the first argument.\n\n","type":"Random.Generator Basics.Bool -> Random.Generator err -> Random.Generator val -> Random.Generator (Result.Result err val)"},{"name":"sample","comment":" Given a list, choose an element uniformly at random. `Nothing` is only\nproduced if the list is empty.\n\n    type Direction\n        = North\n        | South\n        | East\n        | West\n\n    direction : Generator Direction\n    direction =\n        sample [ North, South, East, West ]\n            |> map (Maybe.withDefault North)\n\n","type":"List.List a -> Random.Generator (Maybe.Maybe a)"},{"name":"sequence","comment":" Start with a list of generators, and turn them into a generator that returns a list.\n","type":"List.List (Random.Generator a) -> Random.Generator (List.List a)"},{"name":"traverse","comment":" Apply a function that returns a generator to each element of a list,\nand turn it into a generator that returns a list.\n","type":"(a -> Random.Generator b) -> List.List a -> Random.Generator (List.List b)"}],"binops":[]},{"name":"Random.Float","comment":" Extra randomized functions on floats.\n\n\n# Arithmetic Generators\n\n@docs anyFloat, positiveFloat, negativeFloat, floatGreaterThan, floatLessThan\n\n\n# Gaussian Generators\n\n@docs normal, standardNormal\n\n","unions":[],"aliases":[],"values":[{"name":"anyFloat","comment":" A generator that generates any float\n","type":"Random.Generator Basics.Float"},{"name":"floatGreaterThan","comment":" A generator that generates a float greater than a given float\n","type":"Basics.Float -> Random.Generator Basics.Float"},{"name":"floatLessThan","comment":" A generator that generates a float less than a given float\n","type":"Basics.Float -> Random.Generator Basics.Float"},{"name":"negativeFloat","comment":" A generator that generates any negative float\n","type":"Random.Generator Basics.Float"},{"name":"normal","comment":" Create a generator of floats that is normally distributed with\ngiven mean and standard deviation.\n","type":"Basics.Float -> Basics.Float -> Random.Generator Basics.Float"},{"name":"positiveFloat","comment":" A generator that generates any positive float\n","type":"Random.Generator Basics.Float"},{"name":"standardNormal","comment":" A generator that follows a standard normal distribution (as opposed to\na uniform distribution)\n","type":"Random.Generator Basics.Float"}],"binops":[]},{"name":"Random.Int","comment":" Extra randomized functions on ints.\n\n\n# Generators\n\n@docs anyInt, positiveInt, negativeInt, intGreaterThan, intLessThan\n\n","unions":[],"aliases":[],"values":[{"name":"anyInt","comment":" A generator that generates any int that can be generated by the\nrandom generator algorithm.\n","type":"Random.Generator Basics.Int"},{"name":"intGreaterThan","comment":" A generator that generates an int greater than a given int\n","type":"Basics.Int -> Random.Generator Basics.Int"},{"name":"intLessThan","comment":" A generator that generates an int less than a given int\n","type":"Basics.Int -> Random.Generator Basics.Int"},{"name":"negativeInt","comment":" A generator that generates a negative int\n","type":"Random.Generator Basics.Int"},{"name":"positiveInt","comment":" A generator that generates a positive int\n","type":"Random.Generator Basics.Int"}],"binops":[]},{"name":"Random.List","comment":" Extra randomized functions on lists.\n\n\n# Work with a List\n\n@docs choose, shuffle, choices\n\n","unions":[],"aliases":[],"values":[{"name":"choices","comment":" Repeated sample without replacement: produce a list of randomly\nselected elements of some list, and the list of unselected elements.\n","type":"Basics.Int -> List.List a -> Random.Generator ( List.List a, List.List a )"},{"name":"choose","comment":" Sample without replacement: produce a randomly selected element of the\nlist, and the list with that element omitted. If the list is empty, the\nselected element will be `Nothing`.\n","type":"List.List a -> Random.Generator ( Maybe.Maybe a, List.List a )"},{"name":"shuffle","comment":" Shuffle the list. Takes O(_n_ log _n_) time and no extra space.\n","type":"List.List a -> Random.Generator (List.List a)"}],"binops":[]},{"name":"Random.Order","comment":" An extra random generator for the `Order` type.\n\n@docs order\n\n","unions":[],"aliases":[],"values":[{"name":"order","comment":" Generate a random order with equal probability.\n","type":"Random.Generator Basics.Order"}],"binops":[]},{"name":"Random.Set","comment":" Extra randomized functions on sets.\n\n\n# Create a Set\n\n@docs set\n\n\n# Create a Generator\n\n@docs sample\n\n\n# Modify a Generator\n\n@docs notInSet\n\n","unions":[],"aliases":[],"values":[{"name":"notInSet","comment":" Filter a generator of all values not in a given set.\n","type":"Set.Set comparable -> Random.Generator comparable -> Random.Generator comparable"},{"name":"sample","comment":" Select a value from a set uniformly at random, or `Nothing` for an empty set.\nAnalogous to `Random.Extra.sample` but with sets.\n","type":"Set.Set comparable -> Random.Generator (Maybe.Maybe comparable)"},{"name":"set","comment":" Generate a set of at most the given size from a generator.\n\nThe size of a generated set is limited both by the integer provided and the\nnumber of unique values the generator can produce. It is very likely, but not\nguaranteed, that generated sets will be as big as the smaller of these two limits.\n\n","type":"Basics.Int -> Random.Generator comparable -> Random.Generator (Set.Set comparable)"}],"binops":[]},{"name":"Random.String","comment":" Extra randomized functions on strings.\n\n\n# Create a String\n\n@docs string, rangeLengthString\n\n","unions":[],"aliases":[],"values":[{"name":"rangeLengthString","comment":" Generates a random string of random length given the minimum length\nand maximum length and a given character generator.\n","type":"Basics.Int -> Basics.Int -> Random.Generator Char.Char -> Random.Generator String.String"},{"name":"string","comment":" Generate a random string of a given length with a given character generator\n\n    fiveLetterEnglishWord =\n        string 5 Random.Char.english\n\n","type":"Basics.Int -> Random.Generator Char.Char -> Random.Generator String.String"}],"binops":[]}]

package/.elm/0.19.1/packages/f0i/statistics/2.0.0/LICENSE

@@ -1,11 +0,0 @@
-Copyright 2020-present Martin Sigloch
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/.elm/0.19.1/packages/f0i/statistics/2.0.0/README.md

@@ -1,73 +0,0 @@
-# Fast Statistic functions for Lists of Float and Int
-
-This package provides functions to get common statistic functions over lists of numbers.
-
-If you need a function that is currently not included,
-please let me know by creating an [Issue in Github](https://github.com/f0i/statistics/issues/new)
-or send me an email at [elm-statistics@f0i.de](mailto:elm-statistics@f0i.de?subject=github:f0i/statistics).
-Same thing for performance improvements, ideas, sponsoring and job offers.
-
-Performance tests and comparision to other libraries can be found in the benchmark directory or at [f0i.de/projects/elm-statistics](https://f0i.de/projects/elm-statistics).
-
-## Install
-
-```
-elm install f0i/statistics
-```
-
-
-## Examples
-
-```elm
-$ elm repl
-
-> import FStatistics as Stat
--- This is the test data for the following examples:
-> data = [1, 1, 2, 2, 4, 8, 8, 9]
-[1,1,2,2,4,8,8,9]
-
-> data |> Stat.avg
-Just 4.375 : Maybe Float
-
-> data |> Stat.mean -- alias for avg
-Just 4.375 : Maybe Float
-
-> data |> Stat.occurrences
-Dict.fromList [(1,2),(2,2),(4,1),(8,2),(9,1)]
-    : Dict.Dict number Int
-
-> data |> Stat.minmax
-Just (1,9) : Maybe ( number, number )
-
-> data |> Stat.stdDeviation
-Just 3.1991209730174317 : Maybe Float
-
--- Get the element 25% into the list (interpolated between closest values)
-> data |> Stat.percentile 0.25
-Just 1.75 : Maybe Float
-
--- Some functions have a separate implementation for list of Int
-> data |> Stat.percentileInt 0.75
-Just 8 : Maybe Int
-
->
-```
-
-The complete list of function definitions can be found in
-[the package documentation](https://package.elm-lang.org/packages/f0i/statistics/latest/Statistics)
-
-
-## Development
-
-This package uses elm-test and elm-benchmark.
-There are make inside the [makefile](makefile) to run these tests whenever a file changes.
-
-## Alternatives
-
-There are some other libraries which provide statistics functions:
-
-* https://package.elm-lang.org/packages/gampleman/elm-visualization/latest/
-* https://package.elm-lang.org/packages/BrianHicks/elm-trend/latest/
-* https://package.elm-lang.org/packages/jxxcarlson/elm-stat/latest
-
-See https://f0i.de/projects/elm-statistics for performance comparision.

package/.elm/0.19.1/packages/f0i/statistics/2.0.0/docs.json

@@ -1 +0,0 @@
-[{"name":"FStatistics","comment":" Fast Statistics functions for elm\n\n\n# Average\n\n@docs avg, avgInt, mean, meanInt\n@docs median, medianInt, percentile, percentileInt\n@docs percentiles, percentilesInt\n\n\n# Minimum / maximum\n\n@docs minimum, maximum, minmax\n\n\n# Distribution\n\n@docs occurrences\n@docs variance, varianceInt\n@docs stdDeviation, stdDeviationInt\n\n\n# Misc\n\n@docs atLeast, atMost, sum, product\n\n","unions":[],"aliases":[],"values":[{"name":"atLeast","comment":" Alias for `max`, to make piped usage more intuitive\n\n    number |> atLeast 5\n\n","type":"number -> number -> number"},{"name":"atMost","comment":" Alias for `min`, to make piped usage more intuitive\n\n    number |> atMost 5\n\n","type":"number -> number -> number"},{"name":"avg","comment":" Calculate the mean of a list of Float\n","type":"List.List Basics.Float -> Maybe.Maybe Basics.Float"},{"name":"avgInt","comment":" Calculate the mean of a list of Int\n","type":"List.List Basics.Int -> Maybe.Maybe Basics.Int"},{"name":"maximum","comment":" Alias for List.maximum\n","type":"List.List number -> Maybe.Maybe number"},{"name":"mean","comment":" Alias for avg\n","type":"List.List Basics.Float -> Maybe.Maybe Basics.Float"},{"name":"meanInt","comment":" Alias for avgInt\n","type":"List.List Basics.Int -> Maybe.Maybe Basics.Int"},{"name":"median","comment":" Get the median of a sorted list of Float\n\nIf the length of the list is even, the retun value is the average of the two\nvalues at the middle of the list.\nReturns `Nothing` if the list is empty\n\n","type":"List.List Basics.Float -> Maybe.Maybe Basics.Float"},{"name":"medianInt","comment":" Get the median of a sorted list of Int\n\nIf the length of the list is even, the retun value is the average of the two\nvalues at the middle of the list.\nReturns `Nothing` if the list is empty\n\n","type":"List.List Basics.Int -> Maybe.Maybe Basics.Int"},{"name":"minimum","comment":" Alias for List.minimum\n","type":"List.List number -> Maybe.Maybe number"},{"name":"minmax","comment":" Get minimum and maximum from list\n\nReturns `Nothing` if list is empty\n\n","type":"List.List number -> Maybe.Maybe ( number, number )"},{"name":"occurrences","comment":" Get a `Dict` containing the numbers from the list as keys\nand the number of occurrences for each number as value\n","type":"List.List number -> Dict.Dict number Basics.Int"},{"name":"percentile","comment":" Get the element at a position in percent from a list\n\nIf the percentage doesn't exactly match an element the value is interpolated\nfrom the two closest elements\n\n","type":"Basics.Float -> List.List Basics.Float -> Maybe.Maybe Basics.Float"},{"name":"percentileInt","comment":" Get the element at a position in percent from a list\n\nIf the percentage doesn't exactly match an element the value is interpolated\nfrom the two closest elements\n\n","type":"Basics.Float -> List.List Basics.Int -> Maybe.Maybe Basics.Int"},{"name":"percentiles","comment":" Get elements at multiple positions in percent from a list\n\nIf the percentage doesn't exactly match an element the value is interpolated\nfrom the two closest elements\n\n","type":"List.List Basics.Float -> List.List Basics.Float -> List.List Basics.Float"},{"name":"percentilesInt","comment":" Get elements at multiple positions in percent from a list\n\nIf the percentage doesn't exactly match an element the value is interpolated\nfrom the two closest elements\n\n","type":"List.List Basics.Float -> List.List Basics.Int -> List.List Basics.Int"},{"name":"product","comment":" Alias for List.product\n","type":"List.List number -> number"},{"name":"stdDeviation","comment":" Get the standard deviation of a population of Float\n","type":"List.List Basics.Float -> Maybe.Maybe Basics.Float"},{"name":"stdDeviationInt","comment":" Get the standard deviation of a population of Int\n","type":"List.List Basics.Int -> Maybe.Maybe Basics.Int"},{"name":"sum","comment":" Alias for List.sum\n","type":"List.List number -> number"},{"name":"variance","comment":" Get The variance of a population of int\nThis function uses mostly Int calculations wich can cause rounding errors.\nSee function `variance` (which uses Float) for more precise results.\n","type":"List.List Basics.Float -> Maybe.Maybe Basics.Float"},{"name":"varianceInt","comment":" Get The variance of a population of int\nThis function uses mostly Int calculations wich can cause rounding errors.\nSee function `variance` (which uses Float) for more precise results.\n","type":"List.List Basics.Int -> Maybe.Maybe Basics.Int"}],"binops":[]}]