[{"name":"N","comment":" Natural number within a typed range\n\n@docs N\n\n\n# bounds\n\n@docs In, Exactly, Min, Infinity\n@docs On, InOn\n@docs Up, Down, To\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\n\n## type `n`\n\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\n\n## type `n +`\n\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\n\n## type `Up x To (n + x)`\n\n[⏭ 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\n\n## exact\n\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\n\n# `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\n@docs toPower, remainderBy, multiplyBy, divideBy\n\n\n## clamp\n\n@docs toAtLeast, toAtLeastMin, toAtMost, toIn\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 OnValue, InOnValue\n@docs toValue, fromValue\n@docs minToValue, minFromValue\n@docs maxToValue, maxFromValue\n\n\n# type information\n\n@docs minTo, minSubtract\n@docs maxTo, maxToInfinity, maxAdd\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 onInfinity, onToNumber\n@docs exactly\n@docs differenceAdd, differenceSubtract\n@docs differenceToInt\n@docs addDifference, subtractDifference\n\n@docs N0OrAdd1\n\n\n## [allowable-state](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/)\n\n@docs number0Adapt, numberMinus1Map\n@docs on0Adapt, onMinus1Map\n\n\n## safe internals without functions\n\n@docs onToValue, onFromValue\n@docs inOnToValue, inOnFromValue\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\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)`...)` / [`InOn`](#InOn)\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 [`OnValue`](#OnValue) for _other_ code\n    that relies (or performs better) on structural `==`\n\n","args":["lowestPossibleAsDifference","highestPossibleAsDifference"],"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 (OnValue 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.toValue\n    --> n9 |> N.toValue\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+ 0`|`4+ 1`|`4+ 2`|...\n    which means it's ≥ 4\n  - the argument's maximum `+` some variable `maxTo15` is `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 (InOn N2 N12)\n\n    -- = 3\n    N (Exactly (On N3))\n\nThere's also versions of this that don't contain functions internally:\n\n    -- ≥ 4\n    N (Min (OnValue N4))\n\n    -- 2 ≤ n ≤ 12\n    N (InOnValue N2 N12)\n\n    -- = 3\n    N (Exactly (OnValue N3))\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","successorMinus1"],"cases":[["N0",["n0PossiblyOrNever"]],["Add1",["successorMinus1"]]]},{"name":"OnValue","comment":" In some cases, it's better or required not to store functions etc. in app state, events, ...:\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 [`OnValue`](#OnValue) 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":["representedNumber"],"cases":[]},{"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":[]},{"name":"Up","comment":" `Up low To high`: a specific number represented as the difference `high - low`\n","args":["lowRepresentationAsNumber","toTag","highRepresentationAsNumber"],"cases":[]}],"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\nUseful as a **stored & argument** type\nin combination with [`typesafe-array`](https://package.elm-lang.org/packages/lue-bird/elm-typesafe-array/latest/),\nnot with [`N`](#N)s\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)) TicTacToField)\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\nUse `Exactly (` [`OnValue`](#OnValue) `...)`\nfor **storing** in a type that can't handle internal functions\n\n","args":["asDifference"],"type":"N.In asDifference asDifference"},{"name":"InOn","comment":" Lower and upper limits [`On`](#On). For stored types only\n\nCan't store functions? → [`InOnValue`](#InOnValue)\n\n","args":["lowestPossibleAsNumber","highestPossibleAsNumber"],"type":"N.In (N.On lowestPossibleAsNumber) (N.On highestPossibleAsNumber)"},{"name":"InOnValue","comment":" Lower and upper limits as [`OnValue`](#OnValue)s. For stored types only\n\nYou can just use [`InOn`](#InOn) when you don't have disadvantages storing functions.\nSee [`OnValue`](#OnValue)\n\n","args":["min","max"],"type":"N.In (N.OnValue min) (N.OnValue max)"},{"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)`...)` / [`InOn`](#InOn)\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\nIf you can't store functions, [`OnValue`](#OnValue)\n\n","args":["lowestPossibleAsDifference"],"type":"N.In lowestPossibleAsDifference (N.OnValue 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` range](#InOn).\nIt will lead to elm crashing because [difference](#Up)s are stored as functions internally.\nInstead,\n\n  - [compare](#compare) in _your_ code\n  - convert to [`OnValue`](#OnValue) for _other_ code\n    that relies (or performs better) on structural `==`\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 [natural number](#N0OrAdd1),\nlike shown in a given [difference](#Up)\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.min n2)\n    --: N (Min (Up7 x_))\n\n","type":"N.N (N.In (N.Up minPlusX N.To sumMinPlusX) addedMax_) -> 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 [natural number](#N0OrAdd1)\n","type":"N.Down high N.To middle -> N.Up low N.To high -> N.Up low N.To middle"},{"name":"differenceToInt","comment":" A [difference](#Up) represented as an `Int` `>= 0`\n\n    N.intToIn ( n3, n6 ) 5\n        |> N.max\n        |> N.differenceToInt\n    --> 6\n\nThis enables for example [`exactly`](#exactly)\n\n","type":"N.Up low_ N.To high_ -> Basics.Int"},{"name":"divideBy","comment":" Divide (`//`) by an [`N`](#N) `d ≥ 1`\n\n  - → `/ 0` is impossible\n  - → `x / d <= x`\n\n.\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 divisorMinMinus1_)) divisorMax_) -> N.N (N.In min_ max) -> N.N (N.In (N.Up0 minX_) max)"},{"name":"exactly","comment":" Create an [`N`](#N) with the value = minimum = maximum of a given difference\n\n    N.intToIn ( n3, n6 ) 5\n        |> N.min\n        |> N.exactly\n        |> N.max\n        |> N.differenceToInt\n    --> 3\n\nTo extract an int directly, [`differenceToInt`](#differenceToInt)\n\nThis is a powerful thing since you can safely create numbers if you have a [difference](#Up)\nand adapt its range afterwards with [`maxTo`](#maxTo), [`minTo`](#minTo)\nor [`maxAdd`](#maxAdd), [`minSubtract`](#minSubtract)\n\n","type":"N.Up low N.To high -> N.N (N.In (N.Up low N.To high) (N.Up low N.To high))"},{"name":"fromValue","comment":" Number with equatable [`OnValue` range](#InOnValue)\n→ number with [`On` range](#InOn) to be [altered](#alter), [compared](#compare), ...\n","type":"N.N (N.InOnValue min max) -> N.N (N.InOn min max)"},{"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 [`toAtLeast`](#toAtLeast) 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 lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) upperLimitMax) ) -> Fuzz.Fuzzer (N.N (N.In lowerLimitMin upperLimitMax))"},{"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 lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) upperLimitMax) ) -> Fuzz.Fuzzer (N.N (N.In lowerLimitMin upperLimitMax))"},{"name":"inOnFromValue","comment":" equatable [`InOnValue`](#InOnValue) → [`InOn`](#InOn)\n","type":"N.InOnValue min max -> N.InOn min max"},{"name":"inOnToValue","comment":" [`InOn`](#InOn) → equatable [`InOnValue`](#InOnValue)\n","type":"N.InOn min max -> N.InOnValue min max"},{"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 lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) upperLimitMax) ) -> Random.Generator (N.N (N.In lowerLimitMin upperLimitMax))"},{"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    inputIntJudge : Int -> Result String (N (In (Up1 minX_) (Up10 maxX_)))\n    inputIntJudge =\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 |> inputIntJudge\n    --> Err \"≤ 0\"\n\n","type":"( N.N (N.In lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) (N.Up upperLimitMaxX N.To upperLimitMaxPlusX)) ) -> Basics.Int -> Result.Result (N.BelowOrAbove Basics.Int (N.N (N.Min (N.Up upperLimitMaxX N.To (N.Add1 upperLimitMaxPlusX))))) (N.N (N.In lowerLimitMin (N.Up upperLimitMaxX N.To upperLimitMaxPlusX)))"},{"name":"intModBy","comment":" Perform [modular arithmetic](https://en.wikipedia.org/wiki/Modular_arithmetic) by an [`N`](#N) `d ≥ 1`.\nWe know `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 divisorMinMinus1_)) (N.Up divMaxX N.To (N.Add1 divisorMaxPlusXMinus1))) -> Basics.Int -> N.N (N.In (N.Up0 remainderMinX_) (N.Up divMaxX N.To divisorMaxPlusXMinus1))"},{"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 lowerLimitMin lowerLimitMax_) -> Basics.Int -> N.N (N.Min lowerLimitMin)"},{"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 lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) upperLimitMax) ) -> Basics.Int -> N.N (N.In lowerLimitMin upperLimitMax)"},{"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 (N.Add1 comparedAgainstMinPlusXMinus1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXMinus1))) -> N.N (N.In min max) -> Result.Result (N.BelowOrAbove (N.N (N.In min (N.Up maxX N.To comparedAgainstMaxPlusXMinus1))) (N.N (N.In (N.Up minX N.To (N.Add2 comparedAgainstMinPlusXMinus1)) max))) (N.N (N.In (N.Up minX N.To (N.Add1 comparedAgainstMinPlusXMinus1)) (N.Up maxX N.To (N.Add1 comparedAgainstMaxPlusXMinus1))))"},{"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 lowerLimitMin (N.Up lowerLimitMaxX N.To (N.Add1 lowerLimitMaxMinus1PlusX))) -> N.N (N.In min max) -> Result.Result (N.N (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxMinus1PlusX))) (N.N (N.In lowerLimitMin 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.sub 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 upperLimitMinX N.To upperLimitMinPlusX) upperLimitMax) -> N.N (N.In min max) -> Result.Result (N.N (N.In (N.Up upperLimitMinX N.To (N.Add1 upperLimitMinPlusX)) max)) (N.N (N.In min upperLimitMax))"},{"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 lowerLimitMin (N.Up lowerLimitMaxX N.To (N.Add1 lowerLimitMaxPlusXMinus1))), N.N (N.In (N.Up upperLimitMinX N.To upperLimitMinPlusX) upperLimitMax) ) -> N.N (N.In min max) -> Result.Result (N.BelowOrAbove (N.N (N.In min (N.Up lowerLimitMaxX N.To lowerLimitMaxPlusXMinus1))) (N.N (N.In (N.Up upperLimitMinX N.To (N.Add1 upperLimitMinPlusX)) max))) (N.N (N.In lowerLimitMin upperLimitMax))"},{"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":"maxFromValue","comment":" Number with equatable [`OnValue`](#OnValue) maximum → number with [`On`](#On) maximum\n","type":"N.N (N.In min (N.OnValue max)) -> N.N (N.In min (N.On max))"},{"name":"maxTo","comment":" Make it fit into functions with require a higher maximum.\n\nYou 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\nBut once 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 maxNewMin) maxNew) -> N.N (N.In min (N.Up maxToMaxNewMin_ N.To maxNewMin)) -> N.N (N.In min maxNew)"},{"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":"maxToValue","comment":" Number with [`On`](#On) maximum\n→ number with equatable [`OnValue`](#OnValue) maximum\n","type":"N.N (N.In min (N.On max)) -> N.N (N.In min (N.OnValue 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 successor 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":" Change the successor type for the case that its [`min`](#min) is 1 + ...\nto allow adapting any 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 successor 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), [`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":"minFromValue","comment":" Number with equatable [`OnValue`](#OnValue) minimum\n→ number with [`On`](#On) minimum\n","type":"N.N (N.In (N.OnValue min) max) -> N.N (N.In (N.On min) max)"},{"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 lower\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":"minToValue","comment":" Number with [`On`](#On) minimum\n→ number with equatable [`OnValue`](#OnValue) minimum\n","type":"N.N (N.In (N.On min) max) -> N.N (N.In (N.OnValue min) max)"},{"name":"multiplyBy","comment":" Multiply by a given [`n`](#N) `≥ 1`.\nwhich 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 multiplicandMinMinus1_)) 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 minus1 -> N.N0OrAdd1 adaptedN0PossiblyOrNever minus1"},{"name":"numberMinus1Map","comment":" Change the type\nfor the case that the [`N0OrAdd1`](#N0OrAdd1) is [`Add1 minus1`](#N0OrAdd1)\n","type":"(minus1 -> mappedMinus1) -> N.N0OrAdd1 n0PossiblyOrNever minus1 -> N.N0OrAdd1 n0PossiblyOrNever mappedMinus1"},{"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 minus1) -> N.On (N.N0OrAdd1 adaptedPossiblyOrNever minus1)"},{"name":"onFromValue","comment":" equatable [`OnValue`](#OnValue) → [`On`](#On)\n","type":"N.OnValue n -> N.On n"},{"name":"onInfinity","comment":" [`On`](#On) [difference up](#Up) to [`Infinity`](#Infinity)\n\n    (N.onInfinity |> N.differenceToInt)\n        == ((1 / 0) |> round)\n    --> True\n\n    (N.onInfinity |> N.onToNumber)\n        == N.Infinity\n    --> True\n\n","type":"N.On N.Infinity"},{"name":"onMinus1Map","comment":" Change the type\nfor the case that the [`N0OrAdd1`](#N0OrAdd1) is [`Add1 minus1`](#N0OrAdd1)\n","type":"(minus1 -> mappedMinus1) -> N.On (N.N0OrAdd1 n0PossiblyOrNever minus1) -> N.On (N.N0OrAdd1 n0PossiblyOrNever mappedMinus1)"},{"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        numberSuccessor :\n            N0OrAdd1 possiblyOrNever successorMinus1\n            -> Emptiable (Stacked element) possiblyOrNever\n        numberSuccessor =\n            \\number ->\n                case number of\n                    N.N0 possiblyOrNever ->\n                        Emptiable.Empty possiblyOrNever\n\n                    N.Add1 successor ->\n                        successor |> 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 [`onToValue`](#onToValue)\n\n","type":"N.On representedNumber -> representedNumber"},{"name":"onToValue","comment":" [`On`](#On) → equatable [`OnValue`](#OnValue)\n","type":"N.On n -> N.OnValue n"},{"name":"range","comment":" Its [limits](#In)\ncontaining both its [`min`](#min)\nand its [`max`](#max)\n","type":"N.N range -> range"},{"name":"remainderBy","comment":" The remainder after dividing by an [`N`](#N) `d ≥ 1`.\nWe know `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 divisorMinMinus1_)) (N.Up divMaxX N.To (N.Add1 divisorMaxPlusXMinus1))) -> N.N range_ -> N.N (N.In (N.Up0 remainderMinX_) (N.Up divMaxX N.To divisorMaxPlusXMinus1))"},{"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 [`toAtMost`](#toAtMost) 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.toValue\n    --> n1 |> N.toValue\n\nOne of the [`N`](#N)s has no maximum constraint? → [`N.subtractMin`](#subtractMin)\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),\nlike shown in a given [difference](#Down)\n","type":"N.Down high N.To low -> high -> low"},{"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 min_) (Up12 maxX_))\n\nUse [`N.subtract`](#subtract) if you want to subtract an [`N`](#N) in a range\n\n","type":"N.N (N.In subtractedDifference0_ (N.Down min N.To differenceMin)) -> N.N (N.In (N.On min) max) -> N.N (N.In (N.On differenceMin) max)"},{"name":"toAtLeast","comment":" **Cap** the [`N`](#N) to `>=` a given new lower limit\n\n    between5And12 |> N.toAtLeast n10\n    --: N (In (Up10 x_) (On N12))\n\nThe type doesn't forbid that the lower limit you're comparing against\nis below the current lower limit\n\n    n15\n        |> N.toAtLeast n10\n        --: N (In (Up10 x_) (On N15))\n        |> N.toInt\n    --> 15\n\nDon't know both maxima? → [`toAtLeastMin`](#toAtLeastMin)\n\n","type":"N.N (N.In minNew (N.Up minNewMaxToMax_ N.To max)) -> N.N (N.In min_ (N.On max)) -> N.N (N.In minNew (N.On 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\nKnow both maxima? → [`toAtLeast`](#toAtLeast)\n\n","type":"N.N (N.In lowerLimitMin lowerLimitMax_) -> N.N range_ -> N.N (N.Min lowerLimitMin)"},{"name":"toAtMost","comment":" **Cap** the [`N`](#N) to `<=` a given new upper limit\n\n    atLeast3\n        |> N.toAtMost (between4And5 |> N.min n3)\n    --: N (In (Up3 minX_) (Up5 maxX_))\n\n  - To enforce a new minimum, too → [`toIn`](#toIn)\n\n","type":"N.N (N.In min upperLimitMax) -> N.N (N.In min max_) -> N.N (N.In min upperLimitMax)"},{"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    atLeast5 |> N.toIn ( n5, n10 )\n    --: N (In (Up5 minX_) (Up10 maxX_))\n\n  - There shouldn't be an upper limit? → [`toAtLeastMin`](#toAtLeastMin)\n  - Keep the current maximum → [`toAtLeast`](#toAtLeast)\n  - Keep the current minimum → [`toAtMost`](#toAtMost)\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 lowerLimitMin (N.Up minNewMaxToMaxNewMin_ N.To upperLimitMin)), N.N (N.In (N.On upperLimitMin) upperLimitMax) ) -> N.N range_ -> N.N (N.In lowerLimitMin upperLimitMax)"},{"name":"toInt","comment":" Drop the range constraints\nto feed another library with its `Int` representation\n","type":"N.N range_ -> Basics.Int"},{"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 exponentMinMinus1_)) 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"},{"name":"toValue","comment":" Number with [`On` range](#InOn) → number with equatable [`OnValue` range](#InOnValue)\n","type":"N.N (N.InOn min max) -> N.N (N.InOnValue min max)"}],"binops":[]}]