[{"name":"N","comment":" Natural number within a typed range\n\n@docs N\n\n\n# bounds\n\n@docs In, Min\n@docs Fixed, InFixed, Exactly, Infinity\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 it?\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 absoluteInt, modByInt, atLeastInt, inInt\n\n\n### `Int` compare\n\n@docs isAtLeastInt, isInInt\n\n\n# compare\n\n@docs isAtLeast, isAtMost\n@docs BelowOrAbove, is, isIn\n@docs greater, smaller, order\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 atLeast, atLeastMin, atMost, in_\n\n\n## broaden\n\n@docs toInt, toFloat, toString\n\n\n# without internal functions\n\n@docs FixedValue, InFixedValue, ExactlyValue, MinValue, InfinityValue\n@docs toValue, fromValue\n@docs minToValue, minFromValue\n@docs maxToValue, maxFromValue\n\n\n# type information\n\n@docs minTo, minDown\n@docs maxTo, maxToInfinity, maxUp\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), [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 differenceInfinity\n@docs exactly\n@docs differenceAdd, differenceSubtract\n@docs differenceToInt\n@docs addDifference, subtractDifference\n\n@docs N0OrAdd1\n\n\n## safe internals without functions\n\n@docs fixedToValue, fixedFromValue\n@docs inFixedToValue, inFixedFromValue\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":"FixedValue","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 [`FixedValue`](#FixedValue) will yield the correct result instead of crashing\n\n[`Fixed` is defined as a difference from 0](#Fixed), so this independent type needed to be created\n\nYou can just use [`Fixed`](#Fixed) when you don't have disadvantages storing functions\n\n","args":["n"],"cases":[]},{"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 (Fixed (Add3 minX_)) (Up maxTo5_ 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 (Add5 minMinus5_) 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 N2) element\n\nRemember: ↑ and other [`Min`](#Min) `(` [`Fixed`](#Fixed) `...)` / [`Exactly`](#Exactly) / [`InFixed`](#InFixed) aren't 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 [`FixedValue`](#FixedValue) for _other_ code\n    that relies (or performs better) on structural `==`\n\n","args":["min","max"],"cases":[]},{"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\nThis enables adding, subtracting.\nConsider the \"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 (Fixed (Add4 minMinus4_)) max_)\n\n    -- 4 ≤ n ≤ 15\n    N (In (Fixed (Add4 minMinus4_)) (Up maxTo15_ To N15))\n\n`In (Add4 minMinus4_) (Up maxTo15_ To N15)` says:\n\n  - the minimum-constraint can be `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 (Fixed N4))\n\n    -- 2 ≤ n ≤ 12\n    N (InFixed N2 N12)\n\n    -- = 3\n    N (Exactly N3)\n\nThere's also versions of this that don't contain functions internally:\n\n    -- ≥ 4\n    N (Min (FixedValue N4))\n\n    -- 2 ≤ n ≤ 12\n    N (InFixedValue N2 N12)\n\n    -- = 3\n    N (ExactlyValue 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":"To","comment":" Just a word in a [difference type](#Up):\n\n    Up low To high\n\n    Down high To high\n\n→ distance `high - low`\n\n","args":[],"cases":[]},{"name":"Up","comment":" `Up low To high`: an exact number as the difference `high - low`\n","args":["low","toTag","high"],"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`: an exact number as the difference `high - low`\n","args":["high","toTag","low"],"type":"N.Up low toTag high"},{"name":"Exactly","comment":" Allow only a specific [`Fixed`](#Fixed) 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/)s,\nnot with [`N`](#N)s\n\n    byte : ArraySized (Exactly 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 N3)\n            (ArraySized (Exactly 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\n","args":["n"],"type":"N.InFixed n n"},{"name":"ExactlyValue","comment":" For **storing** in a type. Allow only a specific [`FixedValue`](#FixedValue)\n\nYou can just use [`Exactly`](#Exactly) when you don't have disadvantages storing functions.\nSee [`FixedValue`](#FixedValue)\n\n","args":["n"],"type":"N.InFixedValue n n"},{"name":"Fixed","comment":" The [difference](#Up) from [`0`](#N0) to a given `n`\n\nA stored type looks like a [result type](#result-type)\nwhere every [`Up<n> x`](#Up) is instead [`Fixed N<n>`](#Fixed)\n\nDo not use `==` on 2 numbers in a [`Fixed` range](#InFixed).\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 [`FixedValue`](#FixedValue) for _other_ code\n    that relies (or performs better) on structural `==`\n\n","args":["n"],"type":"N.Up N.N0 N.To n"},{"name":"InFixed","comment":" Lower and upper limits [`Fixed`](#Fixed). For stored types only\n\nCan't store functions? → [`InFixedValue`](#InFixedValue)\n\n","args":["min","max"],"type":"N.In (N.Fixed min) (N.Fixed max)"},{"name":"InFixedValue","comment":" Lower and upper limits as [`FixedValue`](#FixedValue)s. For stored types only\n\nYou can just use [`InFixed`](#InFixed) when you don't have disadvantages storing functions.\nSee [`FixedValue`](#FixedValue)\n\n","args":["min","max"],"type":"N.In (N.FixedValue min) (N.FixedValue max)"},{"name":"Infinity","comment":" Flag \"The number's upper limit is unknown\" used in the definition of [`Min`](#Min):\n\n    type alias Min min =\n        In minimum Infinity\n\n","args":[],"type":"N.Fixed { infinity : () }"},{"name":"InfinityValue","comment":" [`Infinity`](#Infinity) as a [`FixedValue`](#FixedValue). Used in\n\n    type alias MinValue min =\n        In (FixedValue min) InfinityValue\n\nYou can just use [`Infinity`](#Infinity) when you don't have disadvantages storing functions.\nSee [`FixedValue`](#FixedValue)\n\n","args":[],"type":"N.FixedValue { infinity : () }"},{"name":"Min","comment":" Only **stored / result types should use the type `Min`**:\n\n       ↓ minimum    ↓ or →\n    ⨯ [✓ ✓ ✓ ✓ ✓ ✓ ✓...\n\n\n### result type without maximum constraint\n\nSometimes, you simply cannot compute a maximum\n\n    absoluteInt : Int -> N (In (Up0 x_) ??)\n                    ↓\n    absoluteInt : 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 (Add5 minMinus5_) 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 (Fixed N1)) element\n\nRemember: ↑ and other [`Min`](#Min)/[`Exactly`](#Exactly)/[`Fixed`](#Fixed) are result/stored types, not argument types\n\nCan't store functions? → [`MinValue`](#MinValue)\n\n","args":["lowestPossibleValue"],"type":"N.In lowestPossibleValue N.Infinity"},{"name":"MinValue","comment":" A lower limit as a [`FixedValue`](#FixedValue). For stored types only\n\nYou can just use [`Min`](#Min) `(` [`Fixed`](#Fixed) `...)` when you don't have disadvantages storing functions.\nSee [`FixedValue`](#FixedValue)\n\n","args":["min"],"type":"N.In (N.FixedValue min) N.InfinityValue"},{"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":"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":"absoluteInt","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.absoluteInt\n        --: N (Min (Up0 x_))\n        |> N.toInt\n    --> 4\n\n    16 |> N.absoluteInt |> N.toInt\n    --> 16\n\nReally only use this if you want the absolute value\n\n    badLength =\n        List.length >> N.absoluteInt\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.minDown 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.atLeastInt n0\n\n","type":"Basics.Int -> N.N (N.Min (N.Up0 x_))"},{"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 [`Fixed`](#Fixed), supply the [`N.minTo`](#minTo) manually\nto re-enable adding both minimum types!\n\n    atLeast5 |> N.addMin (atLeastFixed2 |> 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":"atLeast","comment":" **Cap** the [`N`](#N) to `>=` a given new lower limit\n\n    between5And12 |> N.atLeast n10\n    --: N (In (Up10 x_) (Fixed 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.atLeast n10\n        --: N (In (Up10 x_) (Fixed N15))\n        |> N.toInt\n    --> 15\n\nDon't know both maxima? → [`atLeastMin`](#atLeastMin)\n\n","type":"N.N (N.In minNew (N.Up minNewMaxToMax_ N.To max)) -> N.N (N.In min_ (N.Fixed max)) -> N.N (N.In minNew (N.Fixed max))"},{"name":"atLeastInt","comment":" A `N (Min ...)` from an `Int`;\nif the `Int < minimum`, `minimum` is returned\n\n    0\n        |> N.atLeastInt n3\n        --: N (Min (Up3 x_))\n        |> N.toInt\n    --> 3\n\n    9\n        |> N.atLeastInt 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.minDown n1)\n            (n0 |> N.maxToInfinity)\n\nTo handle the case `< minimum` yourself → [`isAtLeastInt`](#isAtLeastInt)\n\n","type":"N.N (N.In lowerLimitMin lowerLimitMax_) -> Basics.Int -> N.N (N.Min lowerLimitMin)"},{"name":"atLeastMin","comment":" **Cap** the [`N`](#N) to `>=` a given new lower limit\n\n    n5AtLeast |> N.atLeastMin 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.atLeastMin n10 |> N.toInt\n    --: N (Min (Up10 x_))\n\nKnow both maxima? → [`atLeast`](#atLeast)\n\n","type":"N.N (N.In lowerLimitMin lowerLimitMax_) -> N.N range_ -> N.N (N.Min lowerLimitMin)"},{"name":"atMost","comment":" **Cap** the [`N`](#N) to `<=` a given new upper limit\n\n    atLeast3\n        |> N.atMost (between4And5 |> N.min n3)\n    --: N (In (Up3 minX_) (Up5 maxX_))\n\n  - To enforce a new minimum, too → [`in_`](#in_)\n\n","type":"N.N (N.In min upperLimitMax) -> N.N (N.In min max_) -> N.N (N.In min upperLimitMax)"},{"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":"differenceInfinity","comment":" [Difference up](#Up) to [`Infinity`](#Infinity)\n","type":"N.Infinity"},{"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.inInt ( 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.Fixed (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.inInt ( n3, n6 ) 5\n        |> N.min\n        |> N.exactly\n        |> N.max\n        |> N.differenceToInt\n    --> 3\n\nSee [`differenceToInt`](#differenceToInt)\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":"fixedFromValue","comment":" [`Fixed`](#Fixed) → equatable [`FixedValue`](#FixedValue)\n","type":"N.FixedValue n -> N.Fixed n"},{"name":"fixedToValue","comment":" [`Fixed`](#Fixed) → equatable [`FixedValue`](#FixedValue)\n","type":"N.Fixed n -> N.FixedValue n"},{"name":"fromValue","comment":" Number with equatable [`FixedValue` range](#InFixedValue)\n→ number with [`Fixed` range](#InFixed) to be [altered](#alter), [compared](#compare), ...\n","type":"N.N (N.InFixedValue min max) -> N.N (N.InFixed 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.inInt ( n0, n10 ) 3\n        |> N.greater (N.inInt ( n0, n10 ) 1)\n        |> N.toInt\n    --> 3\n\n    N.inInt ( n0, n10 ) 3\n        |> N.greater (N.inInt ( 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 [`atLeast`](#atLeast) instead!\n\n","type":"N.N range -> N.N range -> N.N range"},{"name":"inFixedFromValue","comment":" equatable [`InFixedValue`](#InFixedValue) → [`InFixed`](#InFixed)\n","type":"N.InFixedValue min max -> N.InFixed min max"},{"name":"inFixedToValue","comment":" [`InFixed`](#InFixed) → equatable [`InFixedValue`](#InFixedValue)\n","type":"N.InFixed min max -> N.InFixedValue min max"},{"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.Fixed 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.Fixed upperLimitMin) upperLimitMax) ) -> Fuzz.Fuzzer (N.N (N.In lowerLimitMin upperLimitMax))"},{"name":"inInt","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 [`isInInt`](#isInInt)\n\n    0\n        |> N.inInt ( n3, n12 )\n        --: N (In (Up3 minX_) (Up12 minX_))\n        |> N.toInt\n    --> 3\n\n    99\n        |> N.inInt ( n3, n12 )\n        |> N.toInt\n    --> 12\n\n    9\n        |> N.inInt ( 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.isInInt ( n0, n9 )\n            |> Result.toMaybe\n\n","type":"( N.N (N.In lowerLimitMin (N.Up lowerLimitMaxToUpperLimitMin_ N.To upperLimitMin)), N.N (N.In (N.Fixed upperLimitMin) upperLimitMax) ) -> Basics.Int -> N.N (N.In lowerLimitMin upperLimitMax)"},{"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.Fixed upperLimitMin) upperLimitMax) ) -> Random.Generator (N.N (N.In lowerLimitMin upperLimitMax))"},{"name":"in_","comment":" **Clamp** the number to between both given limits\n\n    between5And9 |> N.in_ ( n10, n10 )\n    --: N (In (Up10 minX_) (Up10 maxX_))\n\n    between5And15 |> N.in_ ( n5, n10 )\n    --: N (In (Up5 minX_) (Up10 maxX_))\n\n    atLeast5 |> N.in_ ( n5, n10 )\n    --: N (In (Up5 minX_) (Up10 maxX_))\n\n  - There shouldn't be an upper limit? → [`atLeastMin`](#atLeastMin)\n  - Keep the current maximum → [`atLeast`](#atLeast)\n  - Keep the current minimum → [`atMost`](#atMost)\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.Fixed upperLimitMin) upperLimitMax) ) -> N.N range_ -> 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 (Fixed (Add19 minMinus19_)) 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 (Fixed (Add18 minMinus18_)) 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":"isAtLeastInt","comment":" If the `Int ≥` a given `minimum`,\nreturn `Ok` with the `N (Min minimum)`,\nelse `Err` with the input `Int`\n\n    4 |> N.isAtLeastInt n5\n    --: Result Int (N (Min (Up5 x_)))\n    --> Err 4\n\n    1234 |> N.isAtLeastInt 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":"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":"isInInt","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.isInInt ( 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.Fixed 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":"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":"maxFromValue","comment":" Number with equatable [`FixedValue`](#FixedValue) maximum → number with [`Fixed`](#Fixed) maximum\n","type":"N.N (N.In min (N.FixedValue max)) -> N.N (N.In min (N.Fixed 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\n","type":"N.N (N.In (N.Fixed 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 [`Fixed`](#Fixed) maximum\n→ number with equatable [`FixedValue`](#FixedValue) maximum\n","type":"N.N (N.In min (N.Fixed max)) -> N.N (N.In min (N.FixedValue max))"},{"name":"maxUp","comment":" Have a specific maximum in mind? → [`N.maxTo`](#maxTo)\n\nWant to increase the upper bound by a fixed amount? → [`maxUp`](#maxUp)\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":"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":"minDown","comment":" Have a specific minimum in mind? → [`N.minTo`](#minTo)\n\nWant to decrease the lower bound by a fixed amount? → [`minDown`](#minDown)\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":"minFromValue","comment":" Number with equatable [`FixedValue`](#FixedValue) minimum\n→ number with [`Fixed`](#Fixed) minimum\n","type":"N.N (N.In (N.FixedValue min) max) -> N.N (N.In (N.Fixed min) max)"},{"name":"minTo","comment":" Set the 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\n","type":"N.N (N.In minNew (N.Up minNewMaxToMin_ N.To min)) -> N.N (N.In (N.Fixed min) max) -> N.N (N.In minNew max)"},{"name":"minToValue","comment":" Number with [`Fixed`](#Fixed) minimum\n→ number with equatable [`FixedValue`](#FixedValue) minimum\n","type":"N.N (N.In (N.Fixed min) max) -> N.N (N.In (N.FixedValue min) max)"},{"name":"modByInt","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.modByInt 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.modByInt 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.Fixed (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":"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.Fixed (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":"order","comment":" Increasing [`Order`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/Order)\nbetween 2 [`N`](#N)s\n\n    N.order n14 n2\n    --> GT\n\n    N.order n4 n4\n    --> EQ\n\n    n12 |> N.order n4\n    --> LT\n\n","type":"N.N range0_ -> N.N range1_ -> Basics.Order"},{"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.Fixed (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.inInt ( n0, n10 ) 3\n        |> N.smaller (N.inInt ( n0, n10 ) 1)\n        |> N.toInt\n    --> 1\n\n    N.inInt ( n0, n10 ) 3\n        |> N.smaller (N.inInt ( 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 [`atMost`](#atMost) 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 (Fixed 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.Fixed min) (N.Up maxX N.To maxPlusX)) -> N.N (N.In (N.Fixed 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 (Fixed N5))\n\n    atLeast6 |> N.subtractMin between0And5\n    --: N (Min (Fixed N1))\n\n    between6And12 |> N.subtractMin between1And5\n    --: N (In (Fixed 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.Fixed min) max) -> N.N (N.In (N.Fixed differenceMin) max)"},{"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":"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.Fixed (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 [`Fixed` range](#InFixed) → number with equatable [`FixedValue` range](#InFixedValue)\n","type":"N.N (N.InFixed min max) -> N.N (N.InFixedValue min max)"}],"binops":[]}]