[{"name":"N","comment":" Natural number within a typed range\n\n@docs N\n\n\n# bounds\n\n@docs In, Min, Infinity, Exactly\n@docs On, Up, To, Down\n\n\n# create\n\n@docs inRandom, inFuzz, inFuzzUniform\n\n[`ArraySized.upTo`](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/ArraySized#upTo)\nto create increasing [`N`](#N)s.\n`ArraySized` will even know the final length in its type!\nWanna try?\n\n\n# specific numbers\n\nIf the package exposed every number 0 → 1000+, [tools can become unusably slow](https://github.com/lue-bird/elm-typesafe-array/issues/2)\n\nSo only 0 → 16 are exposed, while larger numbers have to be generated locally\n\nCurrent method: [generate them](https://lue-bird.github.io/elm-bounded-nat/generate/)\ninto a `module N.Local exposing (n<n>, N<n>, Add<n>, Up<n>, ...)` +\n`import N.Local as N exposing (n<n>, N<n>, Add<n>, Up<n>, ...)`\n\nIn the future, [`elm-generate`](https://github.com/lue-bird/generate-elm) will allow auto-generating via [`elm-review`](https://dark.elm.dmy.fr/packages/jfmengels/elm-review/latest/)\n\ntype `n` [⏭ skip to last](#N16)\n\n@docs N0, N1, N2, N3, N4, N5, N6, N7, N8, N9, N10, N11, N12, N13, N14, N15, N16\n\ntype `n +` [⏭ skip to last](#Add16)\n\n@docs Add1, Add2, Add3, Add4, Add5, Add6, Add7, Add8, Add9, Add10, Add11, Add12, Add13, Add14, Add15, Add16\n\ntype `Up x To (n + x)` [⏭ skip to last](#Up16)\n\n@docs Up0, Up1, Up2, Up3, Up4, Up5, Up6, Up7, Up8, Up9, Up10, Up11, Up12, Up13, Up14, Up15, Up16\n\nexact [⏭ skip to last](#n16)\n\n@docs n0, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13, n14, n15, n16\n\n\n## from `Int`\n\n@docs intToAbsolute, intModBy, intToAtLeast, intToIn\n\n\n### `Int` compare\n\n@docs intIsAtLeast, intIsIn\n\n\n# alter\n\n@docs add, addMin\n@docs subtract, subtractMin, subtractMax\n@docs toPower, remainderBy, multiplyBy, divideBy\n\n\n## clamp\n\n@docs toAtLeastMin, toIn, toInOrAtLeast\n\n\n# compare\n\n@docs isAtLeast, isAtMost\n@docs BelowOrAbove, is, isIn\n@docs greater, smaller\n\nMore advanced stuff in [section type information ) allowable-state](#allowable-state)\n\n\n# transform\n\n@docs toInt, toFloat, toString\n\n\n# without internal functions\n\n@docs inToNumber, inToOn\n@docs minToNumber, minToOn\n@docs maxToNumber, maxToOn\n\n\n# type information\n\n@docs minTo, minSubtract, minEndsSubtract, minTo0\n@docs maxTo, maxToInfinity, maxAdd, maxEndsSubtract\n\n\n## allowable-state\n\nConsider this an advanced technique for packages that use\n[`allowable-state`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/).\nAny questions @lue in slack!\n\n@docs isAtLeast1\n@docs min0Adapt, minAtLeast1Never\n\n\n# miss an operation?\n\nAnything that can't be expressed with the available operations? → issue/PR\n\n\n# safe internals\n\nInternal parts you can safely access and transform\n\nWhile the internally stored `Int` can't directly be guaranteed to be in bounds by elm,\nthe [minimum](#min) and [maximum](#max)\nmust be built as actual values checked by the compiler.\nNo shenanigans like runtime errors for impossible cases\n\nHaving those exposed can be useful when building extensions to this library like\n\n  - [`typesafe-array`](https://dark.elm.dmy.fr/packages/lue-bird/elm-typesafe-array/latest/)\n  - [`morph`](https://github.com/lue-bird/elm-morph)\n  - [`bits`](https://dark.elm.dmy.fr/packages/lue-bird/elm-bits/latest/)\n\n@docs range, min, max\n@docs differenceAdd, differenceSubtract\n@docs addDifference, subtractDifference\n\n@docs N0OrAdd1\n\n\n## ranges\n\n@docs inRange, minRange, maxRange, exactlyRange\n@docs rangeMin, rangeMax\n@docs rangeAdd, rangeSubtract, rangeMinSubtract, rangeMaxSubtract, rangeMaxAdd, rangeMinEndsSubtract, rangeMaxEndsSubtract, rangeMinTo, rangeMaxTo\n\n\n## [allowable-state](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/)\n\n@docs number0Adapt, numberFrom1Map\n@docs on0Adapt, onFrom1Map\n@docs rangeIsAtLeast1, rangeMin0Adapt, rangeMinAtLeast1Never\n\n\n## safe internals without functions\n\n@docs onToNumber, toOn\n@docs rangeInToNumber, rangeInToOn\n@docs rangeMinToNumber, rangeMinToOn\n@docs rangeMaxToNumber, rangeMaxToOn\n\n","unions":[{"name":"BelowOrAbove","comment":" The error result of comparing [`N`](#N)s\n\n  - `Above`: greater than what it's compared against\n  - `Below`: less than what it's compared against\n\nValues exist for each condition\n\n","args":["below","above"],"cases":[["Below",["below"]],["Above",["above"]]]},{"name":"In","comment":" somewhere within a minimum & maximum\n\n       ↓ minimum   ↓ maximum\n    ⨯ [✓ ✓ ✓ ✓ ✓ ✓ ✓] ⨯ ⨯ ⨯...\n\n\n### argument type in a range\n\n    -- 3 ≤ n ≤ 5\n    N (In (On (Add3 minFrom3_)) (Up maxTo5_ To N5))\n\n    -- 0 ≤ n ≤ 100\n    percent : N (In min_ (Up maxTo100_ To N100)) -> Percent\n\nFor every constructable value, the minimum is smaller than the maximum\n(that's why [`In`](#In) is opaque)\n\nIf you want a number where you just care about the minimum, leave `max` as a type _variable_\n\n       ↓ minimum    ↓ maximum or  →\n    ⨯ [✓ ✓ ✓ ✓ ✓ ✓ ✓...\n\n    -- any natural number\n    N (In min_ max_)\n\nA number, at least 5:\n\n    N (In (On (Add5 minFrom_)) max_)\n\n→ `max_` could be a specific maximum or [no maximum at all](#Infinity)\n\n\n### result type in a range\n\n    n3 : N (In (Up3 minX_) (Up3 maxX_))\n\n    between3And6 : N (In (Up3 minX_) (Up6 maxX_))\n\n    between3And6 |> N.add n3\n    --: N (In (Up6 minX_) (Up9 maxX_))\n\n\n### stored type in a range\n\nAn example where this is useful using [typesafe-array](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/):\n\n    type Tree branchingFactor element\n        = Tree\n            element\n            (ArraySized\n                branchingFactor\n                (Maybe (Tree branchingFactor element))\n            )\n\n    type alias TreeBinaryFull element =\n        Tree (Exactly (On N2)) element\n\nRemember: ↑ and other `... (`[`On`](#On)`...)`\nare result/stored types, not argument types\n\n---\n\nDo not use `==` on 2 values storing a range.\nIt will lead to elm crashing because [difference](#Up)s are stored as functions.\nInstead,\n\n  - [compare](#compare) in _your_ code\n  - convert to [a value](#without-internal-functions) for _other_ code\n    that relies (or performs better) on structural `==`\n\n","args":["minimumAsDifference","maximumAsDifference"],"cases":[]},{"name":"Infinity","comment":" \"The limit is unknown\".\n\nUsed in the definition of [`Min`](#Min)\n\n    type alias Min min =\n        In minimum Infinity\n\n","args":[],"cases":[["Infinity",[]]]},{"name":"N","comment":" A **bounded** natural number `>= 0`\n\n\n### result type\n\n    -- ≥ 4\n    N (Min (Up4 x_))\n\n    -- 2 ≤ n ≤ 12\n    N (In (Up2 minX_) (Up12 maxX_))\n\n    -- n3 :\n    N (In (Up3 minX_) (Up3 maxX_))\n\nThe type variable enables adding, subtracting.\nConsider the \"[`Up`](#Up)\" thing an implementation detail\n\n    n3\n        |> N.add n6\n        --: N (In (Up9 minX_) (Up9 maxX_))\n        |> N.multiplyBy n5\n        --: N (Min (Up9 minX_))\n        |> N.remainderBy n4\n        --: N (In (Up0 minX_) (Up3 maxX_))\n        |> N.inToNumber\n    --: N (In N0 N3)\n    --> n1 |> N.minTo n0 |> N.maxTo n3 |> N.inToNumber\n\n\n### argument type\n\n    -- ≥ 0, any limitations allowed\n    N range_\n\n    -- ≥ 4\n    N (In (On (Add4 minFrom4_)) max_)\n\n    -- 4 ≤ n ≤ 15\n    N (In (On (Add4 minFrom4_)) (Up maxTo15_ To N15))\n\n`In (On (Add4 minFrom4_)) (Up maxTo15_ To N15)` says:\n\n  - the argument's minimum is 4 `+` some variable `= 4+0`|`4+1`|`4+2`|...\n    which means it's ≥ 4\n  - the argument's maximum `+` some variable `= 15`\n    which means it's ≤ 15\n\n\n### stored type\n\nwhat to put in declared types like `Model`\n\n    -- ≥ 4\n    N (Min (On N4))\n\n    -- 2 ≤ n ≤ 12\n    N (In (On N2) (On N12))\n\nThere's also versions of this that don't contain functions internally:\n\n    -- ≥ 4\n    N (Min N4)\n\n    -- 2 ≤ n ≤ 12\n    N (In N2 N12)\n\nmore type examples at [`In`](#In), [`Min`](#Min)\n\n","args":["range"],"cases":[]},{"name":"N0OrAdd1","comment":" Base type of [`N0`](#N0), [`Add1 n`](#Add1) following [`allowable-state`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/):\n\n  - Is the parameter `possiblyOrNever` set to `Never` like in\n\n        type alias Add1 n =\n            N0aOrAdd1 Never n\n\n    `N0` is impossible to construct\n\n  - Is the parameter `possiblyOrNever` set to `Possibly` like in\n\n        type alias N0 =\n            N0OrAdd1 Possibly Never\n\n    `N0` is a possible value\n\n","args":["n0PossiblyOrNever","from1"],"cases":[["N0",["n0PossiblyOrNever"]],["Add1",["from1"]]]},{"name":"To","comment":" Just a word in a [difference type](#Up):\n\n    Up low To high\n\n    Down high To low\n\n→ distance `high - low`\n\n","args":[],"cases":[["To",["Basics.Never"]]]},{"name":"Up","comment":" `Up low To high`: a specific number represented as the difference `high - low`\n","args":["lowNumber","toTag","highNumber"],"cases":[["Difference",["{ up : lowNumber -> highNumber, down : highNumber -> lowNumber }"]]]}],"aliases":[{"name":"Add1","comment":" The [natural number](#N0OrAdd1) `1 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never n"},{"name":"Add10","comment":" The [natural number](#N0OrAdd1) `10 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))))))))"},{"name":"Add11","comment":" The [natural number](#N0OrAdd1) `11 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))))))))))"},{"name":"Add12","comment":" The [natural number](#N0OrAdd1) `12 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))))))))))"},{"name":"Add13","comment":" The [natural number](#N0OrAdd1) `13 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))))))))))))"},{"name":"Add14","comment":" The [natural number](#N0OrAdd1) `14 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))))))))))))"},{"name":"Add15","comment":" The [natural number](#N0OrAdd1) `15 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))))))))))))))"},{"name":"Add16","comment":" The [natural number](#N0OrAdd1) `16 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))))))))))))))"},{"name":"Add2","comment":" The [natural number](#N0OrAdd1) `2 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)"},{"name":"Add3","comment":" The [natural number](#N0OrAdd1) `3 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))"},{"name":"Add4","comment":" The [natural number](#N0OrAdd1) `4 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))"},{"name":"Add5","comment":" The [natural number](#N0OrAdd1) `5 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))))"},{"name":"Add6","comment":" The [natural number](#N0OrAdd1) `6 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))))"},{"name":"Add7","comment":" The [natural number](#N0OrAdd1) `7 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))))))"},{"name":"Add8","comment":" The [natural number](#N0OrAdd1) `8 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n)))))))"},{"name":"Add9","comment":" The [natural number](#N0OrAdd1) `9 +` a given `n`\n","args":["n"],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never n))))))))"},{"name":"Down","comment":" `Down high To low`: a specific number represented as the difference `high - low`\n","args":["high","toTag","low"],"type":"N.Up low toTag high"},{"name":"Exactly","comment":" Allow only a specific given represented number\n\nresult type:\n\n    Exactly (On N3)\n\nUse `Exactly  ...` without [`On`](#On)\nfor **storing** in a type [without internal functions](#without-internal-functions)\n\n    Exactly N3\n\nThis is pretty useless in combination with [`N`](#N)\n\n    -- argument type\n    numberToInt : N (Exactly n) -> n -> Int\n    numberToInt wellThisWasPointless _ =\n        wellThisWasPointless |> N.toInt\n\nIt _is_ useful as a **stored & argument** type\nin combination with [`typesafe-array`](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/),\n\n    byte : ArraySized (Exactly (On N8)) Bit -> Byte\n\n→ A given [`ArraySized`](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/) must have _exactly 8_ `Bit`s\n\n    type alias TicTacToeBoard =\n        ArraySized\n            (Exactly (On N3))\n            (ArraySized (Exactly (On N3)) TicTacToeField)\n\n→ A given [`ArraySized`](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/) must have _exactly 3 by 3_ `TicTacToeField`s\n\n","args":["representation"],"type":"N.In representation representation"},{"name":"Min","comment":" Only **stored / result types should use `Min`**\n\n       ↓ minimum    ↓ or →\n    ⨯ [✓ ✓ ✓ ✓ ✓ ✓ ✓...\n\n\n### result type without maximum constraint\n\nSometimes, you simply cannot compute a maximum\n\n    intToAbsolute : Int -> N (In (Up0 x_) ??)\n                    ↓\n    intToAbsolute : Int -> N (Min (Up0 x_))\n\n    -- n ≥ 5\n    atLeast5 : N (Min (Up5 x_))\n\n    atLeast5 |> N.addMin n3\n    --: N (Min (Up8 x_))\n\n    n3 |> N.addMin atLeast5\n    --: N (Min (Up8 x_))\n\n\n### argument type without maximum constraint\n\nEvery `Min min` is of type `In min ...`,\nso using a type variable for the maximum on arguments is highly encouraged\nwhen no maximum constraint should be enforced\n\n    -- any natural number\n    N (In min_ max_)\n\n    -- number, at least 5\n    N (In (On (Add5 minFrom5_)) max_)\n\n\n### stored type without maximum constraint\n\nAn example where this is useful using [typesafe-array](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/):\n\n    type Tree branchingFactor element\n        = Tree\n            element\n            (ArraySized\n                branchingFactor\n                (Maybe (Tree branchingFactor element))\n            )\n\n    type alias TreeMulti element =\n        Tree (Min (On N1)) element\n\nRemember: ↑ and other `... (`[`On`](#On)`...)`\nare result/stored types, not argument types\n\nYou can just use [`Min`](#Min) `(` [`On`](#On) `...)` when you don't have disadvantages storing functions.\n\n[Can't store functions?](#without-internal-functions)\n\n","args":["lowestPossibleAsDifference"],"type":"N.In lowestPossibleAsDifference N.Infinity"},{"name":"N0","comment":" The [natural number](#N0OrAdd1) `0`\n","args":[],"type":"N.N0OrAdd1 Possibly.Possibly Basics.Never"},{"name":"N1","comment":" The [natural number](#N0OrAdd1) `1`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)"},{"name":"N10","comment":" The [natural number](#N0OrAdd1) `10`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))))))))"},{"name":"N11","comment":" The [natural number](#N0OrAdd1) `11`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))))))))))"},{"name":"N12","comment":" The [natural number](#N0OrAdd1) `12`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))))))))))"},{"name":"N13","comment":" The [natural number](#N0OrAdd1) `13`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))))))))))))"},{"name":"N14","comment":" The [natural number](#N0OrAdd1) `14`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))))))))))))"},{"name":"N15","comment":" The [natural number](#N0OrAdd1) `15`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))))))))))))))"},{"name":"N16","comment":" The [natural number](#N0OrAdd1) `16`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))))))))))))))"},{"name":"N2","comment":" The [natural number](#N0OrAdd1) `2`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))"},{"name":"N3","comment":" The [natural number](#N0OrAdd1) `3`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))"},{"name":"N4","comment":" The [natural number](#N0OrAdd1) `4`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))"},{"name":"N5","comment":" The [natural number](#N0OrAdd1) `5`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))))"},{"name":"N6","comment":" The [natural number](#N0OrAdd1) `6`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))))"},{"name":"N7","comment":" The [natural number](#N0OrAdd1) `7`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))))))"},{"name":"N8","comment":" The [natural number](#N0OrAdd1) `8`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never))))))))"},{"name":"N9","comment":" The [natural number](#N0OrAdd1) `9`\n","args":[],"type":"N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Possibly.Possibly Basics.Never)))))))))"},{"name":"On","comment":" The fixed [difference](#Up) from [`0`](#N0) to a given [number](#N0OrAdd1) `n`\n\nYou'll find this either to require a certain minimum\n\n    entryOnlyForKids : N (In (On (Add6 minFrom6_)) (Up maxTo14_ To N14)) -> ()\n    entryOnlyForKids _ =\n        ()\n\nOr in a stored type, which looks like a [result type](#result-type)\nwhere every [`Up<n> x`](#Up) is instead [`On N<n>`](#On)\n\nDo not use `==` on 2 numbers in a [`On`](#On) [range](#In).\nIt will lead to elm crashing because [difference](#Up)s are stored as functions internally.\n\nInstead, [compare](#compare) in _your_ code\nor convert to a value for _other_ code:\n\nNot storing functions etc. in app state, events, ... enables\n\n  - serializability, for example\n      - json import/export on the debugger → doesn't work\n  - calling `==`, for example\n      - on hot module reloading,\n        old code might end up remaining in the model\n      - [lamdera](https://www.lamdera.com/) → doesn't work\n      - accidental `==` call → crash\n\nCalling `==` on a value will yield the correct result instead of crashing\n\n[`On` is defined as a difference from 0](#On), so this independent type needed to be created\n\nYou can just use [`On`](#On) when you don't have disadvantages storing functions\n\n","args":["asNumber"],"type":"N.Up N.N0 N.To asNumber"},{"name":"Up0","comment":" `0` as the difference `Up x To x`\n","args":["x"],"type":"N.Up x N.To x"},{"name":"Up1","comment":" `1` as the difference `Up x To (N0OrAdd1 Possibly x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never x)"},{"name":"Up10","comment":" `10` as the difference `Up x To (Add10 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))))))))"},{"name":"Up11","comment":" `11` as the difference `Up x To (Add11 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))))))))))"},{"name":"Up12","comment":" `12` as the difference `Up x To (Add12 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))))))))))"},{"name":"Up13","comment":" `13` as the difference `Up x To (Add13 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))))))))))))"},{"name":"Up14","comment":" `14` as the difference `Up x To (Add14 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))))))))))))"},{"name":"Up15","comment":" `15` as the difference `Up x To (Add15 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))))))))))))))"},{"name":"Up16","comment":" `16` as the difference `Up x To (Add16 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))))))))))))))"},{"name":"Up2","comment":" `2` as the difference `Up x To (Add2 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))"},{"name":"Up3","comment":" `3` as the difference `Up x To (Add3 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))"},{"name":"Up4","comment":" `4` as the difference `Up x To (Add4 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))"},{"name":"Up5","comment":" `5` as the difference `Up x To (Add5 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))))"},{"name":"Up6","comment":" `6` as the difference `Up x To (Add6 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))))"},{"name":"Up7","comment":" `7` as the difference `Up x To (Add7 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))))))"},{"name":"Up8","comment":" `8` as the difference `Up x To (Add8 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x))))))))"},{"name":"Up9","comment":" `9` as the difference `Up x To (Add9 x)`\n","args":["x"],"type":"N.Up x N.To (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never (N.N0OrAdd1 Basics.Never x)))))))))"}],"values":[{"name":"add","comment":" Add a given [specific](#In) [`N`](#N)\n\n    between70And100 |> N.add n7\n    --: N (In (Up77 minX_) (Up107 maxX_))\n\nOne addend has an unconstrained maximum? → [`addMin`](#addMin)\n\n","type":"N.N (N.In (N.Up minPlusX N.To sumMinPlusX) (N.Up maxPlusX N.To sumMaxPlusX)) -> N.N (N.In (N.Up minX N.To minPlusX) (N.Up maxX N.To maxPlusX)) -> N.N (N.In (N.Up minX N.To sumMinPlusX) (N.Up maxX N.To sumMaxPlusX))"},{"name":"addDifference","comment":" Increase a [number](#N0OrAdd1) by a given [difference](#Up)\n\n    successor : n -> Add1 n\n    successor =\n        -- FYI: equivalent to Add1\n        N.addDifference (n1 |> N.min)\n\n    n10 |> N.min |> N.onToNumber |> successor\n    --> n11 |> N.min |> N.onToNumber\n\n","type":"N.Up low N.To high -> low -> high"},{"name":"addMin","comment":" To the [`N`](#N) without a known maximum-constraint,\nadd a number that (only) has [information on how to add](#Up) the minima\n\n    atLeast70 |> N.addMin n7\n    --: N (Min (Up77 x_))\n\n    n7 |> N.addMin atLeast70\n    --: N (Min (Up77 x_))\n\nUse [`add`](#add) if both maxima are known [difference](#Up)s as well\n\nIf the added minimum is [`On`](#On), supply the [`N.minTo`](#minTo) manually\nto re-enable adding both minimum types!\n\n    atLeast5 |> N.addMin (atLeastOn2 |> N.minTo n2)\n    --: N (Min (Up7 x_))\n\n","type":"N.N (N.In (N.Up minPlusX N.To sumMinPlusX) addendMax_) -> N.N (N.In (N.Up minX N.To minPlusX) max_) -> N.N (N.Min (N.Up minX N.To sumMinPlusX))"},{"name":"differenceAdd","comment":" Chain the [difference](#Up) [`Up`](#Up) to a higher [natural number](#N0OrAdd1)\n","type":"N.Up middle N.To high -> N.Up low N.To middle -> N.Up low N.To high"},{"name":"differenceSubtract","comment":" Chain the [difference](#Up) [`Down`](#Down) to a lower [number](#N0OrAdd1)\n","type":"N.Down high N.To middle -> N.Up low N.To high -> N.Up low N.To middle"},{"name":"divideBy","comment":" Divide (`//`) by an [`N`](#N) `d ≥ 1`\nThat means `x / d ≤ x`\n\n    atMost7\n        |> N.divideBy n3\n        --: N (In (Up0 minX_) (Up7 maxX_))\n        |> N.toInt\n\n","type":"N.N (N.In (N.On (N.Add1 divisorMinFrom1_)) divisorMax_) -> N.N (N.In min_ max) -> N.N (N.In (N.Up0 minX_) max)"},{"name":"exactlyRange","comment":" Create a [range](#In) with a given representation = minimum = maximum\n\n    N.intToIn ( n3, n6 ) 5\n        |> N.min\n        |> N.exactlyRange\n    --: In (Up3 x) (Up3 x)\n\n","type":"limitRepresentation -> N.In limitRepresentation limitRepresentation"},{"name":"greater","comment":" The maximum of both given numbers in the same range\n\nEven though you can just use directly\n\n    N.intToIn ( n0, n10 ) 3\n        |> N.greater (N.intToIn ( n0, n10 ) 1)\n        |> N.toInt\n    --> 3\n\n    N.intToIn ( n0, n10 ) 3\n        |> N.greater (N.intToIn ( n0, n10 ) 4)\n        |> N.toInt\n    --> 4\n\nthis is rather supposed to be used as a primitive to build a structure maximum function\n\n    ArraySized.fold Up N.greater\n\nFor clamping, try [`toIn`](#toIn) and [`toAtLeastMin`](#toAtLeastMin) instead!\n\n","type":"N.N range -> N.N range -> N.N range"},{"name":"inFuzz","comment":" `Fuzzer` for an [`N`](#N) in a given range.\nFor larger ranges, smaller [`N`](#N)s are preferred\n\n    import Fuzz\n\n    N.inFuzz ( n3, n6 )\n        |> Fuzz.map N.toInt\n        |> Fuzz.examples 10\n    --> [ 5, 6, 3, 3, 4, 6, 3, 6, 3, 5 ]\n\n","type":"( N.N (N.In minMin (N.Up minMaxToMaxMin_ N.To maxMin)), N.N (N.In (N.On maxMin) maxMax) ) -> Fuzz.Fuzzer (N.N (N.In minMin maxMax))"},{"name":"inFuzzUniform","comment":" `Fuzzer` for an [`N`](#N) in a given range.\nIn contrast to [`N.inFuzz`](#inFuzz),\nall [`N`](#N)s are equally as likely, even for larger ranges\n\n    import Fuzz\n\n    N.inFuzzUniform ( n2, n2 |> N.toPower n13 )\n        |> Fuzz.map N.toInt\n        |> Fuzz.examples 3\n    --> [ 2244, 4842, 3566 ]\n\n    N.inFuzz ( n2, n2 |> N.toPower n13 )\n        |> Fuzz.map N.toInt\n        |> Fuzz.examples 3\n    --> [ 26, 82, 17 ]\n\n","type":"( N.N (N.In minMin (N.Up minMaxToMaxMin_ N.To maxMin)), N.N (N.In (N.On maxMin) maxMax) ) -> Fuzz.Fuzzer (N.N (N.In minMin maxMax))"},{"name":"inRandom","comment":" Generate a random [`N`](#N) in a range\n\n    N.inRandom ( n1, n10 )\n    --: Random.Generator\n    --:     (N (In (Up1 minX_) (Up10 maxX_)))\n\n","type":"( N.N (N.In minMin (N.Up minMaxToMaxMin_ N.To maxMin)), N.N (N.In (N.On maxMin) maxMax) ) -> Random.Generator (N.N (N.In minMin maxMax))"},{"name":"inRange","comment":" Create a [range](#In)\nfrom the lowest possible representation of a given lower [range](#In)\nto the highest possible representation of a given higher [range](#In)\n","type":"( N.In minMin (N.Up minMaxToMaxMin_ N.To maxMin), N.In (N.On maxMin) maxMax ) -> N.In minMin maxMax"},{"name":"inToNumber","comment":" Number with [`On`](#On) [range](#In) → number with equatable [range](#In)\n\nIf you want an equatable `Min ...` [`N`](#N), you instead only need [`minToNumber`](#minToNumber)\n\n","type":"N.N (N.In (N.On min) (N.On max)) -> N.N (N.In min max)"},{"name":"inToOn","comment":" [`N`](#N) with equatable number [range](#In)\n→ [`N`](#N) with [`On`](#On) [range](#In) to be [altered](#alter), [compared](#compare), ...\n\nIf you want a `Min (On ...)` [`N`](#N), you instead only need [`minToOn`](#minToOn)\n\n","type":"N.N (N.In min max) -> N.N (N.In (N.On min) (N.On max))"},{"name":"intIsAtLeast","comment":" If the `Int ≥` a given `minimum`,\nreturn `Ok` with the `N (Min minimum)`,\nelse `Err` with the input `Int`\n\n    4 |> N.intIsAtLeast n5\n    --: Result Int (N (Min (Up5 x_)))\n    --> Err 4\n\n    1234 |> N.intIsAtLeast n5 |> Result.map N.toInt\n    --> Ok 1234\n\n","type":"N.N (N.In min max_) -> Basics.Int -> Result.Result Basics.Int (N.N (N.Min min))"},{"name":"intIsIn","comment":" Compared to a range from a lower to an upper bound, is the `Int` in range, [`BelowOrAbove`](#BelowOrAbove)?\n\n    inputIntParse : Int -> Result String (N (In (Up1 minX_) (Up10 maxX_)))\n    inputIntParse =\n        N.intIsIn ( n1, n10 )\n            >> Result.mapError\n                (\\outOfRange ->\n                    case outOfRange of\n                        N.Below _ ->\n                            \"≤ 0\"\n                        N.Above _ ->\n                            \"≥ 11\"\n                )\n\n    0 |> inputIntParse\n    --> Err \"≤ 0\"\n\n","type":"( N.N (N.In minMin (N.Up minMaxToMaxMin_ N.To maxMin)), N.N (N.In (N.On maxMin) (N.Up maxMaxX N.To maxMaxPlusX)) ) -> Basics.Int -> Result.Result (N.BelowOrAbove Basics.Int (N.N (N.Min (N.Up maxMaxX N.To (N.Add1 maxMaxPlusX))))) (N.N (N.In minMin (N.Up maxMaxX N.To maxMaxPlusX)))"},{"name":"intModBy","comment":" Perform [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic) by an [`N`](#N) `d ≥ 1`.\nThat means `x % d ≤ d - 1`\n\n    7\n        |> N.intModBy n3\n        --: N (In (Up0 minX_) (Up2 maxX_))\n        |> N.toInt\n    --> 1\n\nWorks in the typical mathematical way for a negative `Int`\n\n    -7\n        |> N.intModBy n3\n        --: N (In (Up0 minX_) (Up2 maxX_))\n        |> N.toInt\n    --> 2\n\nAlready have an [`N`](#N)? → [`remainderBy`](#remainderBy)\n\n","type":"N.N (N.In (N.On (N.Add1 minFrom1_)) (N.Up maxX N.To (N.Add1 maxFrom1PlusX))) -> Basics.Int -> N.N (N.In (N.Up0 remainderMinX_) (N.Up maxX N.To maxFrom1PlusX))"},{"name":"intToAbsolute","comment":" The `Int`'s distance from `0`.\nThis [\"absolute value\"](https://en.wikipedia.org/wiki/Absolute_value) is always `≥ 0`\n\n    -4\n        |> N.intToAbsolute\n        --: N (Min (Up0 x_))\n        |> N.toInt\n    --> 4\n\n    16 |> N.intToAbsolute |> N.toInt\n    --> 16\n\nReally only use this if you want the absolute value\n\n    badLength =\n        List.length >> N.intToAbsolute\n\n  - maybe, there's a solution that never even theoretically deals with unexpected values:\n\n        mostCorrectLength =\n            List.foldl\n                (\\_ -> N.addMin n1 >> N.minSubtract n1)\n                (n0 |> N.maxToInfinity)\n\n  - other times, though, like with `Array.length`, which isn't `O(n)`,\n    you can escape with for example\n\n        arrayLength =\n            Array.length >> N.intToAtLeast n0\n\n","type":"Basics.Int -> N.N (N.Min (N.Up0 x_))"},{"name":"intToAtLeast","comment":" A `N (Min ...)` from an `Int`;\nif the `Int < minimum`, `minimum` is returned\n\n    0\n        |> N.intToAtLeast n3\n        --: N (Min (Up3 x_))\n        |> N.toInt\n    --> 3\n\n    9\n        |> N.intToAtLeast n3\n        --: N (Min (Up3 x_))\n        |> N.toInt\n    --> 9\n\nYou can also use this as an escape hatch\nif you know an `Int` must be at least `minimum`.\nBut avoid it if you can do better, like\n\n    goodLength =\n        List.foldl\n            (\\_ -> N.addMin n1 >> N.minSubtract n1)\n            (n0 |> N.maxToInfinity)\n\nTo handle the case `< minimum` yourself → [`intIsAtLeast`](#intIsAtLeast)\n\n","type":"N.N (N.In min max_) -> Basics.Int -> N.N (N.Min min)"},{"name":"intToIn","comment":" Create a `N (In ...)` by **clamping** an `Int` between a minimum & maximum\n\n  - if the `Int < minimum`, `minimum` is returned\n  - if the `Int > maximum`, `maximum` is returned\n\nIf you want to handle the cases `< minimum` & `> maximum` explicitly, use [`intIsIn`](#intIsIn)\n\n    0\n        |> N.intToIn ( n3, n12 )\n        --: N (In (Up3 minX_) (Up12 minX_))\n        |> N.toInt\n    --> 3\n\n    99\n        |> N.intToIn ( n3, n12 )\n        |> N.toInt\n    --> 12\n\n    9\n        |> N.intToIn ( n3, n12 )\n        |> N.toInt\n    --> 9\n\n\n    toDigit : Char -> Maybe (N (In (Up0 minX_) (Up9 maxX_)))\n    toDigit char =\n        ((char |> Char.toCode) - ('0' |> Char.toCode))\n            |> N.intIsIn ( n0, n9 )\n            |> Result.toMaybe\n\n","type":"( N.N (N.In minMin (N.Up minMaxToMaxMin_ N.To maxMin)), N.N (N.In (N.On maxMin) maxMax) ) -> Basics.Int -> N.N (N.In minMin maxMax)"},{"name":"is","comment":" Is the [`N`](#N) equal to, [`BelowOrAbove`](#BelowOrAbove) a given number?\n\n    giveAPresent { age } =\n        case age |> N.is n18 of\n            Err (N.Below younger) ->\n                toy { age = younger }\n\n            Err (N.Above older) ->\n                book { age = older }\n\n            Ok _ ->\n                bigPresent\n\n    toy : { age : N (In min_ (Up17 maxX_)) } -> Toy\n\n    book :\n        { age : N (In (On (Add19 minFrom9_)) max_) }\n        -> Book\n\n(The type doesn't forbid that the number you're comparing against\nis below the current minimum or above the current maximum.\n→ `Err` or `Ok` values don't necessarily follow `min ≤ max` for `N (In min max ...)`\nLuckily that's not a problem, since the values won't be produced anyway.)\n\n","type":"N.N (N.In (N.Up minX N.To vsMinPlusX) (N.Up maxX N.To (N.Add1 vsMaxFrom1PlusX))) -> N.N (N.In min max) -> Result.Result (N.BelowOrAbove (N.N (N.In min (N.Up maxX N.To vsMaxFrom1PlusX))) (N.N (N.In (N.Up minX N.To (N.Add1 vsMinPlusX)) max))) (N.N (N.In (N.Up minX N.To vsMinPlusX) (N.Up maxX N.To (N.Add1 vsMaxFrom1PlusX))))"},{"name":"isAtLeast","comment":" Is the [`N`](#N) below than or at least as big as a given number?\n\n    vote :\n        { age : N (In (On (Add18 minFrom18_)) max_) }\n        -> Vote\n\n    tryToVote { age } =\n        case age |> N.isAtLeast n18 of\n            Err _ ->\n                -- 😓\n                Nothing\n\n            Ok oldEnough ->\n                vote { age = oldEnough } |> Just\n\n    factorial : N (In min_ max_) -> N (Min (Up1 x_))\n    factorial =\n        factorialBody\n\n    factorialBody : N (In min_ max_) -> N (Min (Up1 x_))\n    factorialBody x =\n        case x |> N.isAtLeast n1 of\n            Err _ ->\n                n1 |> N.maxToInfinity\n\n            Ok atLeast1 ->\n                factorial (atLeast1 |> N.subtractMin n1)\n                    |> N.multiplyBy atLeast1\n\n(The type doesn't forbid that the lower limit you're comparing against\nis below the current minimum or above the current maximum.\n→ `Err` or `Ok` values don't necessarily follow `min ≤ max` for `N (In min max ...)`\nLuckily that's not a problem, since the values won't be produced anyway.)\n\n","type":"N.N (N.In minMin (N.Up minMaxX N.To (N.Add1 minMaxFrom1PlusX))) -> N.N (N.In min max) -> Result.Result (N.N (N.In min (N.Up minMaxX N.To minMaxFrom1PlusX))) (N.N (N.In minMin max))"},{"name":"isAtLeast1","comment":" Transfer the knowledge about whether [`n0`](#n0) is a possible value\n\n    stackRepeat :\n        element\n        -> N (In (On (N0OrAdd1 possiblyOrNever minFrom1_)) max_)\n        -> Emptiable (Stacked element) possiblyOrNever\n    stackRepeat toRepeat length =\n        case length |> N.isAtLeast1 of\n            Err possiblyOrNever ->\n                Emptiable.Empty possiblyOrNever\n\n            Ok lengthAtLeast1 ->\n                Stack.topBelow\n                    toRepeat\n                    (List.repeat\n                        (lengthAtLeast1 |> N.subtract n1 |> N.toInt)\n                        toRepeat\n                    )\n\n    stackLength :\n        Emptiable (Stacked element) possiblyOrNever\n        -> N (Min (On (N0OrAdd1 possiblyOrNever N0)))\n    stackLength =\n        \\stack ->\n            case stack of\n                Emptiable.Empty possiblyOrNever ->\n                    -- adapt the variable minimum\n                    n0 |> N.min0Adapt (\\_ -> possiblyOrNever) |> N.maxToInfinity\n\n                Emptiable.Filled (TopBelow ( _, belowTop )) ->\n                    belowTop\n                        |> List.length\n                        |> N.intToAtLeast n0\n                        |> N.add n1\n                        -- downgrade the minimum\n                        |> N.min0Adapt never\n\nusing [`N.min0Adapt`](#min0Adapt)\n\nStack and Emptiable are part of [`emptiness-typed`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/)\n\nCool, right?\n\n","type":"N.N (N.In (N.On (N.N0OrAdd1 n0PossiblyOrNever minFrom1_)) max) -> Result.Result n0PossiblyOrNever (N.N (N.In (N.Up1 minX_) max))"},{"name":"isAtMost","comment":" Is the [`N`](#N) at most (`Ok`) or greater than (`Err`) a given number?\n\n    goToBelow18Party : { age : N (In min_ (Up maxTo17 To N17)) } -> Snack\n\n    tryToGoToBelow18Party { age } =\n        case age |> N.isAtMost n17 of\n            Ok below18 ->\n                goToBelow18Party { age = below18 } |> Just\n\n            Err _ ->\n                Nothing\n\n(The type doesn't forbid that the upper limit you're comparing against\nis below the current minimum or above the current maximum.\n→ `Err` or `Ok` values don't necessarily follow `min ≤ max` for `N (In min max ...)`\nLuckily that's not a problem, since the values won't be produced anyway.)\n\n","type":"N.N (N.In (N.Up maxMinX N.To maxMinPlusX) maxMax) -> N.N (N.In min max) -> Result.Result (N.N (N.In (N.Up maxMinX N.To (N.Add1 maxMinPlusX)) max)) (N.N (N.In min maxMax))"},{"name":"isIn","comment":" Compared to a range from a lower to an upper bound,\nis the [`N`](#N) in range or [`BelowOrAbove`](#BelowOrAbove)?\n\n    isIn3To10 : N (In min_ max_) -> Maybe (N (In (Up3 minX_) (Up10 maxX_)))\n    isIn3To10 =\n        N.isIn ( n3, n10 ) >> Result.toMaybe\n\n    n9 |> isIn3To10 |> Maybe.map N.toInt\n    --> Just 9\n\n    n12 |> isIn3To10\n    --> Nothing\n\n(The type doesn't forbid that the limits you're comparing against\nare below the current minimum, above the current maximum or in the wrong order.\n→ `Err` or `Ok` values don't necessarily follow `min ≤ max` for `N (In min max ...)`\nLuckily that's not a problem, since the values won't be produced anyway.)\n\nHere's some example-cases:\n\n  - `hi < lo < min < max` → `Below | Above`\n  - `hi < min < lo < max` → `Below | Above`\n  - `hi < min < max < lo` → `Below | Above`\n  - `lo < hi < min < max` → `Above`\n  - `max < hi < min < lo` → `Below`\n  - `min < hi < lo < max` → `Below | Above`\n  - `lo < min < hi < max` → `Ok | Above`\n  - `max < min < hi < lo` → `Below`\n  - `max < lo < hi < min` → `Below | Ok | Above` ← the default case\n  - `lo < min < max < hi` → `Ok`\n  - `min < lo < max < hi` → `Ok | Below`\n  - `min < max < lo < hi` → `Below`\n\n.\n\n  - did we miss something? → issue\n  - feel motivated to add the other cases? → PR\n\n","type":"( N.N (N.In minMin (N.Up minMaxX N.To (N.Add1 minMaxFrom1PlusX))), N.N (N.In (N.Up maxMinX N.To maxMinPlusX) maxMax) ) -> N.N (N.In min max) -> Result.Result (N.BelowOrAbove (N.N (N.In min (N.Up minMaxX N.To minMaxFrom1PlusX))) (N.N (N.In (N.Up maxMinX N.To (N.Add1 maxMinPlusX)) max))) (N.N (N.In minMin maxMax))"},{"name":"max","comment":" The greatest allowed number promised by the range type\nas its representation as a [difference](#Up)\n","type":"N.N (N.In min_ max) -> max"},{"name":"maxAdd","comment":" Increase its maximum by a given relative amount.\n\nTo set its maximum to a specific absolute value, [`N.maxTo`](#maxTo)\n\n","type":"N.N (N.In increaseMin_ (N.Up maxPlusX N.To maxIncreasedPlusX)) -> N.N (N.In min (N.Up maxX N.To maxPlusX)) -> N.N (N.In min (N.Up maxX N.To maxIncreasedPlusX))"},{"name":"maxEndsSubtract","comment":" Decrease the start and end of its [`max`](#max) [difference](#Up)\n\n    n3\n        --: N (In (Up3 minX_) (Up3 (Add2 maxX_)))\n        |> N.addStart n2\n    --: N (In (Up5 minX_) (Up5 maxX_))\n\nHuh... One rare use-case is avoiding an extra type parameter:\n\nWith extra type parameter:\n\n    {-| Gives each index a label. Access using `partIn`\n    -}\n    type alias Group record lastIndex count =\n        { record : record\n        , parts : ArraySized String (Exactly (On count))\n        , lastIndex : N (In (On N0) lastIndex)\n        }\n\n    addPart :\n        String\n        ->\n            (Group\n                (N (In (On N0) (Up x To lastIndexPlusX)) -> record)\n                (Up x To lastIndexPlusX)\n                count\n             -> Group record (Up x To (Add1 lastIndexPlusX)) (Add1 count)\n            )\n    addPart partName groupSoFar =\n        { record = groupSoFar.record groupSoFar.lastIndex\n        , parts = groupSoFar.parts |> ArraySized.push partName\n        , lastIndex = groupSoFar.lastIndex |> N.add n1\n        }\n\n    partIn :\n        Group record i_ (Add1 lastIndex)\n        -> (record -> N (In (On N0) (Up x_ To lastIndex)))\n        -> String\n    partIn group field =\n        group.parts |> ArraySized.element ( Up, group.record |> field )\n\nIf we change `Group record lastIndex count` to keep only one of both, we have a problem:\nAll indexes in the `record` are dependent on the same maximum which now is [`On`](#On).\nThat means that lower indexes aren't accepted by `partIn` anymore. The fix:\n\n    addPart :\n        String\n        ->\n            (GroupBeingBuilt\n                (N (In (On N0) (Up (Add1 xFrom1) To lastIndex)) -> record)\n                (Up (Add1 xFrom1) To lastIndex)\n                count\n             -> GroupBeingBuilt record (Up xFrom1 To lastIndex) (Add1 count)\n            )\n    addPart partName groupSoFar =\n        { record = groupSoFar.record groupSoFar.lastIndex\n        , parts = groupSoFar.parts |> ArraySized.push partName\n        , lastIndex = groupSoFar.lastIndex |> N.add n1 |> N.maxEndsSubtract n1 |> N.minTo n0\n        }\n\n    type alias GroupComplete record count =\n        Group record (On count) count\n\nThe really nice thing is that as we finish, the start of [minimum difference](#min) is `N0`,\nwhich makes this an [`On`](#On)\n\n","type":"N.N (N.In (N.Down maxPlusX N.To maxPlusXDecreased) (N.Down maxX N.To maxXDecreased)) -> N.N (N.In min (N.Up maxX N.To maxPlusX)) -> N.N (N.In min (N.Up maxXDecreased N.To maxPlusXDecreased))"},{"name":"maxRange","comment":" Create a range with minimum set to 0 and a given maximum\n","type":"max -> N.In (N.Up0 newMinX_) max"},{"name":"maxTo","comment":" Set its maximum to a given (lower) one.\n\nThis can help \"resetting\" an argument's maximum\nto make it fit into functions that require a higher maximum.\n\nSince you should type arguments and stored types as broad as possible\n\n    onlyAtMost18 : N (In min_ (Up maxTo18_ To N18)) -> ...\n\n    onlyAtMost18 between3And8 -- works\n\nonce you implement `onlyAtMost18`, you might use the `n` in `onlyAtMost19`:\n\n    onlyAtMost18 n =\n        -- onlyAtMost19 n → error\n        onlyAtMost19 (n |> N.maxTo n18)\n\nTo increase its maximum by a relative amount, [`maxAdd`](#maxAdd)\n\n","type":"N.N (N.In (N.On newMaxMin) newMax) -> N.N (N.In min (N.Up maxToNewMaxMin_ N.To newMaxMin)) -> N.N (N.In min newMax)"},{"name":"maxToInfinity","comment":" On `N (In min max)`'s type,\nallow `max` to go [up to infinity](#Infinity) to get a `N (Min min)`\n\n    between3And10 |> N.maxToInfinity\n    --: N (Min (Up3 x_))\n\nUse it to unify different types of number minimum constraints like\n\n    [ atLeast1, between1And10 ]\n\nelm complains:\n\n> But all the previous elements in the list are: `N (Min (Up1 x_))`\n\n    [ atLeast1\n    , between1And10 |> N.maxToInfinity\n    ]\n\n","type":"N.N (N.In min max_) -> N.N (N.Min min)"},{"name":"maxToNumber","comment":" [`N`](#N) with [`On`](#On) maximum\n→ [`N`](#N) with equatable maximum number\n","type":"N.N (N.In min (N.On max)) -> N.N (N.In min max)"},{"name":"maxToOn","comment":" [`N`](#N) with an equatable maximum number\n→ [`N`](#N) with [`On`](#On) maximum\n","type":"N.N (N.In min max) -> N.N (N.In min (N.On max))"},{"name":"min","comment":" The smallest allowed number promised by the range type\nas its representation as a [difference](#Up)\n","type":"N.N (N.In min maximum_) -> min"},{"name":"min0Adapt","comment":" Change the `possiblyOrNever` type for the case that its [`min`](#min) is 0\n\n`never` allows you to adapt any variable,\n`\\_ -> yourVariablePossiblyOrNever` swaps it for your given variable\n\n    stackLength :\n        Emptiable (Stacked element) possiblyOrNever\n        -> N (Min (On (N0OrAdd1 possiblyOrNever N0)))\n    stackLength =\n        \\stack ->\n            case stack of\n                Emptiable.Empty possiblyOrNever ->\n                    n0\n                        -- adapt the variable minimum\n                        |> N.min0Adapt (\\_ -> possiblyOrNever)\n                        -- allow a different min - 1 type\n                        |> N.minAtLeast1Never\n                        |> N.maxToInfinity\n\n                Emptiable.Filled (TopBelow ( _, belowTop )) ->\n                    belowTop\n                        |> List.length\n                        |> N.intToAtLeast n0\n                        |> N.add n1\n                        -- downgrade the minimum\n                        |> N.min0Adapt never\n\nusing [`isAtLeast1`](#isAtLeast1), [`minAtLeast1Never`](#minAtLeast1Never).\n\nStack and Emptiable are part of [`emptiness-typed`](https://dark.elm.dmy.fr/packages/lue-bird/elm-emptiness-typed/latest/)\n\nwith `(\\_ -> Possible)` it's just a worse version of [`minSubtract`](#minSubtract)\nthat might be useful in ultra rare situations\n\n    minSubtract1IfPossible :\n        N (In (On (N0OrAdd1 possiblyOrNever minFrom1)) max)\n        -> N (In (On (N0OrAdd1 Possibly minFrom1)) max)\n    minSubtract1IfPossible =\n        N.min0Adapt (\\_ -> Possibly)\n\n","type":"(possiblyOrNever -> adaptedPossiblyOrNever) -> N.N (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1)) max) -> N.N (N.In (N.On (N.N0OrAdd1 adaptedPossiblyOrNever minFrom1)) max)"},{"name":"minAtLeast1Never","comment":" For the case that its [`min`](#min) is 1 + ..., allow adapting any variable.\nThis is possible because we currently have a minimum that is `Never` >= 1\n\n    stackLength :\n        Emptiable (Stacked element) possiblyOrNever\n        -> N (Min (On (N0OrAdd1 possiblyOrNever N0)))\n    stackLength =\n        \\stack ->\n            case stack of\n                Emptiable.Empty possiblyOrNever ->\n                    n0\n                        -- adapt the variable minimum\n                        |> N.min0Adapt (\\_ -> possiblyOrNever)\n                        -- allow a different type for min from 1\n                        |> N.minAtLeast1Never\n                        |> N.maxToInfinity\n\n                Emptiable.Filled (TopBelow ( _, belowTop )) ->\n                    belowTop\n                        |> List.length\n                        |> N.intToAtLeast n0\n                        |> N.add n1\n                        -- downgrade the minimum\n                        |> N.min0Adapt never\n\nusing [`isAtLeast1`](#isAtLeast1), [`min0Adapt`](#min0Adapt)\n\n","type":"N.N (N.In (N.On (N.N0OrAdd1 possiblyOrNever Basics.Never)) max) -> N.N (N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1_)) max)"},{"name":"minEndsSubtract","comment":" Decrease the start and end of its [`min`](#min) [difference](#Up)\n\n    n3\n        --: N (In (Up3 (Add2 minX_)) (Up3 maxX_))\n        |> N.minEndsSubtract n2\n    --: N (In (Up5 minX_) (Up5 maxX_))\n\n[`maxEndsSubtract`](#maxEndsSubtract) has an example of where this can be useful.\n\n","type":"N.N (N.In (N.Down minX N.To minXDecreased) (N.Down minPlusX N.To minPlusXDecreased)) -> N.N (N.In (N.Up minX N.To minPlusX) max) -> N.N (N.In (N.Up minXDecreased N.To minPlusXDecreased) max)"},{"name":"minRange","comment":" Create a [range](#In) with a given representation as the minimum\nand [`Infinity`](#Infinity) as the maximum\n\n    N.intToIn ( n3, n6 ) 5\n        |> N.min\n        |> N.minRange\n    --: Min (Up3 x)\n\n","type":"min -> N.Min min"},{"name":"minSubtract","comment":" Decrease its minimum by a given relative amount.\n\nTo set its minimum to a specific absolute value, [`minTo`](#minTo)\n\n","type":"N.N (N.In maxIncreasedMin_ (N.Down minPlusX N.To minDecreasedPlusX)) -> N.N (N.In (N.Up x N.To minPlusX) max) -> N.N (N.In (N.Up x N.To minDecreasedPlusX) max)"},{"name":"minTo","comment":" Set its minimum to a given (lower) one\n\n    [ atLeast3, atLeast4 ]\n\nElm complains:\n\n> But all the previous elements in the list are: `N (Min N3)`\n\n    [ atLeast3\n    , atLeast4 |> N.minTo n3\n    ]\n\nTo decrease its minimum by a relative amount, [`minSubtract`](#minSubtract)\n\n","type":"N.N (N.In minNew (N.Up minNewMaxToMin_ N.To min)) -> N.N (N.In (N.On min) max) -> N.N (N.In minNew max)"},{"name":"minTo0","comment":" Set the minimum as 0, without relying on the minimum being [fixed](#On)\nlike the more general [`minTo`](#minTo)\n","type":"N.N (N.In min_ max) -> N.N (N.In (N.Up0 minX_) max)"},{"name":"minToNumber","comment":" [`N`](#N) with [`On`](#On) minimum\n→ [`N`](#N) with equatable minimum number\n\nYou'll usually use this to convert to an equatable `Min ...` [`N`](#N)\n\n","type":"N.N (N.In (N.On min) max) -> N.N (N.In min max)"},{"name":"minToOn","comment":" [`N`](#N) with equatable minimum number\n→ [`N`](#N) with [`On`](#On) minimum\n\nYou'll usually use this to convert to a `Min (On ...)` [`N`](#N)\n\n","type":"N.N (N.In min max) -> N.N (N.In (N.On min) max)"},{"name":"multiplyBy","comment":" Multiply by a given [`n`](#N) `≥ 1`.\nThat means `x * n ≥ x`\n\n    atLeast5 |> N.multiplyBy n2\n    --: N (Min (Up5 x_))\n\n    atLeast2 |> N.multiplyBy n5\n    --: N (Min (Up2 x_))\n\n","type":"N.N (N.In (N.On (N.Add1 multiplicandMinFrom1_)) multiplicandMax_) -> N.N (N.In min max_) -> N.N (N.Min min)"},{"name":"n0","comment":" The specific natural number `0`\n","type":"N.N (N.In (N.Up0 minX_) (N.Up0 maxX_))"},{"name":"n1","comment":" The specific natural number `1`\n","type":"N.N (N.In (N.Up1 minX_) (N.Up1 maxX_))"},{"name":"n10","comment":" The [`N`](#N) `10`\n","type":"N.N (N.In (N.Up10 minX_) (N.Up10 maxX_))"},{"name":"n11","comment":" The [`N`](#N) `11`\n","type":"N.N (N.In (N.Up11 minX_) (N.Up11 maxX_))"},{"name":"n12","comment":" The [`N`](#N) `12`\n","type":"N.N (N.In (N.Up12 minX_) (N.Up12 maxX_))"},{"name":"n13","comment":" The [`N`](#N) `13`\n","type":"N.N (N.In (N.Up13 minX_) (N.Up13 maxX_))"},{"name":"n14","comment":" The [`N`](#N) `14`\n","type":"N.N (N.In (N.Up14 minX_) (N.Up14 maxX_))"},{"name":"n15","comment":" The [`N`](#N) `15`\n","type":"N.N (N.In (N.Up15 minX_) (N.Up15 maxX_))"},{"name":"n16","comment":" The [`N`](#N) `16`\n","type":"N.N (N.In (N.Up16 minX_) (N.Up16 maxX_))"},{"name":"n2","comment":" The [`N`](#N) `2`\n","type":"N.N (N.In (N.Up2 minX_) (N.Up2 maxX_))"},{"name":"n3","comment":" The [`N`](#N) `3`\n","type":"N.N (N.In (N.Up3 minX_) (N.Up3 maxX_))"},{"name":"n4","comment":" The [`N`](#N) `4`\n","type":"N.N (N.In (N.Up4 minX_) (N.Up4 maxX_))"},{"name":"n5","comment":" The [`N`](#N) `5`\n","type":"N.N (N.In (N.Up5 minX_) (N.Up5 maxX_))"},{"name":"n6","comment":" The [`N`](#N) `6`\n","type":"N.N (N.In (N.Up6 minX_) (N.Up6 maxX_))"},{"name":"n7","comment":" The [`N`](#N) `7`\n","type":"N.N (N.In (N.Up7 minX_) (N.Up7 maxX_))"},{"name":"n8","comment":" The [`N`](#N) `8`\n","type":"N.N (N.In (N.Up8 minX_) (N.Up8 maxX_))"},{"name":"n9","comment":" The [`N`](#N) `9`\n","type":"N.N (N.In (N.Up9 minX_) (N.Up9 maxX_))"},{"name":"number0Adapt","comment":" Change the `possiblyOrNever` type\nfor the case that the [`N0OrAdd1`](#N0OrAdd1) is [`N0`](#N0OrAdd1)\n","type":"(n0PossiblyOrNever -> adaptedN0PossiblyOrNever) -> N.N0OrAdd1 n0PossiblyOrNever from1 -> N.N0OrAdd1 adaptedN0PossiblyOrNever from1"},{"name":"numberFrom1Map","comment":" Change the type\nfor the case that the [`N0OrAdd1`](#N0OrAdd1) is [`Add1 from1`](#N0OrAdd1)\n","type":"(from1 -> mappedFrom1) -> N.N0OrAdd1 n0PossiblyOrNever from1 -> N.N0OrAdd1 n0PossiblyOrNever mappedFrom1"},{"name":"on0Adapt","comment":" Change the `possiblyOrNever` type\nfor the case that its [`N0OrAdd1`](#N0OrAdd1) representation is [`N0`](#N0OrAdd1)\n","type":"(possiblyOrNever -> adaptedPossiblyOrNever) -> N.On (N.N0OrAdd1 possiblyOrNever from1) -> N.On (N.N0OrAdd1 adaptedPossiblyOrNever from1)"},{"name":"onFrom1Map","comment":" Change the type\nfor the case that the [`N0OrAdd1`](#N0OrAdd1) is [`Add1 from1`](#N0OrAdd1)\n","type":"(from1 -> mappedFrom1) -> N.On (N.N0OrAdd1 n0PossiblyOrNever from1) -> N.On (N.N0OrAdd1 n0PossiblyOrNever mappedFrom1)"},{"name":"onToNumber","comment":" The [`N0OrAdd1`](#N0OrAdd1) represented by this [`On`](#On) [difference](#Up)\n\n    import Possibly exposing (Possibly(..))\n\n    N.intToIn ( n3, n10 ) 5\n        |> N.min\n        |> N.onToNumber\n    --> N.Add1 (N.Add1 (N.Add1 (N.N0 Possible)))\n\nuseful\n\n  - to preserve emptiness knowledge\n\n        predecessor :\n            N0OrAdd1 possiblyOrNever from1\n            -> Emptiable from1 possiblyOrNever\n        predecessor =\n            \\number ->\n                case number of\n                    N.N0 possiblyOrNever ->\n                        Emptiable.Empty possiblyOrNever\n\n                    N.Add1 predecessor ->\n                        predecessor |> Emptiable.filled\n\n  - as a tag\n\n        type Element index\n            = Element index\n\n        element :\n            N (Exactly (On index))\n            -> Mapping (List element) (Element index) (Maybe element)\n        element index =\n            Typed.tag\n                (Element (index |> N.min |> N.onToNumber))\n                List.Extra.getAt\n\nCan be altered with [`addDifference`](#addDifference), [`subtractDifference`](#subtractDifference).\n\nTo preserve the ability to turn the number into an `Int`, use [`onToNumber`](#onToNumber)\n\n","type":"N.On representedNumber -> representedNumber"},{"name":"range","comment":" Its [limits](#In)\ncontaining both its [`min`](#min)\nand its [`max`](#max)\n\n    import Possibly exposing (Possibly(..))\n\n    N.intToIn ( n3, n5 ) 4\n        --: N (In (Up3 minX_) (Up5 maxX_))\n        |> N.minTo n2\n        --: N (In (Up2 minX_) (Up5 maxX_))\n        |> N.range\n        --: In (Up2 minX_) (Up5 maxX_)\n        |> N.rangeInToNumber\n        --: In N2 N5\n        |> N.rangeMin\n    --: N2\n    --> N.Add1 (N.Add1 (N.N0 Possible))\n\n","type":"N.N range -> range"},{"name":"rangeAdd","comment":" Add a given [difference](#Up) to its minimum and maximum\n","type":"N.In (N.Up minPlusX N.To minIncreasedPlusX) (N.Up maxPlusX N.To maxIncreasedPlusX) -> N.In (N.Up minX N.To minPlusX) (N.Up maxX N.To maxPlusX) -> N.In (N.Up minX N.To minIncreasedPlusX) (N.Up maxX N.To maxIncreasedPlusX)"},{"name":"rangeInToNumber","comment":" [`In`](#In) [`(On ...) (On ...)`](#On) → equatable [`In`](#In)\n","type":"N.In (N.On min) (N.On max) -> N.In min max"},{"name":"rangeInToOn","comment":" equatable [`In`](#In) → [`In`](#In) [`(On ...) (On ...)`](#On)\n","type":"N.In min max -> N.In (N.On min) (N.On max)"},{"name":"rangeIsAtLeast1","comment":" Transfer the knowledge about whether [`n0`](#n0) is a possible value\n","type":"N.N (N.In (N.On (N.N0OrAdd1 n0PossiblyOrNever minFrom1_)) max) -> Result.Result n0PossiblyOrNever (N.In (N.Up1 minX_) max)"},{"name":"rangeMax","comment":" The [range](#In)'s highest possible representation\n","type":"N.In min_ max -> max"},{"name":"rangeMaxAdd","comment":" Add a given [difference](#Up) to its maximum\n","type":"N.Up maxPlusX N.To maxIncreasedPlusX -> N.In min (N.Up maxX N.To maxPlusX) -> N.In min (N.Up maxX N.To maxIncreasedPlusX)"},{"name":"rangeMaxEndsSubtract","comment":" Decrease the start and end of its [`rangeMax`](#rangeMax) [difference](#Up)\n\n    n3\n        |> N.range\n        --: In (Up3 minX_) (Up3 (Add2 maxX_))\n        |> N.rangeMaxEndsSubtract (n2 |> N.range)\n    --: In (Up5 minX_) (Up5 maxX_)\n\nSee [`maxEndsSubtract`](#maxEndsSubtract) for details and examples\n\n","type":"N.In (N.Down maxPlusX N.To maxPlusXDecreased) (N.Down maxX N.To maxXDecreased) -> N.In min (N.Up maxX N.To maxPlusX) -> N.In min (N.Up maxXDecreased N.To maxPlusXDecreased)"},{"name":"rangeMaxSubtract","comment":" Subtract its maximum by a given [difference](#Up)\nand set the minimum to 0\n","type":"N.Down maxPlusX N.To maxDecreasedPlusX -> N.In min_ (N.Up x N.To maxPlusX) -> N.In (N.Up0 minX_) (N.Up x N.To maxDecreasedPlusX)"},{"name":"rangeMaxTo","comment":" Set its maximum to a given (higher) one\n","type":"N.In (N.On newMaxMin) maxNew -> N.In min (N.Up maxToNewMaxMin_ N.To newMaxMin) -> N.In min maxNew"},{"name":"rangeMaxToNumber","comment":" Make [range](#In)'s [`On`](#On) maximum equatable\n","type":"N.In min (N.On max) -> N.In min max"},{"name":"rangeMaxToOn","comment":" Make [range](#In)'s equatable maximum [`On`](#On)\n","type":"N.In min max -> N.In min (N.On max)"},{"name":"rangeMin","comment":" The [range](#In)'s lowest possible representation\n","type":"N.In min max_ -> min"},{"name":"rangeMin0Adapt","comment":" Change its minimum's `possiblyOrNever` type\nfor the case that the [`N0OrAdd1`](#N0OrAdd1) is [`N0`](#N0OrAdd1)\n","type":"(possiblyOrNever -> adaptedPossiblyOrNever) -> N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1)) max -> N.In (N.On (N.N0OrAdd1 adaptedPossiblyOrNever minFrom1)) max"},{"name":"rangeMinAtLeast1Never","comment":" For the case that its [`min`](#min) is 1 + ..., allow adapting any variable.\nThis is possible because we currently have a minimum that is `Never` >= 1\n","type":"N.In (N.On (N.N0OrAdd1 possiblyOrNever Basics.Never)) max -> N.In (N.On (N.N0OrAdd1 possiblyOrNever minFrom1_)) max"},{"name":"rangeMinEndsSubtract","comment":" Decrease the start and end of its [`rangeMin`](#rangeMin) [difference](#Up)\n\n    n3\n        |> N.range\n        --: In (Up3 (Add2 minX_)) (Up3 maxX_)\n        |> N.rangeMinEndsSubtract (n2 |> N.range)\n    --: In (Up5 minX_) (Up5 maxX_)\n\nSee [`maxEndsSubtract`](#maxEndsSubtract) for details and examples\n\n","type":"N.In (N.Down minX N.To minXDecreased) (N.Down minPlusX N.To minPlusXDecreased) -> N.In (N.Up minX N.To minPlusX) max -> N.In (N.Up minXDecreased N.To minPlusXDecreased) max"},{"name":"rangeMinSubtract","comment":" Subtract its minimum by a given [difference](#Up)\n","type":"N.Down minPlusX N.To minDecreasedPlusX -> N.In (N.Up x N.To minPlusX) max -> N.In (N.Up x N.To minDecreasedPlusX) max"},{"name":"rangeMinTo","comment":" Set its minimum to a given (lower) one\n","type":"N.In newMin (N.Up newMinMaxToMin_ N.To min) -> N.In (N.On min) max -> N.In newMin max"},{"name":"rangeMinToNumber","comment":" Make [range](#In)'s [`On`](#On) minimum equatable\n","type":"N.In (N.On min) max -> N.In min max"},{"name":"rangeMinToOn","comment":" Make [range](#In)'s equatable minimum [`On`](#On)\n","type":"N.In min max -> N.In (N.On min) max"},{"name":"rangeSubtract","comment":" Subtract its minimum and maximum by a given [difference](#Up)\n","type":"N.In (N.Down maxPlusX N.To maxDecreasedPlusX) (N.Down min N.To minDecreased) -> N.In (N.On min) (N.Up maxX N.To maxPlusX) -> N.In (N.On minDecreased) (N.Up maxX N.To maxDecreasedPlusX)"},{"name":"remainderBy","comment":" The remainder after dividing by an [`N`](#N) `d ≥ 1`.\nThat means `x % d ≤ d - 1`\n\n    atMost7 |> N.remainderBy n3\n    --: N (In (Up0 minX_) (Up2 maxX_))\n\n","type":"N.N (N.In (N.On (N.Add1 divisorMinFrom1_)) (N.Up divMaxX N.To (N.Add1 divisorMaxFrom1PlusX))) -> N.N range_ -> N.N (N.In (N.Up0 remainderMinX_) (N.Up divMaxX N.To divisorMaxFrom1PlusX))"},{"name":"smaller","comment":" The minimum of both given numbers in the same range\n\nEven though you can just use directly\n\n    N.intToIn ( n0, n10 ) 3\n        |> N.smaller (N.intToIn ( n0, n10 ) 1)\n        |> N.toInt\n    --> 1\n\n    N.intToIn ( n0, n10 ) 3\n        |> N.smaller (N.intToIn ( n0, n10 ) 4)\n        |> N.toInt\n    --> 3\n\nthis is rather supposed to be used as a primitive to build a structure maximum function:\n\n    ArraySized.fold Up N.smaller\n\nFor clamping, try [`toIn`](#toIn) instead!\n\n","type":"N.N range -> N.N range -> N.N range"},{"name":"subtract","comment":" From the [`N`](#N) in a range subtract another [`N`](#N) in a range\n\n    n6\n        |> N.subtract n5\n        --: N (In (On N1) (Up1 x_))\n        |> N.inToNumber\n    --> n1 |> N.inToNumber\n\nOne of the [`N`](#N)s has no maximum constraint? → [`N.subtractMin`](#subtractMin)\n\nThe subtracted [`N`](#N) can get greater than the current minimum? → [`N.subtractMax`](#subtractMax)\n\n","type":"N.N (N.In (N.Down maxPlusX N.To differenceMaxPlusX) (N.Down min N.To differenceMin)) -> N.N (N.In (N.On min) (N.Up maxX N.To maxPlusX)) -> N.N (N.In (N.On differenceMin) (N.Up maxX N.To differenceMaxPlusX))"},{"name":"subtractDifference","comment":" Decrease the [natural number](#N0OrAdd1) by a given [difference](#Down)\n\n    predecessor : Add1 predecessor -> predecessor\n    predecessor =\n        N.subtractDifference (n1 |> N.min)\n\n    n10 |> N.min |> N.onToNumber |> predecessor\n    --> n9 |> N.min |> N.onToNumber\n\n","type":"N.Down high N.To low -> high -> low"},{"name":"subtractMax","comment":" From an [`N`](#N),\nsubtract a number that can get greater than the current minimum\n\n    n5 |> N.subtractMax in3To7\n    --: N (In (Up0 minX_) (On N2))\n\nUse [`N.subtract`](#subtract) if you want to subtract an [`N`](#N) in a range\nor [`N.subtractMin`](#subtractMin) if one of the [`N`](#N)s has no maximum constraint\n\n","type":"N.N (N.In (N.Down max N.To differenceMax) subtrahendMax_) -> N.N (N.In min_ (N.On max)) -> N.N (N.In (N.Up0 minX_) (N.On differenceMax))"},{"name":"subtractMin","comment":" From an [`N`](#N) with an unknown maximum constraint,\nsubtract a [specific number](#In)\n\n    atLeast7 |> N.subtractMin n2\n    --: N (Min (On N5))\n\n    atLeast6 |> N.subtractMin between0And5\n    --: N (Min (On N1))\n\n    between6And12 |> N.subtractMin between1And5\n    --: N (In (On N1) (Up12 maxX_))\n\nUse [`N.subtract`](#subtract) if you want to subtract an [`N`](#N) in a range\nor [`N.subtractMax`](#subtractMax) if the subtracted [`N`](#N) can get greater than the current minimum.\n\n","type":"N.N (N.In subtrahendMin_ (N.Down min N.To differenceMin)) -> N.N (N.In (N.On min) max) -> N.N (N.In (N.On differenceMin) max)"},{"name":"toAtLeastMin","comment":" **Cap** the [`N`](#N) to `>=` a given new lower limit\n\n    n5AtLeast |> N.toAtLeastMin n10\n    --: N (Min (Up10 x_))\n\nThe type doesn't forbid that the lower limit you're comparing against\nis below the current lower limit\n\n    n15AtLeast |> N.toAtLeastMin n10 |> N.toInt\n    --: N (Min (Up10 x_))\n\nTo clamp its maximum, too, [`toIn`](#toIn)\n\n","type":"N.N (N.In min max_) -> N.N range_ -> N.N (N.Min min)"},{"name":"toFloat","comment":" Drop the range constraints\nto feed another library with its `Float` representation\n\nEquivalent to\n\n    toInt |> toFloat\n\n","type":"N.N range_ -> Basics.Float"},{"name":"toIn","comment":" **Clamp** the number to between both given limits\n\n    between5And9 |> N.toIn ( n10, n10 )\n    --: N (In (Up10 minX_) (Up10 maxX_))\n\n    between5And15 |> N.toIn ( n5, n10 )\n    --: N (In (Up5 minX_) (Up10 maxX_))\n\n    between5And12 |> N.toIn ( n10, n12 )\n    --: N (In (Up10 minX_) (Up12 maxX_))\n\n    atLeast5 |> N.toIn ( n5, n10 )\n    --: N (In (Up5 minX_) (Up10 maxX_))\n\n    n15\n        |> N.toIn ( n10, n15 )\n        --: N (In (Up10 minX_) (Up15 max_))\n        |> N.toInt\n    --> 15\n\n    N.intToAtLeast n3 12345\n        |> N.toIn ( n3, N.intToIn ( n4, n5 ) 5 )\n        --: N (In (Up3 minX_) (Up5 maxX_))\n        |> N.toInt\n    --> 5\n\nThere shouldn't be an upper limit? → [`toAtLeastMin`](#toAtLeastMin)\n\n(The type doesn't forbid that the limits you're comparing against\nare beyond the current limits)\n\n","type":"( N.N (N.In minMin (N.Up minNewMaxToMaxNewMin_ N.To maxMin)), N.N (N.In (N.On maxMin) maxMax) ) -> N.N range_ -> N.N (N.In minMin maxMax)"},{"name":"toInOrAtLeast","comment":" Cap the [`N`](#N) to `<=` a given new upper limit –\nbut _always_ keep it `>=` a given new lower limit.\n\n    n5AtLeast |> N.toInOrAtLeast ( n5, n10 )\n    --: N (In (Up5 x_) (On N10))\n\n    n11 |> N.minTo n5 |> N.toInOrAtLeast ( n5, n10 )\n    --: N (In (Up5 x_) (On N10))\n    --→ n10\n\n\n    -- ↓ edge cases if you don't set the new minimum as the current one\n\n\n    n7 |> N.toInOrAtLeast ( n6 |> N.minTo n5, n1 |> N.maxTo n10 )\n    --: N (In (Up5 x_) (On N10))\n    --→ n7\n\n    n5 |> N.toInOrAtLeast ( n6 |> N.minTo n5, n1 |> N.maxTo n10 )\n    --: N (In (Up5 x_) (On N10))\n    --→ n6\n\nIn general, you always want to prefer [`toIn`](#toIn)\nand only use this version for type gymnastics\n\nThe type doesn't forbid that the upper limit you're comparing against\nis above the current upper limit\n\n    n10To14 |> N.toInOrAtLeast ( n10, n15 ) |> N.toInt\n    --: N (In (Up10 x_) (On N15))\n\nNot that you should do it, but if you don't set the minimum to the current minimum,\n[`toInOrAtLeast`](#toInOrAtLeast) behaves just like your regular [`toIn`](#toIn):\n\n","type":"( N.N (N.In min (N.Up newMaxMinToMin_ N.To newMax)), N.N (N.In newMaxMin_ (N.On newMax)) ) -> N.N (N.In min max_) -> N.N (N.In min (N.On newMax))"},{"name":"toInt","comment":" Drop the range constraints\nto feed another library with its `Int` representation\n\n    n3\n        |> N.add n5\n        |> N.divideBy n3\n        |> N.toInt\n    --> 2\n\n","type":"N.N range_ -> Basics.Int"},{"name":"toOn","comment":" equatable number → [`On`](#On)\n","type":"asNumber -> N.On asNumber"},{"name":"toPower","comment":" [`N`](#N) Raised to a given power `p ≥ 1`\n→ `x ^ p ≥ x`\n\n    atLeast5 |> N.toPower n2\n    --: N (Min (Up5 x_))\n\n    atLeast2 |> N.toPower n5\n    --: N (Min (Up2 x_))\n\n","type":"N.N (N.In (N.On (N.Add1 exponentMinFrom1_)) exponentMax_) -> N.N (N.In min max_) -> N.N (N.Min min)"},{"name":"toString","comment":" Drop the range constraints\nto feed another library with its `String` representation\n\nEquivalent to\n\n    toInt |> String.fromInt\n\n","type":"N.N range_ -> String.String"}],"binops":[]}]