[{"name":"Fillable","comment":" An option-able value.\n\n\n#### in arguments\n\n    import Fillable exposing (Empty)\n    import Stack exposing (StackFilled)\n\n    filling : Empty Never filling -> filling\n\n    top : Empty Never (StackFilled element) -> element\n\n\n#### in type declarations\n\n    import Fillable exposing (Empty)\n    import Stack exposing (StackFilled)\n\n    type alias Model =\n        WithoutConstructorFunction\n            { searchKeyWords : Empty Never (StackFilled String)\n            }\n\n    type alias WithoutConstructorFunction record =\n        record\n\nwhere `WithoutConstructorFunction` stops the compiler from creating a positional constructor function for `Model`.\n\n@docs Empty\n\n\n## create\n\n@docs empty, filled, fromMaybe\n\n\n## transform\n\n@docs map, map2, andThen\n@docs filling, toFillingOrIfEmpty, toMaybe\n@docs ifFilled\n\n\n## type-level\n\n@docs adaptType\n\n","unions":[{"name":"Empty","comment":" Like `Maybe`, but able to know at type-level whether `Empty` is possible.\n\n    import Fillable exposing (Empty, filled)\n\n    [ filled 1, filled 7 ]\n        --: List (Empty never_ number_)\n        |> List.map filling\n    --> [ 1, 7 ]\n\n[`Fillable.Empty`](#Empty) alone probably won't be that useful,\nbut it can make data structures type-safely non-emptiable:\n\n    import Fillable exposing (filling)\n\n    top : Empty Never (StackFilled element) -> element\n\n    Fillable.map Dict.NonEmpty.head\n    --: Empty possiblyOrNever (NonEmptyDict comparable v)\n    --: -> Empty possiblyOrNever ( comparable, v ) possiblyOrNever\n\nGo take a look at all the data structures in this package.\n\n","args":["possiblyOrNever","filling"],"cases":[["Empty",["possiblyOrNever"]],["Filled",["filling"]]]}],"aliases":[],"values":[{"name":"adaptType","comment":" Change the `possiblyOrNever` type.\n\n\n#### Returning a type declaration value or argument that is `Empty Possibly`\n\nAn `Empty possiblyOrNever` can't be used as `Empty Possibly`\n\n    import Fillable exposing (Empty)\n    import Possibly exposing (Possibly)\n    import Stack exposing (StackFilled)\n\n    type alias Log =\n        Empty Possibly (StackFilled String)\n\n    fromStack : Empty possiblyOrNever_ (StackFilled String) -> Log\n    fromStack stackFilled =\n        stackFilled\n            --: `possiblyOrNever_` but we need `Possibly`\n            |> Fillable.adaptType (always Possible)\n\n\n#### An argument or a type declaration value is `Empty Never`\n\nThe `Empty Never` can't be unified with `Possibly` or a type variable\n\n    import Fillable exposing (Empty)\n    import Stack exposing (StackFilled)\n\n    theShorter :\n        Empty Never (StackFilled element)\n        -> Empty possiblyOrNever (StackFilled element)\n        -> Empty possiblyOrNever (StackFilled element)\n    theShorter aStack bStack =\n        if Stack.length bStack > Stack.length aStack then\n            bStack\n\n        else\n            --: `Never` but we need `possiblyOrNever`\n            aStack\n\nto make both branches return `possiblyOrNever`, use\n\n    aStack |> Fillable.adaptType never\n\n","type":"(possiblyOrNever -> possiblyOrNeverAdapted) -> Fillable.Empty possiblyOrNever filling -> Fillable.Empty possiblyOrNeverAdapted filling"},{"name":"andThen","comment":" Chain together operations that may return [`empty`](#empty).\n\nIf the argument [`Fillable.Empty`](#Empty) `Never` [`Empty`](Fillable#Empty),\na given function takes its [`filling`](#filling)\nand returns a new possibly [`empty`](#empty) value.\n\nSome call it `flatMap`.\n\n    emptiableString\n        |> Fillable.andThen parse\n        |> Fillable.andThen extraValidation\n\n    parse : ( Char, String ) -> Empty Possibly Parsed\n    extraValidation : Parsed -> Empty Possibly Parsed\n\n","type":"(filling -> Fillable.Empty possiblyOrNever fillingThen) -> Fillable.Empty possiblyOrNever filling -> Fillable.Empty possiblyOrNever fillingThen"},{"name":"empty","comment":" Insert joke about life here.\n\n    empty\n        |> Fillable.map (\\x -> x / 0)\n    --> empty\n\n","type":"Fillable.Empty Possibly.Possibly filling_"},{"name":"filled","comment":" A [`Fillable.Empty`](#Empty) that certainly exists, allowing type-safe extraction.\n\n    import Fillable exposing (filled, filling)\n\n    filled \"Bami\" |> filling\n    --> \"Bami\"\n\n","type":"filling -> Fillable.Empty never_ filling"},{"name":"filling","comment":" Safely extracts the value from an `Empty Never`.\n\n    import Fillable exposing (Empty, filled, filling)\n\n    filled (filled (filled \"Bami\"))\n        |> filling\n        |> filling\n        |> filling\n    --> \"Bami\"\n\n    first : Empty Never ( first, others_ ) -> first\n    first =\n        filling >> Tuple.first\n\n","type":"Fillable.Empty Basics.Never filling -> filling"},{"name":"fromMaybe","comment":" Convert a `Maybe` to a [`Fillable.Empty`](#Empty).\n","type":"Maybe.Maybe value -> Fillable.Empty Possibly.Possibly value"},{"name":"ifFilled","comment":" If we have a `Filled`, alter the value using the [`filling`](#filling).\n\n    import Fillable exposing (filled, ifFilled)\n    import Stack exposing (addOnTop)\n\n    Fillable.empty\n        |> ifFilled addOnTop (filled 3)\n        |> ifFilled addOnTop Fillable.empty\n    --> Stack.only 3\n    --: Empty Possibly (StackFilled number_)\n\nIf you dislike the argument positions, this might be for you:\n\n    import Fillable exposing (filled, ifFilled)\n    import Stack exposing (addOnTop)\n\n    Fillable.empty\n        |> (filled 3 |> ifFilled addOnTop)\n        |> (Fillable.empty |> ifFilled addOnTop)\n    --> Stack.only 3\n    --: Empty Possibly (StackFilled number_)\n\n","type":"(filling -> value -> value) -> Fillable.Empty possiblyOrNever_ filling -> value -> value"},{"name":"map","comment":" Change the possibly `Filled` value based on its current value:\n\n    import Fillable exposing (filled)\n\n    filled -3 |> Fillable.map abs\n    --> filled 3\n\n    Fillable.empty |> Fillable.map abs\n    --> Fillable.empty\n\n","type":"(filling -> fillingMapped) -> Fillable.Empty possiblyOrNever filling -> Fillable.Empty possiblyOrNever fillingMapped"},{"name":"map2","comment":" If all the arguments exist, combine them using a given function.\n\n    import Fillable exposing (filled, empty)\n\n    Fillable.map2 (+) (filled 3) (filled 4) --> filled 7\n    Fillable.map2 (+) (filled 3) empty --> empty\n    Fillable.map2 (+) empty (filled 4) --> empty\n\n","type":"(aFilling -> bFilling -> fillingCombined) -> Fillable.Empty possiblyOrNever aFilling -> Fillable.Empty possiblyOrNever bFilling -> Fillable.Empty possiblyOrNever fillingCombined"},{"name":"toFillingOrIfEmpty","comment":" Lazily use a fallback value if the [`Fillable.Empty`](#Empty) [`empty`](#empty).\n\n    import Possibly exposing (Possibly(..))\n    import Fillable exposing (toFillingOrIfEmpty)\n    import Dict\n\n    Dict.empty\n        |> Dict.get \"Hannah\"\n        |> Fillable.fromMaybe\n        |> toFillingOrIfEmpty (\\_ -> \"unknown\")\n    --> \"unknown\"\n\n    filling =\n        toFillingOrIfEmpty never\n\n","type":"(possiblyOrNever -> filling) -> Fillable.Empty possiblyOrNever filling -> filling"},{"name":"toMaybe","comment":" Convert to a `Maybe`.\n\nDon't try to use this prematurely.\nKeeping type information as long as possible is always a win.\n\n","type":"Fillable.Empty possiblyOrNever_ filling -> Maybe.Maybe filling"}],"binops":[]},{"name":"FocusList","comment":" A list zipper that can also focus on a hole _between_ items.\n\n1.  🔎 focus on a hole between two items\n2.  🔌 plug that hole with a value\n3.  💰 profit\n\n\n## types\n\n@docs ListFocusingHole\n\n\n## create\n\n@docs empty, only\n\n\n## scan\n\n@docs current, before, after\n\n\n## navigate\n\n@docs next, previous, nextHole, previousHole\n@docs first, last, beforeFirst, afterLast\n@docs findForward, findBackward\n\n\n## alter\n\n@docs appendStack, append\n@docs prependStack, prepend\n\n\n### at the focus\n\n@docs alterCurrent, plug, remove\n\n\n### around the focus\n\n@docs alterBefore, alterAfter\n@docs insertAfter, insertBefore\n@docs squeezeStackInBefore, squeezeInBefore\n@docs squeezeStackInAfter, squeezeInAfter\n\n\n## transform\n\n@docs map, mapParts, toStack, toList\n@docs focusingItem\n\n\n## type-level\n\n@docs adaptHoleType\n\n","unions":[{"name":"ListFocusingHole","comment":" A special kind of list with elements of type `item`.\n\nThe focus can be\n\n  - `🍍 🍓 <🍊> 🍉 🍇`: `ListFocusingHole Never`\n\n  - `🍍 🍓 <?> 🍉 🍇`: `ListFocusingHole` [`Possibly`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/Possibly)\n\n    `<?>` means both are possible:\n\n      - `🍍 🍓 <> 🍉 🍇`: a hole between items ... Heh.\n      - `🍍 🍓 <🍊> 🍉 🍇`\n\n\n#### in arguments\n\n    empty : ListFocusingHole Possibly item_\n\n\n#### in types\n\n    type alias Model =\n        WithoutConstructorFunction\n            { choice : ListFocusingHole Never Option\n            }\n\nwhere\n\n    type alias WithoutConstructorFunction record =\n        record\n\nstops the compiler from creating a positional constructor function for `Model`.\n\n","args":["possiblyOrNever","item"],"cases":[]}],"aliases":[],"values":[{"name":"adaptHoleType","comment":" Change the `possiblyOrNever` type.\n\n  - A `ListFocusingHole possiblyOrNever`\n    can't be used as a `ListFocusingHole Possibly`?\n\n        import Possibly exposing (Possible)\n\n        FocusList.adaptType (always Possible)\n\n  - A `ListFocusingHole Never`\n    can't be unified with `ListFocusingHole Possibly` or `possiblyOrNever`?\n\n        FocusList.adaptType never\n\nPlease read more at [`Fillable.adaptType`](Fillable#adaptType).\n\n","type":"(possiblyOrNever -> possiblyOrNeverAdapted) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNeverAdapted item"},{"name":"after","comment":" The items after the location of the focus.\n\n```monospace\n🍍 🍓 <🍊> (🍉 🍇\n```\n\n    import Fillable exposing (Empty, filled)\n    import Stack exposing (StackFilled, topAndBelow)\n\n    FocusList.only 0\n        |> FocusList.append [ 1, 2, 3 ]\n        |> FocusList.next\n        |> Fillable.map FocusList.after\n    --> filled (topAndBelow 2 [ 3 ])\n    --: Empty Possibly (Empty Possibly (StackFilled number_))\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> Fillable.Empty Possibly.Possibly (Stack.StackFilled item)"},{"name":"afterLast","comment":" Focus the hole after the end. Into the nothingness.\n\n```monospace\n🍓 <🍊> 🍉  ->  🍓 🍊 🍉 <>\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 1                 -- <1>\n        |> FocusList.append [ 2, 3 ] -- <1> 2 3\n        |> FocusList.afterLast       -- 1 2 3 <>\n        |> FocusList.plug 4          -- 1 2 3 <4>\n        |> FocusList.toStack\n    --> topAndBelow 1 [ 2, 3, 4 ]\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> FocusList.ListFocusingHole Possibly.Possibly item"},{"name":"alterAfter","comment":" Apply a function to all items coming after the current focussed location.\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"zeroth\"\n        |> FocusList.append [ \"first\", \"second\" ]\n        |> FocusList.alterAfter String.toUpper\n        |> FocusList.toStack\n    --> topAndBelow \"zeroth\" [ \"FIRST\", \"SECOND\" ]\n\n","type":"(item -> item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"alterBefore","comment":" Apply a function to all items coming before the current focussed location.\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"second\"\n        |> FocusList.prepend [ \"zeroth\", \"first\" ]\n        |> FocusList.alterBefore String.toUpper\n        |> FocusList.toStack\n    --> topAndBelow \"ZEROTH\" [ \"FIRST\", \"second\" ]\n\n","type":"(item -> item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"alterCurrent","comment":" If an _item_ is focussed, alter it based on its current value.\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"first\"\n        |> FocusList.prepend [ \"zeroth\" ]\n        |> FocusList.append [ \"second\", \"third\" ]\n        |> FocusList.alterCurrent String.toUpper\n        |> FocusList.toStack\n    --> topAndBelow \"zeroth\" [ \"FIRST\", \"second\", \"third\" ]\n\n","type":"(item -> item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"append","comment":" Put items to the end after anything else.\n\n```monospace\n              🍒🍋\n🍓 <🍊> 🍉 🍇 ↓/\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 123\n        |> FocusList.append [ 456 ]\n        |> FocusList.append [ 789, 0 ]\n        |> FocusList.toStack\n    --> topAndBelow 123 [ 456, 789, 0 ]\n\n","type":"List.List item -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"appendStack","comment":" Put a [stack](Stack) of items to the end after anything else.\n\n```monospace\n              🍒🍋\n🍓 <🍊> 🍉 🍇 ↓/\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 123\n        |> FocusList.append [ 456 ]\n        |> FocusList.append [ 789, 0 ]\n        |> FocusList.toStack\n    --> topAndBelow 123 [ 456, 789, 0 ]\n\n","type":"Fillable.Empty stackPossiblyOrNever_ (Stack.StackFilled item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"before","comment":" The items before the location of the focus.\n\n```monospace\n🍍 🍓) <🍊> 🍉 🍇\n```\n\n    import Fillable exposing (Empty, filled)\n    import Stack exposing (StackFilled, topAndBelow)\n\n    FocusList.only 0\n        |> FocusList.append [ 1, 2, 3 ]\n        |> FocusList.next\n        |> Fillable.andThen FocusList.next\n        |> Fillable.map FocusList.before\n    --> filled (topAndBelow 0 [ 1 ])\n    --: Empty Possibly (Empty Possibly (StackFilled number_))\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> Fillable.Empty Possibly.Possibly (Stack.StackFilled item)"},{"name":"beforeFirst","comment":" Focus the hole before the first item.\nRemember that holes surround everything!\n\n```monospace\n🍍 🍓 <🍊> 🍉  ->  <> 🍍 🍓 🍊 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 1                 -- <1>\n        |> FocusList.append [ 3, 4 ] -- <1> 3 4\n        |> FocusList.nextHole        -- 1 <> 3 4\n        |> FocusList.plug 2          -- 1 <2> 3 4\n        |> FocusList.beforeFirst     -- <> 1 2 3 4\n        |> FocusList.plug 0          -- <0> 1 2 3 4\n        |> FocusList.toStack\n    --> topAndBelow 0 [ 1, 2, 3, 4 ]\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> FocusList.ListFocusingHole Possibly.Possibly item"},{"name":"current","comment":" The current focussed item.\n\n```monospace\n🍍 🍓 <🍊> 🍉 🍇  ->  🍊\n```\n\n    FocusList.only \"hi there\"\n        |> FocusList.current\n    --> \"hi there\"\n\n    FocusList.only 1\n        |> FocusList.append [ 2, 3, 4 ]\n        |> FocusList.last\n        |> FocusList.current\n    --> 4\n\n","type":"FocusList.ListFocusingHole Basics.Never item -> item"},{"name":"empty","comment":" An empty `FocusList` on a hole\nwith nothing before and after it.\nIt's the loneliest of all `FocusList`s.\n\n```monospace\n<>\n```\n\n    import Fillable\n\n    FocusList.empty\n        |> FocusList.toStack\n    --> Fillable.empty\n\n","type":"FocusList.ListFocusingHole Possibly.Possibly item_"},{"name":"findBackward","comment":" Find the first item matching a predicate, moving backwards\nfrom the current position.\n\n    import Fillable exposing (filled)\n\n    FocusList.only 4\n        |> FocusList.prepend [ 2, -1, 0, 3 ]\n        |> FocusList.findBackward (\\item -> item < 0)\n        |> Fillable.map FocusList.current\n    --> filled -1\n\n","type":"(item -> Basics.Bool) -> FocusList.ListFocusingHole possiblyOrNever_ item -> Fillable.Empty Possibly.Possibly (FocusList.ListFocusingHole never_ item)"},{"name":"findForward","comment":" Find the first item in the `FocusList` the matches a predicate,\nreturning a `FocusList` focussed on that item if it was found.\n\nThis start from the current focussed location and searches towards the end.\n\n    import Fillable exposing (filled)\n\n    FocusList.only 4\n        |> FocusList.append [ 2, -1, 0, 3 ]\n        |> FocusList.findForward (\\item -> item < 0)\n        |> Fillable.map FocusList.current\n    --> filled -1\n\n    FocusList.only -4\n        |> FocusList.append [ 2, -1, 0, 3 ]\n        |> FocusList.findForward (\\item -> item < 0)\n        |> Fillable.map FocusList.current\n    --> filled -4\n\n","type":"(item -> Basics.Bool) -> FocusList.ListFocusingHole possiblyOrNever_ item -> Fillable.Empty Possibly.Possibly (FocusList.ListFocusingHole never_ item)"},{"name":"first","comment":" Focus the first item.\n\n```monospace\n🍍 🍓 <🍊> 🍉  ->  <🍍> 🍓 🍊 🍉\n```\n\n    FocusList.only 1\n        |> FocusList.append [ 2, 3, 4 ]\n        |> FocusList.prepend [ 4, 3, 2 ]\n        |> FocusList.first\n        |> FocusList.current\n    --> 4\n\n","type":"FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"focusingItem","comment":" [`Fillable.empty`](Fillable#empty) if the current focussed thing is a hole,\n[`Fillable.filled`](Fillable#filled) if it is an item.\n\n    import Fillable\n\n    FocusList.only 3\n        |> FocusList.append [ 2, 1 ]\n        |> FocusList.nextHole\n        |> FocusList.focusingItem\n    --> Fillable.empty\n\n","type":"FocusList.ListFocusingHole possiblyOrNever item -> Fillable.Empty possiblyOrNever (FocusList.ListFocusingHole never_ item)"},{"name":"insertAfter","comment":" Insert an item after the focussed location.\n\n```monospace\n        🍒\n🍓 <🍊> ↓ 🍉 🍇\n```\n\n    import Stack  exposing (topAndBelow)\n\n    FocusList.only 123\n        |> FocusList.append [ 789 ]\n        |> FocusList.insertAfter 456\n        |> FocusList.toStack\n    --> topAndBelow 123 [ 456, 789 ]\n\nInsert multiple items using [`squeezeInAfter`](#squeezeInAfter).\n\n","type":"item -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"insertBefore","comment":" Insert an item before the focussed location.\n\n```monospace\n      🍒\n🍍 🍓 ↓ <🍊> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 123\n        |> FocusList.insertBefore 456\n        |> FocusList.toStack\n    --> topAndBelow 456 [ 123 ]\n\nInsert multiple items using [`squeezeInBefore`](#squeezeInBefore).\n\n","type":"item -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"last","comment":" Focus the last item.\n\n```monospace\n🍓 <🍊> 🍉 🍇  ->  🍓 🍊 🍉 <🍇>\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 1\n        |> FocusList.append [ 2, 3, 4 ]\n        |> FocusList.last\n        |> FocusList.current\n    --> 4\n\n    FocusList.only 1\n        |> FocusList.append [ 2, 3, 4 ]\n        |> FocusList.last\n        |> FocusList.before\n    --> topAndBelow 1 [ 2, 3 ]\n    --: Empty Possibly (StackFilled number_)\n\n","type":"FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"map","comment":" Change every item based on its current value.\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"first\"\n        |> FocusList.prepend [ \"zeroth\" ]\n        |> FocusList.append [ \"second\", \"third\" ]\n        |> FocusList.map String.toUpper\n        |> FocusList.toStack\n    --> topAndBelow \"ZEROTH\" [ \"FIRST\", \"SECOND\", \"THIRD\" ]\n\n","type":"(item -> mappedItem) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever mappedItem"},{"name":"mapParts","comment":" Apply multiple different functions on the parts of a `FocusList`- what\ncomes before, what comes after, and the current item if there is one.\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"first\"\n        |> FocusList.append [ \"second\" ]\n        |> FocusList.nextHole\n        |> FocusList.plug \"one-and-a-halfth\"\n        |> FocusList.mapParts\n            { before = \\item -> \"before: \" ++ item\n            , current = \\item -> \"current: \" ++ item\n            , after = \\item -> \"after: \" ++ item\n            }\n        |> FocusList.toStack\n    --> topAndBelow\n    -->     \"before: first\"\n    -->     [ \"current: one-and-a-halfth\"\n    -->     , \"after: second\"\n    -->     ]\n\n","type":"{ before : item -> mappedItem, current : item -> mappedItem, after : item -> mappedItem } -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever mappedItem"},{"name":"next","comment":" Move the focus to the next item, if there is one.\n\n```monospace\n<🍊> 🍉 🍇  ->  🍊 <🍉> 🍇\n```\n\n    import Fillable exposing (filled)\n\n    FocusList.only 0\n        |> FocusList.append [ 1, 2, 3 ]\n        |> FocusList.next\n        |> Fillable.map FocusList.current\n    --> filled 1\n\nThis also works from within holes:\n\n```monospace\n🍊 <> 🍉 🍇  ->  🍊 <🍉> 🍇\n```\n\n    import Fillable exposing (Empty, filled)\n\n    FocusList.empty\n        |> FocusList.insertAfter \"foo\"\n        |> FocusList.next\n    --> filled (FocusList.only \"foo\")\n    --: Empty Possibly (ListFocusingHole Never String)\n\nIf there is no `next` item, the result is [`empty`](Fillable#empty).\n\n    import Fillable\n\n    FocusList.empty\n        |> FocusList.next\n    --> Fillable.empty\n\n    FocusList.only 0\n        |> FocusList.append [ 1, 2, 3 ]\n        |> FocusList.last\n        |> FocusList.next\n    --> Fillable.empty\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> Fillable.Empty Possibly.Possibly (FocusList.ListFocusingHole never_ item)"},{"name":"nextHole","comment":" Move the focus to the hole right after the currently focussed location.\nA hole is a whole lot of nothingness, so it's always there.\n\n```monospace\n🍍 <🍊> 🍉  ->  🍍 🍊 <> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"hello\"\n        |> FocusList.append [ \"world\" ]\n        |> FocusList.nextHole\n        |> FocusList.plug \"holey\"\n        |> FocusList.toStack\n    --> topAndBelow \"hello\" [ \"holey\", \"world\" ]\n\n","type":"FocusList.ListFocusingHole Basics.Never item -> FocusList.ListFocusingHole Possibly.Possibly item"},{"name":"only","comment":" A `FocusList` with a single focussed item in it,\nnothing before and after it.\n\n```monospace\n<🍊>\n```\n\n    import Stack\n\n    FocusList.only \"wat\"\n        |> FocusList.current\n    --> \"wat\"\n\n    FocusList.only \"wat\"\n        |> FocusList.toStack\n    --> Stack.only \"wat\"\n\n","type":"element -> FocusList.ListFocusingHole never_ element"},{"name":"plug","comment":" Fill in or replace the focussed thing in the `FocusList`.\n\n```monospace\n🍓 <?> 🍉  ->  🍓 <🍒> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.empty\n        |> FocusList.insertBefore \"🍓\" -- \"🍓\" <>\n        |> FocusList.insertAfter \"🍉\"  -- \"🍓\" <> \"🍉\"\n        |> FocusList.plug \"🍒\"         -- \"🍓\" <\"🍒\"> \"🍉\"\n        |> FocusList.toStack\n    --> topAndBelow \"🍓\" [ \"🍒\", \"🍉\" ]\n\n","type":"item -> FocusList.ListFocusingHole possiblyOrNever_ item -> FocusList.ListFocusingHole never_ item"},{"name":"prepend","comment":" Put items to the beginning before anything else.\n\n```monospace\n🍒🍋\n \\↓ 🍍 🍓 <🍊> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 1\n        |> FocusList.append [ 2, 3, 4 ]\n        |> FocusList.last\n        |> FocusList.prepend [ 5, 6, 7 ]\n        |> FocusList.toStack\n    --> topAndBelow 5 [ 6, 7, 1, 2, 3, 4 ]\n\n","type":"List.List item -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"prependStack","comment":" Put a [stack](Stack) of items to the beginning before anything else.\n\n```monospace\n🍒🍋\n \\↓ 🍍 🍓 <🍊> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 1\n        |> FocusList.append [ 2, 3, 4 ]\n        |> FocusList.last\n        |> FocusList.prependStack (topAndBelow 5 [ 6, 7 ])\n        |> FocusList.toStack\n    --> topAndBelow 5 [ 6, 7, 1, 2, 3, 4 ]\n\n","type":"Fillable.Empty stackPossiblyOrNever_ (Stack.StackFilled item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"previous","comment":" Move the focus to the previous item, if there is one.\n\n```monospace\n🍊 <🍉> 🍇  ->  <🍊> 🍉 🍇\n```\n\n    import Fillable exposing (Empty, filled)\n\n    FocusList.empty |> FocusList.previous\n    --> Fillable.empty\n\n    FocusList.only \"hello\"\n        |> FocusList.append [ \"holey\", \"world\" ]\n        |> FocusList.last\n        |> FocusList.previous\n        |> Fillable.map FocusList.current\n    --> filled \"holey\"\n    --: Empty Possibly (ListFocusingHole Never String)\n\nThis also works from within holes:\n\n```monospace\n🍊 🍉 <> 🍇  ->  🍊 <🍉> 🍇\n```\n\n    import Fillable exposing (Empty, filled)\n\n    FocusList.empty\n        |> FocusList.insertBefore \"foo\"\n        |> FocusList.previous\n    --> filled (FocusList.only \"foo\")\n    --: Empty Possibly (ListFocusingHole Never String)\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> Fillable.Empty Possibly.Possibly (FocusList.ListFocusingHole never_ item)"},{"name":"previousHole","comment":" Move the focus to the hole right before the currently focussed location.\nFeel free to [`plug`](#plug) that hole right up!\n\n```monospace\n🍍 <🍊> 🍉  ->  🍍 <> 🍊 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only \"world\"\n        |> FocusList.previousHole\n        |> FocusList.plug \"hello\"\n        |> FocusList.toStack\n    --> topAndBelow \"hello\" [ \"world\" ]\n\n","type":"FocusList.ListFocusingHole Basics.Never item -> FocusList.ListFocusingHole Possibly.Possibly item"},{"name":"remove","comment":" Punch a hole by removing the focussed thing.\n\n```monospace\n🍓 <?> 🍉  ->  🍓 <> 🍉\n```\n\n    import Fillable exposing (filled)\n\n    FocusList.only \"hello\"\n        |> FocusList.append [ \"holey\", \"world\" ]\n        |> FocusList.next\n        |> Fillable.map FocusList.remove\n        |> Fillable.map FocusList.toList\n    --> filled [ \"hello\", \"world\" ]\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> FocusList.ListFocusingHole Possibly.Possibly item"},{"name":"squeezeInAfter","comment":" Append items directly after the focussed location.\n\n```monospace\n        🍒🍋\n🍓 <🍊> \\↓/ 🍉 🍇\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 0\n        |> FocusList.squeezeInAfter [ 4, 5 ]\n        |> FocusList.squeezeInAfter [ 1, 2, 3 ]\n        |> FocusList.toStack\n    --> topAndBelow 0 [ 1, 2, 3, 4, 5 ]\n\n","type":"List.List item -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"squeezeInBefore","comment":" Prepend items directly before the focussed location.\n\n```monospace\n      🍒🍋\n🍍 🍓 \\↓/ <🍊> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 0\n        |> FocusList.squeezeInBefore [ -5, -4 ]\n        |> FocusList.squeezeInBefore [ -3, -2, -1 ]\n        |> FocusList.toStack\n    --> topAndBelow -5 [ -4, -3, -2, -1, 0 ]\n\n","type":"List.List item -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"squeezeStackInAfter","comment":" Append a [`Stack`](Stack) of items directly after the focussed location.\n\n```monospace\n        🍒🍋\n🍓 <🍊> \\↓/ 🍉 🍇\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 0\n        |> FocusList.squeezeStackInAfter\n            (topAndBelow 4 [ 5 ])\n        |> FocusList.squeezeStackInAfter\n            (topAndBelow 1 [ 2, 3 ])\n        |> FocusList.toStack\n    --> topAndBelow 0 [ 1, 2, 3, 4, 5 ]\n\n","type":"Fillable.Empty Possibly.Possibly (Stack.StackFilled item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"squeezeStackInBefore","comment":" Prepend a [`Stack`](Stack) of items directly before the focussed location.\n\n```monospace\n      🍒🍋\n🍍 🍓 \\↓/ <🍊> 🍉\n```\n\n    import Stack exposing (topAndBelow)\n\n    FocusList.only 0\n        |> FocusList.squeezeStackInBefore\n            (topAndBelow -5 [ -4 ])\n        |> FocusList.squeezeStackInBefore\n            (topAndBelow -3 [ -2, -1 ])\n        |> FocusList.toStack\n    --> topAndBelow -5 [ -4, -3, -2, -1, 0 ]\n\n","type":"Fillable.Empty Possibly.Possibly (Stack.StackFilled item) -> FocusList.ListFocusingHole possiblyOrNever item -> FocusList.ListFocusingHole possiblyOrNever item"},{"name":"toList","comment":" Converts it to a flattened list:\n\n    FocusList.only 456\n        |> FocusList.prepend [ 123 ]\n        |> FocusList.append [ 789 ]\n        |> FocusList.toList\n    --> [ 123, 456, 789 ]\n\nOnly use this if you need a list in the end.\nOtherwise, use [`toStack`](#toStack) to preserve some information about its length.\n\n","type":"FocusList.ListFocusingHole possiblyOrNever_ item -> List.List item"},{"name":"toStack","comment":" Flattens the `FocusList` into a [`Stack`](Stack#StackFilled):\n\n    import Fillable\n    import Stack exposing (topAndBelow)\n\n    FocusList.empty\n        |> FocusList.toStack\n    --> Fillable.empty\n\n    FocusList.only 123\n        |> FocusList.append [ 789 ]\n        |> FocusList.nextHole\n        |> FocusList.plug 456\n        |> FocusList.toStack\n    --> topAndBelow 123 [ 456, 789 ]\n\nthe type information gets carried over, so\n\n    Item -> Stack.Never\n    Possibly\n\n","type":"FocusList.ListFocusingHole possiblyOrNever item -> Fillable.Empty possiblyOrNever (Stack.StackFilled item)"}],"binops":[]},{"name":"Stack","comment":" An **emptiable or non-empty** data structure where [`top`](#top), [`removeTop`](#removeTop), [`addOnTop`](#addOnTop) [`mapTop`](#mapTop) are `O(n)`.\n\n@docs StackFilled, StackWithTop\n\n\n## create\n\n[`Fillable.empty`](Fillable#empty) to create an `Empty Possibly` stack.\n\n@docs only, topAndBelow, fromTopAndBelow, fromList\n\n\n## scan\n\n@docs top, length\n\n\n## alter\n\n@docs addOnTop, removeTop\n@docs splitTop\n@docs reverse\n\n\n### filter\n\n@docs when, whenFilled\n\n\n### glue\n\n@docs stackOnTop, stackTypedOnTop, concat\n\n\n## transform\n\n@docs map, mapTop, mapBelowTop\n@docs foldFrom, fold\n@docs toList, toTopAndBelow\n@docs map2, map2TopAndDown\n\n","unions":[],"aliases":[{"name":"StackFilled","comment":" A non-empty representation of a stack. [`top`](#top), [`removeTop`](#removeTop), [`addOnTop`](#addOnTop) [`mapTop`](#mapTop) are `O(n)`\n\n\n#### in arguments\n\n[`Empty`](Fillable#Empty) `Never (StackFilled ...)` → stack is non-empty:\n\n    top : Empty Never (StackFilled element) -> element\n\n\n#### in results\n\n[`Empty`](Fillable#Empty) [`Possibly`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/Possibly) `(StackFilled ...)` → stack could be empty\n\n    fromList : List element -> Empty Possibly (StackFilled element)\n\nWe can treat it like any [`Fillable.Empty`](Fillable#Empty):\n\n    import Fillable exposing (filled, Empty(..))\n    import Possibly exposing (Possibly)\n    import Stack exposing (StackFilled, top)\n\n    Fillable.empty : Stack Possibly element_ -- fine\n\n    toList : Empty possiblyOrNever_ (StackFilled element) -> List element\n    toList =\n        \\stack ->\n            case stack of\n                Filled ( top_, belowTop_ ) ->\n                    top_ :: belowTop_\n\n                Empty _ ->\n                    []\n\n    [ \"hi\", \"there\" ] -- comes in as an argument\n        |> Stack.fromList\n        |> Fillable.map (filled >> top)\n    --: Empty String Possibly\n\nMost operations also allow a different type for the top element → see [`StackWithTop`](#StackWithTop)\n\n","args":["element"],"type":"Stack.StackWithTop element element"},{"name":"StackWithTop","comment":" [`StackFilled`](#StackFilled) with a different type for the top element:\n\n    top : Empty Never (StackWithTop top belowTopElement_) -> top\n\nit's the result of:\n\n  - [`only`](#only)\n  - [`topAndBelow`](#topAndBelow)\n  - [`fromTopAndBelow`](#fromTopAndBelow)\n  - [`addOnTop`](#addOnTop)\n  - [`mapTop`](#mapTop)\n  - [`map2TopAndDown`](#map2TopAndDown)\n\n","args":["topElement","belowTopElement"],"type":"( topElement, List.List belowTopElement )"}],"values":[{"name":"addOnTop","comment":" Add an element to the front.\n\n    import Fillable\n    import Stack exposing (topAndBelow, addOnTop)\n\n    topAndBelow 2 [ 3 ] |> addOnTop 1\n    --> topAndBelow 1 [ 2, 3 ]\n\n    Fillable.empty |> addOnTop 1\n    --> Stack.only 1\n\n","type":"newTop -> Fillable.Empty possiblyOrNever_ (Stack.StackFilled belowElement) -> Fillable.Empty never_ (Stack.StackWithTop newTop belowElement)"},{"name":"concat","comment":" Glue together a bunch of stacks.\n\n    import Fillable\n    import Stack exposing (topAndBelow)\n\n    topAndBelow\n        (topAndBelow 0 [ 1 ])\n        [ topAndBelow 10 [ 11 ]\n        , Fillable.empty\n        , topAndBelow 20 [ 21, 22 ]\n        ]\n        |> Stack.concat\n    --> topAndBelow 0 [ 1, 10, 11, 20, 21, 22 ]\n\nFor this to return a non-empty stack, there must be a non-empty [`top`](#top) stack.\n\n","type":"Fillable.Empty possiblyOrNever (Stack.StackWithTop (Fillable.Empty possiblyOrNever (Stack.StackFilled element)) (Fillable.Empty belowTopListsPossiblyOrNever_ (Stack.StackFilled element))) -> Fillable.Empty possiblyOrNever (Stack.StackFilled element)"},{"name":"fold","comment":" A fold in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nwhere the initial result is the [`top`](#top).\n\n    import LinearDirection exposing (LinearDirection(..))\n    import Stack exposing (topAndBelow)\n\n    topAndBelow 234 [ 345, 543 ]\n        |> Stack.fold FirstToLast max\n    --> 543\n\n","type":"LinearDirection.LinearDirection -> (belowTopElement -> top -> top) -> Fillable.Empty Basics.Never (Stack.StackWithTop top belowTopElement) -> top"},{"name":"foldFrom","comment":" Reduce in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import LinearDirection exposing (LinearDirection(..))\n    import Stack exposing (topAndBelow)\n\n    topAndBelow 'l' [ 'i', 'v', 'e' ]\n        |> Stack.foldFrom \"\" LastToFirst String.cons\n    --> \"live\"\n\n    topAndBelow 'l' [ 'i', 'v', 'e' ]\n        |> Stack.foldFrom \"\" FirstToLast String.cons\n    --> \"evil\"\n\n","type":"accumulationValue -> LinearDirection.LinearDirection -> (element -> accumulationValue -> accumulationValue) -> Fillable.Empty possiblyOrNever_ (Stack.StackFilled element) -> accumulationValue"},{"name":"fromList","comment":" Convert a `List element` to a `Empty Possibly (StackFilled element)`.\nThe `List`s `head` becomes [`top`](#top), its `tail` is shoved down below.\n\n    import Possibly exposing (Possibly)\n    import Fillable\n    import Stack exposing (topAndBelow)\n\n    [] |> Stack.fromList\n    --> Fillable.empty\n\n    [ \"hello\", \"emptiness\" ] |> Stack.fromList\n    --> topAndBelow \"hello\" [ \"emptiness\" ]\n    --: Empty Possibly (StackFilled String)\n\nWhen constructing from known elements, always prefer\n\n    import Stack exposing (topAndBelow)\n\n    topAndBelow \"hello\" [ \"emptiness\" ]\n\n","type":"List.List element -> Fillable.Empty Possibly.Possibly (Stack.StackFilled element)"},{"name":"fromTopAndBelow","comment":" Convert from a tuple `( top, List belowElement )`.\n\nCurrently equivalent to [`filled`](Fillable#filled).\n\n","type":"( top, List.List belowElement ) -> Fillable.Empty never_ (Stack.StackWithTop top belowElement)"},{"name":"length","comment":" How many element there are.\n\n    import Stack exposing (addOnTop)\n\n    Stack.only 3\n        |> addOnTop 2\n        |> Stack.length\n    --> 2\n\n","type":"Fillable.Empty possiblyOrNever_ (Stack.StackWithTop top_ belowElement_) -> Basics.Int"},{"name":"map","comment":" Apply a function to every element.\n\n    import Stack exposing (topAndBelow)\n\n    topAndBelow 1 [ 4, 9 ]\n        |> Stack.map negate\n    --> topAndBelow -1 [ -4, -9 ]\n\n","type":"(aElement -> bElement) -> Fillable.Empty possiblyOrNever (Stack.StackFilled aElement) -> Fillable.Empty possiblyOrNever (Stack.StackFilled bElement)"},{"name":"map2","comment":" Combine every element in 2 stacks with a given function.\nIf one stack is longer, its extra elements are dropped.\n\n    import Fillable\n    import Stack exposing (topAndBelow)\n\n    Stack.map2 (+)\n        (topAndBelow 1 [ 2, 3 ])\n        (topAndBelow 4 [ 5, 6, 7 ])\n    --> topAndBelow 5 [ 7, 9 ]\n\n    Stack.map2 Tuple.pair\n        (topAndBelow 1 [ 2, 3 ])\n       Fillable.empty\n    --> Fillable.empty\n\nFor [`StackWithTop top belowTopElement`](#StackWithTop) where `top` and `belowTopElement` have a different type,\nthere's [`map2TopAndDown`](#map2TopAndDown).\n\n","type":"(aElement -> bElement -> combinedElement) -> Fillable.Empty possiblyOrNever (Stack.StackFilled aElement) -> Fillable.Empty possiblyOrNever (Stack.StackFilled bElement) -> Fillable.Empty possiblyOrNever (Stack.StackFilled combinedElement)"},{"name":"map2TopAndDown","comment":" Combine the top and below elements of 2 stacks using given functions.\nIf one stack is longer, its extra elements are dropped.\n\n    import Fillable\n    import Stack exposing (topAndBelow, map2TopAndDown)\n\n    map2TopAndDown Tuple.pair (+)\n        (topAndBelow \"hey\" [ 0, 1 ])\n        (topAndBelow \"there\" [ 1, 6, 7 ])\n    --> topAndBelow ( \"hey\", \"there\" ) [ 1, 7 ]\n\n    map2TopAndDown Tuple.pair (+)\n        (topAndBelow 1 [ 2, 3 ])\n       Fillable.empty\n    --> Fillable.empty\n\nUse [`map2`](#map2) if [`top`](#top) and `belowElement` types match.\n\n","type":"(aTop -> bTop -> topCombined) -> (aBelowElement -> bBelowElement -> belowElementCombined) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop aTop aBelowElement) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop bTop bBelowElement) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop topCombined belowElementCombined)"},{"name":"mapBelowTop","comment":" Apply a function to every element of its removeTop.\n\n    import Stack exposing (topAndBelow, mapBelowTop)\n\n    topAndBelow 1 [ 4, 9 ]\n        |> mapBelowTop negate\n    --> topAndBelow 1 [ -4, -9 ]\n\n","type":"(belowElement -> belowElementMapped) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop top belowElement) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop top belowElementMapped)"},{"name":"mapTop","comment":" Change the [`top`](#top) element based on its current value.\nIts type is allowed to change.\n\n    import Stack exposing (topAndBelow, mapTop)\n\n    topAndBelow 1 [ 4, 9 ]\n        |> mapTop negate\n    --> topAndBelow -1 [ 4, 9 ]\n\n","type":"(top -> topMapped) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop top belowElement) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop topMapped belowElement)"},{"name":"only","comment":" A stack with just 1 single element.\n\n    import Fillable\n    import Stack exposing (addOnTop)\n\n    Stack.only \":)\"\n    --> Fillable.empty |> addOnTop \":)\"\n\n","type":"top -> Fillable.Empty never_ (Stack.StackWithTop top belowTopElement_)"},{"name":"removeTop","comment":" Everything after the first value.\n\n    import Stack exposing (topAndBelow, addOnTop, stackOnTop, removeTop)\n\n    Stack.only 2\n        |> addOnTop 3\n        |> stackOnTop (topAndBelow 1 [ 0 ])\n        |> removeTop\n    --> topAndBelow 0 [ 3, 2 ]\n    --: Empty Possibly (StackFilled number_)\n\n","type":"Fillable.Empty Basics.Never (Stack.StackWithTop top_ belowElement) -> Fillable.Empty Possibly.Possibly (Stack.StackFilled belowElement)"},{"name":"reverse","comment":" Flip the order of the elements.\n\n    import Stack exposing (topAndBelow)\n\n    topAndBelow \"l\" [ \"i\", \"v\", \"e\" ]\n        |> Stack.reverse\n    --> topAndBelow \"e\" [ \"v\", \"i\", \"l\" ]\n\n","type":"Fillable.Empty possiblyOrNever (Stack.StackFilled element) -> Fillable.Empty possiblyOrNever (Stack.StackFilled element)"},{"name":"splitTop","comment":" Convert to a non-empty list tuple `( top, List belowElement )`.\n\nCurrently equivalent to [`filling`](Fillable#filling).\n\n    import Stack exposing (StackFilled, topAndBelow, splitTop)\n\n    topAndBelow \"hi\" [ \"there\", \"👋\" ]\n        |> splitTop\n    --> ( \"hi\", topAndBelow \"there\" [ \"👋\" ] )\n    --: ( String, Empty Possibly (StackFilled String) )\n\n","type":"Fillable.Empty Basics.Never (Stack.StackWithTop top belowElement) -> ( top, Fillable.Empty Possibly.Possibly (Stack.StackFilled belowElement) )"},{"name":"stackOnTop","comment":" Glue the elements of a stack to the end of another stack.\n\n    import Stack exposing (topAndBelow, stackOnTop)\n\n    topAndBelow 1 [ 2 ]\n        |> stackOnTop (topAndBelow -1 [ 0 ])\n    --> topAndBelow -1 [ 0, 1, 2 ]\n\nPrefer this over [`stackTypedOnTop`](#stackTypedOnTop) if the piped stack is already known as non-empty\nor if both can be empty.\n\n","type":"Fillable.Empty appendedPossiblyOrNever_ (Stack.StackFilled element) -> Fillable.Empty possiblyOrNever (Stack.StackFilled element) -> Fillable.Empty possiblyOrNever (Stack.StackFilled element)"},{"name":"stackTypedOnTop","comment":" Glue the elements of an `Empty possiblyOrNever`/`Never` [`Stack`](#StackFilled) to the end of a [`Stack`](#StackFilled).\n\n    import Fillable\n    import Stack exposing (topAndBelow, stackOnTop, stackTypedOnTop)\n\n    Fillable.empty\n        |> stackTypedOnTop\n            (topAndBelow 1 [ 2 ])\n        |> stackOnTop\n            (topAndBelow -2 [ -1, 0 ])\n    --> topAndBelow -2 [ -1, 0, 1, 2 ]\n\nPrefer [`stackOnTop`](#stackOnTop) if the piped stack is already known as non-empty\nor if both are `Possibly`.\n\n","type":"Fillable.Empty possiblyOrNever (Stack.StackWithTop newTop element) -> Fillable.Empty inPossiblyOrNever_ (Stack.StackFilled element) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop newTop element)"},{"name":"toList","comment":" Convert it to a `List`.\n\n    import Stack exposing (topAndBelow)\n\n    topAndBelow 1 [ 7 ] |> Stack.toList\n    --> [ 1, 7 ]\n\n","type":"Fillable.Empty possiblyOrNever_ (Stack.StackFilled element) -> List.List element"},{"name":"toTopAndBelow","comment":" Convert to a non-empty list tuple `( top, List belowElement )`.\n\nCurrently equivalent to [`filling`](Fillable#filling).\n\n    import Stack exposing (topAndBelow, toTopAndBelow)\n\n    topAndBelow \"hi\" [ \"there\", \"👋\" ]\n        |> toTopAndBelow\n    --> ( \"hi\", [ \"there\", \"👋\" ] )\n\n","type":"Fillable.Empty Basics.Never (Stack.StackWithTop top belowElement) -> ( top, List.List belowElement )"},{"name":"top","comment":" The first value.\n\n    import Stack exposing (top, addOnTop)\n\n    Stack.only 3\n        |> addOnTop 2\n        |> top\n    --> 2\n\n","type":"Fillable.Empty Basics.Never (Stack.StackWithTop top belowTop_) -> top"},{"name":"topAndBelow","comment":" A stack from a top element and a `List` of elements below going down.\n","type":"top -> List.List belowElement -> Fillable.Empty never_ (Stack.StackWithTop top belowElement)"},{"name":"when","comment":" Keep elements that satisfy a test.\n\n    import Stack exposing (topAndBelow)\n\n    topAndBelow 1 [ 2, 5, -3, 10 ]\n        |> Stack.when (\\x -> x < 5)\n    --> topAndBelow 1 [ 2, -3 ]\n    --: Empty Possibly (StackFilled number_)\n\n","type":"(element -> Basics.Bool) -> Fillable.Empty possiblyOrNever_ (Stack.StackFilled element) -> Fillable.Empty Possibly.Possibly (Stack.StackFilled element)"},{"name":"whenFilled","comment":" Keep all [`filled`](Fillable#filled) values and drop all [`empty`](Fillable#empty) elements.\n\n    import Fillable exposing (filled)\n    import Stack exposing (topAndBelow)\n\n    topAndBelow Fillable.empty [ Fillable.empty ]\n        |> Stack.whenFilled\n    --> Fillable.empty\n\n    topAndBelow (filled 1) [ Fillable.empty, filled 3 ]\n        |> Stack.whenFilled\n    --> topAndBelow 1 [ 3 ]\n\nAs you can see, if only the top is [`filling`](Fillable#filling) a value, the result is non-empty.\n\n","type":"Fillable.Empty possiblyOrNever (Stack.StackWithTop (Fillable.Empty possiblyOrNever topValue) (Fillable.Empty belowPossiblyOrNever_ belowElementValue)) -> Fillable.Empty possiblyOrNever (Stack.StackWithTop topValue belowElementValue)"}],"binops":[]}]