[{"name":"Hand","comment":" An emptiable-able value.\n\n\n#### in arguments\n\n    import Hand exposing (Empty)\n    import Stack exposing (Stacked)\n\n    fill : Hand fill Never Empty -> fill\n\n    top : Hand (Stacked element) Never Empty -> element\n\n\n#### in type declarations\n\n    import Hand exposing (Empty, Hand)\n    import Stack exposing (Stacked)\n\n    type alias Model =\n        WithoutConstructorFunction\n            { searchKeyWords : Hand (Stacked String) Never Empty\n            }\n\nwhere [`RecordWithoutConstructorFunction`](https://dark.elm.dmy.fr/packages/lue-bird/elm-no-record-type-alias-constructor-function/latest/)\nstops the compiler from creating a constructor function for `Model`.\n\n@docs Hand, Empty\n\n\n## create\n\n@docs empty, filled, fromMaybe\n\n\n## transform\n\n@docs fillMap, fillMapFlat\n@docs fillAnd\n@docs flatten\n@docs fill, fillElseOnEmpty\n@docs toMaybe\n\n\n## type-level\n\n@docs emptyAdapt\n\n","unions":[{"name":"Empty","comment":" A word used in the [`Hand`](#Hand) type:\n\n    top : Hand (Stacked element) Never Empty -> element\n\n    when :\n        Hand ... possiblyOrNever_ Empty\n        -> Hand ... Possibly Empty\n\n","args":[],"cases":[]},{"name":"Hand","comment":" Like `Maybe`, but able to know at type-level whether [`Empty`](#Empty) is possible.\n\n    import Hand exposing (Hand, Empty, filled, fill)\n\n    [ filled 1, filled 7 ]\n        --: List (Hand number_ never_ Empty)\n        |> List.map fill\n    --> [ 1, 7 ]\n\n[`Hand.Empty`](#Empty) alone probably won't be that useful,\nbut it can make data structures type-safely non-emptiable:\n\n    import Hand exposing (fillMap)\n\n    top : Hand (Stacked element) Never Empty -> element\n\n    fillMap Dict.NonEmpty.head\n    --: Hand (NonEmptyDict comparable v) possiblyOrNever Empty\n    --: -> Hand ( comparable, v ) possiblyOrNever Empty\n\nGo take a look at all the data structures in this package.\n\n","args":["fill","possiblyOrNever","emptyTag"],"cases":[["Empty",["possiblyOrNever"]],["Filled",["fill"]]]}],"aliases":[],"values":[{"name":"empty","comment":" Insert joke about life here.\n\n    Hand.empty\n        |> Hand.fillMap (\\x -> x / 0)\n    --> Hand.empty\n\n","type":"Hand.Hand filling_ Possibly.Possibly Hand.Empty"},{"name":"emptyAdapt","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 Hand exposing (Empty)\n    import Possibly exposing (Possibly)\n    import Stack exposing (Stacked)\n\n    type alias Log =\n        Empty Possibly (Stacked String)\n\n    fromStack : Hand (Stacked String) possiblyOrNever_ Empty -> Log\n    fromStack stackFilled =\n        stackFilled\n            --: `possiblyOrNever_` but we need `Possibly`\n            |> Hand.emptyAdapt (always Possible)\n\n\n#### An argument or a type declaration value is `Never Empty`\n\nThe `Never Empty` can't be unified with `Possibly Empty` or a type variable\n\n    import Hand exposing (Empty)\n    import Stack exposing (Stacked)\n\n    theShorter :\n        Hand (Stacked element) Never Empty\n        -> Hand (Stacked element) possiblyOrNever Empty\n        -> Hand (Stacked element) possiblyOrNever Empty\n    theShorter aStack bStack =\n        if Stack.length bStack > Stack.length aStack then\n            bStack\n\n        else\n            aStack\n                --: `Never` but we need `possiblyOrNever`\n                |> Hand.emptyAdapt never\n\nmakes both branches return `possiblyOrNever`.\n\n","type":"(possiblyOrNever -> adaptedPossiblyOrNever) -> Hand.Hand fill possiblyOrNever Hand.Empty -> Hand.Hand fill adaptedPossiblyOrNever Hand.Empty"},{"name":"fill","comment":" Safely extract the [`filled`](#filled) content from a `Hand fill Never Empty`.\n\n    import Hand exposing (Empty, filled)\n\n    filled (filled (filled \"Bami\"))\n        |> Hand.fill\n        |> Hand.fill\n        |> Hand.fill\n    --> \"Bami\"\n\n    first : Empty ( first, others_ ) Never Empty -> first\n    first =\n        Hand.fill >> Tuple.first\n\n","type":"Hand.Hand fill Basics.Never Hand.Empty -> fill"},{"name":"fillAnd","comment":" If the incoming food and the given argument are\n[`filled`](#filled), give a [`filled`](#filled) tuple of both [`fill`](#fill)s back.\n\nIf any is [`empty`](#empty), give a [`Hand.empty`](#empty) back.\n\n[`fillAnd`](#fillAnd) comes in handy when **multiple arguments** need to be [`filled`](#filled):\n\n    import Hand exposing (filled, fillMap, fillAnd)\n\n    filled 3\n        |> fillAnd (filled 4)\n        |> fillAnd (filled 5)\n        |> fillMap (\\( ( a0, a1 ), a2 ) -> a0^a1 - a2^2)\n    --> filled 56\n\n","type":"Hand.Hand anotherFill possiblyOrNever Hand.Empty -> Hand.Hand fill possiblyOrNever Hand.Empty -> Hand.Hand ( fill, anotherFill ) possiblyOrNever Hand.Empty"},{"name":"fillElseOnEmpty","comment":" Lazily use a fallback value if the [`Hand`](#Hand) is [`empty`](#empty).\n\n    import Possibly exposing (Possibly(..))\n    import Hand exposing (Hand(..), fillElseOnEmpty)\n    import Dict\n\n    Dict.empty\n        |> Dict.get \"Hannah\"\n        |> Hand.fromMaybe\n        |> fillElseOnEmpty (\\_ -> \"unknown\")\n    --> \"unknown\"\n\n    fill =\n        fillElseOnEmpty never\n\n    fatten =\n        fillElseOnEmpty Empty\n\n","type":"(possiblyOrNever -> fill) -> Hand.Hand fill possiblyOrNever Hand.Empty -> fill"},{"name":"fillMap","comment":" If the [`Hand`](#Hand) is [`filled`](#filled), change it based on its current [`fill`](#fill):\n\n    import Hand exposing (filled, fillMap)\n\n    filled -3 |> fillMap abs\n    --> filled 3\n\n    Hand.empty |> fillMap abs\n    --> Hand.empty\n\n","type":"(fill -> fillMapped) -> Hand.Hand fill possiblyOrNever Hand.Empty -> Hand.Hand fillMapped possiblyOrNever Hand.Empty"},{"name":"fillMapFlat","comment":" Chain together operations that may return [`empty`](#empty).\nIt's like calling [`fillMap`](#fillMap)`|>`[`flatten`](#flatten):\n\nIf the argument [`Hand.Empty`](#Empty) `Never` [`Empty`](Hand#Empty),\na given function takes its [`fill`](#fill)\nand returns a new possibly [`empty`](#empty) value.\n\nSome call it\n[`andThen`](https://package.elm-lang.org/packages/elm/core/latest/Maybe#andThen)\nor [`flatMap`](https://package.elm-lang.org/packages/ccapndave/elm-flat-map/1.2.0/Maybe-FlatMap#flatMap).\n\n    import Hand exposing (Hand, Empty, fillMapFlat)\n\n    emptiableString\n        |> fillMapFlat parse\n        |> fillMapFlat extraValidation\n\n    parse : ( Char, String ) -> Hand Parsed Possibly Empty\n    extraValidation : Parsed -> Hand Parsed Possibly Empty\n\nFor any number of arguments:\n[`fillAnd`](#fillAnd)`... |> ... |>`[`fillMapFlat`](#fillMapFlat):\n\n    import Hand exposing (filled, fillMapFlat, fillAnd)\n\n    (filled 3)\n        |> fillAnd (filled 4)\n        |> fillAnd (filled 5)\n        |> fillMapFlat\n            (\\( ( a, b ), c ) -> filled ( a, b, c ))\n    --> filled ( 3, 4, 5 )\n\n","type":"(fill -> Hand.Hand fillIfBothFilled possiblyOrNever Hand.Empty) -> Hand.Hand fill possiblyOrNever Hand.Empty -> Hand.Hand fillIfBothFilled possiblyOrNever Hand.Empty"},{"name":"filled","comment":" A [`Hand.Empty`](#Empty) that certainly exists, allowing type-safe extraction.\n\n    import Hand exposing (filled, fill)\n\n    filled \"Bami\" |> fill\n    --> \"Bami\"\n\n","type":"fill -> Hand.Hand fill never_ Hand.Empty"},{"name":"flatten","comment":" In a nestable [`Hand`](#Hand):\nOnly keep it [`filled`](#filled) if the inner [`Hand`](#Hand) is [`filled`](#filled).\n\nSome call it [`join`](https://package.elm-lang.org/packages/elm-community/maybe-extra/latest/Maybe-Extra#join).\n\n    import Hand exposing (filled)\n\n    filled (filled 1) |> Hand.flatten\n    --> filled 1\n\n    filled Hand.empty |> Hand.flatten\n    --> Hand.empty\n\n    Hand.empty |> Hand.flatten\n    --> Hand.empty\n\n","type":"Hand.Hand (Hand.Hand fill possiblyOrNever Hand.Empty) possiblyOrNever Hand.Empty -> Hand.Hand fill possiblyOrNever Hand.Empty"},{"name":"fromMaybe","comment":" Convert a `Maybe` to a [`Hand`](#Hand)`Possibly`[`Hand`](#Empty).\n\nTo _create_ new [`Hand`](#Hand)s, use [`filled`](#filled) and [`empty`](#empty) instead!\n\n","type":"Maybe.Maybe value -> Hand.Hand value Possibly.Possibly Hand.Empty"},{"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":"Hand.Hand fill possiblyOrNever_ Hand.Empty -> Maybe.Maybe fill"}],"binops":[]},{"name":"Scroll","comment":" Items rolled up on both sides of a focus\n→ good fit for dynamic choice selection: tabs, playlist, timeline...\n\n[`Scroll`](#Scroll) can even focus a gap [`Down`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) and [`Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) every item.\n\n1.  🔎 focus on a gap between two items\n2.  🔌 plug that gap with a value\n3.  💰 profit\n\n@docs Scroll, FocusGap\n\n\n## position\n\n@docs Location, nearest\n\n\n## create\n\n@docs empty, only\n\n\n## scan\n\n@docs focusItem, focus\n@docs side\n@docs length\n\n\n## move the focus\n\n@docs to, toGap\n@docs toEnd, toEndGap\n@docs toWhere\n@docs focusDrag\n\n\n## transform\n\n@docs focusItemTry\n@docs map, focusSidesMap\n@docs foldFrom, fold\n@docs toStack, toList\n\n\n### alter\n\n@docs mirror\n@docs focusAlter, sideAlter\n\n\n## type-level\n\n@docs focusGapAdapt\n\n","unions":[{"name":"FocusGap","comment":" A word in every [`Scroll`](#Scroll) type:\n\n  - `🍍 🍓 <🍊> 🍉 🍇`: `Scroll ... Never FocusGap`\n\n  - `🍍 🍓 <?> 🍉 🍇`: `Scroll ...` [`Possibly`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/Possibly) `FocusGap`\n\n    `<?>` means both are possible:\n\n      - `🍍 🍓 <> 🍉 🍇`: a gap between items ... Heh.\n      - `🍍 🍓 <🍊> 🍉 🍇`\n\n","args":[],"cases":[]},{"name":"Location","comment":" Position in a [`Scroll`](#Scroll) relative to its focus.\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty, filled, fillMap, fillMapFlat)\n    import Stack exposing (topDown)\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.to (Scroll.AtSide Up 2)\n        |> fillMap Scroll.focusItem\n    --> filled 3\n    --: Hand (Stacked number_) Possibly Empty\n\n","args":[],"cases":[["AtSide",["Linear.DirectionLinear","Basics.Int"]],["AtFocus",[]]]},{"name":"Scroll","comment":" Items rolled up on both sides of a focus\n→ good fit for dynamic choice selection: tabs, playlist, ...\n\n`Scroll` can even focus a gap `Down` and `Up` every item:\n\n  - `🍍 🍓 <🍊> 🍉 🍇`: `Scroll ... Never FocusGap`\n\n  - `🍍 🍓 <?> 🍉 🍇`: `Scroll ...` [`Possibly`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/Possibly) `FocusGap`\n\n    `<?>` means both are possible:\n\n      - `🍍 🍓 <> 🍉 🍇`: a gap between items ... Heh.\n      - `🍍 🍓 <🍊> 🍉 🍇`\n\n\n#### in arguments\n\n    empty : Scroll item_ Possibly FocusGap\n\n\n#### in types\n\n    type alias Model =\n        RecordWithoutConstructorFunction\n            { choice : Scroll Option Never FocusGap\n            }\n\nwhere [`RecordWithoutConstructorFunction`](https://dark.elm.dmy.fr/packages/lue-bird/elm-no-record-type-alias-constructor-function/latest/)\nstops the compiler from creating a constructor function for `Model`.\n\n","args":["item","possiblyOrNever","focusedOnGapTag"],"cases":[["BeforeFocusAfter",["Hand.Hand (Stack.Stacked item) Possibly.Possibly Hand.Empty","Hand.Hand item possiblyOrNever Hand.Empty","Hand.Hand (Stack.Stacked item) Possibly.Possibly Hand.Empty"]]]}],"aliases":[],"values":[{"name":"empty","comment":" An empty `Scroll` on a gap\nwith nothing before and after it.\nIt's the loneliest of all [`Scroll`](#Scroll)s.\n\n```monospace\n<>\n```\n\n    import Hand\n\n    Scroll.empty |> Scroll.toStack\n    --> Hand.empty\n\n","type":"Scroll.Scroll item_ Possibly.Possibly Scroll.FocusGap"},{"name":"focus","comment":" The focused item or gap.\n\n```monospace\n🍍 🍓 <🍊> 🍉 🍇  ->  🍊\n🍍 🍓 <> 🍉 🍇  ->  _\n```\n\n    import Hand exposing (filled, fill)\n\n    Scroll.empty |> Scroll.focus\n    --> Hand.empty\n\n    Scroll.only \"hi there\" |> Scroll.focus |> fill\n    --> \"hi there\"\n\n[`focusItem`](#focusItem) is short for `focus |> fill`.\n\n","type":"Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Hand.Hand item possiblyOrNever Hand.Empty"},{"name":"focusAlter","comment":" Alter the focus – [item or gap](Hand) – based on its current value.\n\n\n#### `Scroll.focusAlter (\\_ -> 🍊 |> filled)`\n\n```monospace\n🍊  ->  🍓 <?> 🍉  ->  🍓 <🍊> 🍉\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled, fillMap)\n    import Stack exposing (topDown, onTopLay)\n\n    Scroll.empty\n            -- <>\n        |> Scroll.sideAlter\n            ( Down, onTopLay \"🍓\" )\n            -- \"🍓\" <>\n        |> Scroll.sideAlter\n            ( Up, onTopLay \"🍉\" )\n            -- \"🍓\" <> \"🍉\"\n        |> Scroll.focusAlter (\\_ -> \"🍊\" |> filled)\n            -- \"🍓\" <\"🍊\"> \"🍉\"\n        |> Scroll.toStack\n    --> topDown \"🍓\" [ \"🍊\", \"🍉\" ]\n\n\n#### `Scroll.focusAlter (\\_ -> Hand.empty)`\n\n```monospace\n🍓 <?> 🍉  ->  🍓 <> 🍉\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled, fillMap)\n    import Stack exposing (topDown)\n\n    Scroll.only \"hello\"\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"scrollable\" [ \"world\" ] )\n        |> Scroll.to (Up |> Scroll.nearest)\n        |> fillMap (Scroll.focusAlter (\\_ -> Hand.empty))\n        |> fillMap Scroll.toList\n    --> filled [ \"hello\", \"world\" ]\n\n\n#### `Scroll.focusAlter (?🍒 -> ?🍊)`\n\n```monospace\n(?🍒 -> ?🍊)  ->  🍓 <?🍒> 🍉  ->  🍓 <?🍊> 🍉\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled, fillMap)\n    import Stack exposing (topDown, onTopLay)\n\n    Scroll.empty\n            -- <>\n        |> Scroll.sideAlter\n            ( Down, onTopLay \"🍓\" )\n            -- \"🍓\" <>\n        |> Scroll.sideAlter\n            ( Up, onTopLay \"🍉\" )\n            -- \"🍓\" <> \"🍉\"\n        |> Scroll.focusAlter\n            (\\_ -> filled \"🍊\")\n            -- \"🍓\" <\"🍊\"> \"🍉\"\n        |> Scroll.toStack\n    --> topDown \"🍓\" [ \"🍊\", \"🍉\" ]\n\n    Scroll.only \"first\"\n        |> Scroll.sideAlter\n            ( Down, \\_ -> Stack.only \"zeroth\" )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"second\" [ \"third\" ] )\n        |> Scroll.focusAlter (fillMap String.toUpper)\n        |> Scroll.toStack\n    --> topDown \"zeroth\" [ \"FIRST\", \"second\", \"third\" ]\n\n","type":"(Hand.Hand item possiblyOrNever Hand.Empty -> Hand.Hand item possiblyOrNeverAltered Hand.Empty) -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll item possiblyOrNeverAltered Scroll.FocusGap"},{"name":"focusDrag","comment":" Try to move the focus to the nearest item [`Down|Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/).\n\n`Down`\n\n```monospace\n🍊 🍉 <🍓> 🍇  ->  🍊 <🍓> 🍉 🍇\n🍊 🍉 <> 🍇  ->  🍊 <> 🍉 🍇\n```\n\n`Up`\n\n```monospace\n🍊 <🍓> 🍉 🍇  ->  🍊 🍉 <🍓> 🍇\n🍊 <> 🍉 🍇  ->  🍊 🍉 <> 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty, fillMapFlat)\n    import Scroll exposing (Scroll, FocusGap)\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.focusDrag Down\n        |> fillMapFlat Scroll.toStack\n    --> topDown 3 [ 2, 0, 1 ]\n    --: Hand (Stacked number_) Possibly Empty\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.focusDrag Up\n        |> fillMapFlat Scroll.toStack\n    --> topDown 1 [ 0, 2, 3 ]\n    --: Hand (Stacked number_) Possibly Empty\n\nIf there is no nearest item, the result is [`empty`](Hand#empty).\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand\n    import Stack exposing (topDown)\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.focusDrag Down\n    --> Hand.empty\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.focusDrag Up\n    --> Hand.empty\n\n","type":"Linear.DirectionLinear -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Hand.Hand (Scroll.Scroll item possiblyOrNever Scroll.FocusGap) Possibly.Possibly Hand.Empty"},{"name":"focusGapAdapt","comment":" Change the `possiblyOrNever` type\n\n  - A `Scroll ... possiblyOrNever FocusGap`\n    can't be used as a `Scroll ... Possibly`?\n\n        import Possibly exposing (Possibly(..))\n\n        Scroll.focusGapAdapt (always Possible)\n\n  - A `Scroll ... Never FocusGap`\n    can't be unified with `Scroll ... Possibly` or `possiblyOrNever FocusGap`?\n\n        Scroll.focusGapAdapt never\n\nPlease read more at [`Hand.emptyAdapt`](Hand#emptyAdapt).\n\n","type":"(possiblyOrNever -> adaptedPossiblyOrNever) -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll item adaptedPossiblyOrNever Scroll.FocusGap"},{"name":"focusItem","comment":" The focused item.\n\n```monospace\n🍍 🍓 <🍊> 🍉 🍇  ->  🍊\n```\n\n    import Stack exposing (topDown)\n    import Linear exposing (DirectionLinear(..))\n\n    Scroll.only \"hi there\" |> Scroll.focusItem\n    --> \"hi there\"\n\n    Scroll.only 1\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 3, 4 ] )\n        |> Scroll.toEnd Up\n        |> Scroll.focusItem\n    --> 4\n\n","type":"Scroll.Scroll item Basics.Never Scroll.FocusGap -> item"},{"name":"focusItemTry","comment":" [`Hand.empty`](Hand#empty) if the current focussed thing is a gap,\n[`Hand.filled`](Hand#filled) if it's an item.\n\n    import Hand\n    import Stack exposing (topDown)\n    import Linear exposing (DirectionLinear(..))\n\n    Scroll.only 3\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 1 ] )\n        |> Scroll.toGap Up\n        |> Scroll.focusItemTry\n    --> Hand.empty\n\n","type":"Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Hand.Hand (Scroll.Scroll item never_ Scroll.FocusGap) possiblyOrNever Hand.Empty"},{"name":"focusSidesMap","comment":" Change the [`focus`](#focus),\nthe [`side`](#side)s `Down` and `Up`\nusing different functions.\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled, fillMap)\n    import Stack exposing (topDown)\n\n    Scroll.only \"first\"\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Stack.only \"second\" )\n        |> Scroll.toGap Up\n        |> Scroll.focusAlter (\\_ -> filled \"one-and-a-halfth\")\n        |> Scroll.focusSidesMap\n            { side =\n                \\side ->\n                    Stack.map\n                        (\\_ item ->\n                            String.concat\n                                [ side |> sideToString, \": \", item ]\n                        )\n            , focus =\n                fillMap (\\item -> \"focused item: \" ++ item)\n            }\n        |> Scroll.toStack\n    --→\n    topDown\n        \"before: first\"\n        [ \"focused item: one-and-a-halfth\"\n        , \"after: second\"\n        ]\n\n    sideToString =\n        \\side ->\n            case side of\n                Down ->\n                    \"before\"\n\n                Up ->\n                    \"after\"\n\n[`map`](#map) transforms every item.\n\n","type":"{ focus : Hand.Hand item possiblyOrNever Hand.Empty -> Hand.Hand mappedItem possiblyOrNeverMapped Hand.Empty, side : Linear.DirectionLinear -> Hand.Hand (Stack.Stacked item) Possibly.Possibly Hand.Empty -> Hand.Hand (Stack.Stacked mappedItem) possiblyOrNeverMappedBefore_ Hand.Empty } -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll mappedItem possiblyOrNeverMapped Scroll.FocusGap"},{"name":"fold","comment":" Fold in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nfrom the first item [`Up|Down`](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nas the initial accumulation value.\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    Scroll.only 234\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 345 [ 543 ] )\n        |> Scroll.fold ( Up, max )\n    --> 543\n\n","type":"( Linear.DirectionLinear, item -> item -> item ) -> Scroll.Scroll item Basics.Never Scroll.FocusGap -> item"},{"name":"foldFrom","comment":" Reduce in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    Scroll.only 'e'\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 'v' [ 'i', 'l' ] )\n        |> Scroll.foldFrom ( \"\", Down, String.cons )\n    --> \"live\"\n\n    Scroll.only 'e'\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 'v' [ 'i', 'l' ] )\n        |> Scroll.foldFrom ( \"\", Up, String.cons )\n    --> \"evil\"\n\n","type":"( accumulationValue, Linear.DirectionLinear, item -> accumulationValue -> accumulationValue ) -> Scroll.Scroll item Basics.Never Scroll.FocusGap -> accumulationValue"},{"name":"length","comment":" Counting all contained items.\n\n    import Stack exposing (topDown)\n    import Linear exposing (DirectionLinear(..))\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown -1 [ -2 ] )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.length\n    --> 6\n\n    Scroll.empty\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown -1 [ -2 ] )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.length\n    --> 5\n\n","type":"Scroll.Scroll item_ possiblyOrNever_ Scroll.FocusGap -> Basics.Int"},{"name":"map","comment":" Change every item based on its current value.\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    Scroll.only \"first\"\n        |> Scroll.sideAlter\n            ( Down, \\_ -> Stack.only \"zeroth\" )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"second\" [ \"third\" ] )\n        |> Scroll.map (\\_ -> String.toUpper)\n        |> Scroll.toStack\n    --> topDown \"ZEROTH\" [ \"FIRST\", \"SECOND\", \"THIRD\" ]\n\n[`focusSidesMap`](#focusSidesMap) allows changing the individual parts separately.\n\n","type":"(Scroll.Location -> item -> mappedItem) -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll mappedItem possiblyOrNever Scroll.FocusGap"},{"name":"mirror","comment":" Swap the [stack](Stack) on the [`side Down`](#side) the [`focus`](#focus)\nwith the [stack](Stack) on the [`side Up`](#side).\n\n```monospace\n🍓 <🍊> 🍉 🍇  <->  🍇 🍉 <🍊> 🍓\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    Scroll.only 1\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 3, 4 ] )\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 4 [ 3, 2 ] )\n\nIn contrast to `List` or [stack](Stack), this can be done in `O(1)` time.\n\n","type":"Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap"},{"name":"nearest","comment":" The [`Location`](#Location) directly [`Down`|`Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) the focus.\n\n    import Hand exposing (Hand, Empty, filled, fillMap)\n    import Stack exposing (onTopLay, topDown)\n    import Scroll exposing (Scroll, FocusGap)\n    import Linear exposing (DirectionLinear(..))\n\n    Scroll.only \"hello\"\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"scrollable\" [ \"world\" ] )\n        |> Scroll.toEnd Up\n        |> Scroll.to (Down |> Scroll.nearest)\n        |> fillMap Scroll.focusItem\n    --> filled \"scrollable\"\n    --: Hand (Scroll String Never FocusGap) Possibly Empty\n\n    Scroll.empty\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown \"world\" [ \"scrollable\" ] )\n        |> Scroll.to (Down |> Scroll.nearest)\n    --> Scroll.only \"world\"\n    -->     |> Scroll.sideAlter\n    -->         ( Down, \\_ -> Stack.only \"scrollable\" )\n    -->     |> filled\n    --: Hand (Scroll String Never FocusGap) Possibly Empty\n\n    Scroll.empty\n        |> Scroll.sideAlter\n            ( Up, onTopLay \"foo\" )\n        |> Scroll.to (Up |> Scroll.nearest)\n    --> filled (Scroll.only \"foo\")\n    --: Hand (Scroll String Never FocusGap) Possibly\n\n    nearest =\n        \\side ->\n            Scroll.AtSide side 0\n\n","type":"Linear.DirectionLinear -> Scroll.Location"},{"name":"only","comment":" A `Scroll` with a single focussed item in it,\nnothing `Down` and `Up` it.\n\n```monospace\n🍊  ->  <🍊>\n```\n\n    import Stack\n\n    Scroll.only \"wat\" |> Scroll.focusItem\n    --> \"wat\"\n\n    Scroll.only \"wat\" |> Scroll.toStack\n    --> Stack.only \"wat\"\n\n","type":"element -> Scroll.Scroll element never_ Scroll.FocusGap"},{"name":"side","comment":" The [`Stack`](Stack) to one [side](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) of the focus.\n\n`Down`\n\n```monospace\n🍍←🍓) <🍊> 🍉 🍇\n```\n\n`Up`\n\n```monospace\n🍍 🍓 <🍊> (🍉→🍇\n```\n\n    import Hand exposing (Hand, Empty, fillMapFlat)\n    import Stack exposing (Stacked, topDown)\n    import Linear exposing (DirectionLinear(..))\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.to (Up |> Scroll.nearest)\n        |> fillMapFlat (Scroll.to (Up |> Scroll.nearest))\n        |> fillMapFlat (Scroll.side Down)\n    --> topDown 1 [ 0 ]\n    --: Hand (Stacked number_) Possibly Empty\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.to (Up |> Scroll.nearest)\n        |> fillMapFlat (Scroll.side Up)\n    --> topDown 2 [ 3 ]\n    --: Hand (Stacked number_) Possibly Empty\n\n","type":"Linear.DirectionLinear -> Scroll.Scroll item possiblyOrNever_ Scroll.FocusGap -> Hand.Hand (Stack.Stacked item) Possibly.Possibly Hand.Empty"},{"name":"sideAlter","comment":" Look [`Down|Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) the [`focus`](#focus) and operate directly an the [`Stack`](Stack) you see.\n\n\n#### `sideAlter ( DirectionLinear, \\_ -> 🍒🍋 )`\n\n`Down`\n\n```monospace\n🍓 <🍊> 🍉\n      ↓\n🍋 🍒 <🍊> 🍉\n```\n\n`Up`\n\n```monospace\n🍍 🍓 <🍊> 🍉\n      ↓\n🍍 🍓 <🍊> 🍒 🍋\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand\n    import Stack exposing (topDown)\n\n    Scroll.only \"selectoo\"\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown \"earlee\" [ \"agua\", \"enutai\" ] )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"orangloo\" [ \"iquipy\", \"oice\" ] )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Hand.empty )\n        |> Scroll.toStack\n    --> topDown \"enutai\" [ \"agua\", \"earlee\", \"selectoo\" ]\n\n\n#### `sideAlter ( DirectionLinear, Stack.map ... )`\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    Scroll.only \"second\"\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown \"first\" [ \"zeroth\" ] )\n        |> Scroll.sideAlter\n            ( Down, Stack.map (\\_ -> String.toUpper) )\n        |> Scroll.toStack\n    --> topDown \"ZEROTH\" [ \"FIRST\", \"second\" ]\n\n    Scroll.only \"zeroth\"\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"first\" [ \"second\" ] )\n        |> Scroll.sideAlter\n            ( Up, Stack.map (\\_ -> String.toUpper) )\n        |> Scroll.toStack\n    --> topDown \"zeroth\" [ \"FIRST\", \"SECOND\" ]\n\nLook to one [side](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) from the focus\nand slide items in directly at the nearest location.\n\n\n#### `sideAlter ( DirectionLinear, Stack.onTopGlue/onTopStack 🍒🍋 )`\n\n`Down`\n\n```monospace\n      🍒🍋\n🍍 🍓 \\↓/ <🍊> 🍉\n```\n\n`Up`\n\n```monospace\n        🍒🍋\n🍓 <🍊> \\↓/ 🍉 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Down, Stack.onTopGlue [ -4, -5 ] )\n        |> Scroll.sideAlter\n            ( Down, Stack.onTopStack (topDown -1 [ -2, -3 ]) )\n        |> Scroll.toStack\n    --> topDown -5 [ -4, -3, -2, -1, 0 ]\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, Stack.onTopGlue [ 4, 5 ] )\n        |> Scroll.sideAlter\n            ( Up, Stack.onTopStack (topDown 1 [ 2, 3 ]) )\n        |> Scroll.toStack\n    --> topDown 0 [ 1, 2, 3, 4, 5 ]\n\n\n#### `Scroll.sideAlter ( DirectionLinear, \\side -> 🍒🍋 |> onTopStack side )`\n\n`Down`\n\n```monospace\n🍋🍒\n \\↓ 🍍 🍓 <🍊> 🍉\n```\n\n`Up`\n\n```monospace\n              🍒🍋\n🍓 <🍊> 🍉 🍇 ↓/\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown, onTopStack)\n\n    Scroll.only 1\n        |> Scroll.sideAlter\n            ( Up, \\after -> topDown 2 [ 3, 4 ] |> onTopStack after )\n        |> Scroll.toEnd Up\n        |> Scroll.sideAlter\n            ( Down, \\before -> topDown 7 [ 6, 5 ] |> onTopStack before )\n        |> Scroll.toStack\n    --> topDown 5 [ 6, 7, 1, 2, 3, 4 ]\n\n    Scroll.only 123\n        |> Scroll.sideAlter\n            ( Up, \\after -> Stack.only 456 |> onTopStack after )\n        |> Scroll.sideAlter\n            ( Up, \\after -> topDown 789 [ 0 ] |> onTopStack after )\n        |> Scroll.toStack\n    --> topDown 123 [ 456, 789, 0 ]\n\n\n#### `sideAlter ( DirectionLinear,`[`Stack.onTopLay`](Stack#onTopLay) `... )`\n\n`Down`\n\n```monospace\n      🍒\n🍍 🍓 ↓ <🍊> 🍉\n```\n\n\n#### `Up`\n\n```monospace\n        🍒\n🍓 <🍊> ↓ 🍉 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown, onTopLay)\n\n    Scroll.only 123\n        |> Scroll.sideAlter\n            ( Down, onTopLay 456 )\n        |> Scroll.toStack\n    --> topDown 456 [ 123 ]\n\n    Scroll.only 123\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Stack.only 789 )\n        |> Scroll.sideAlter\n            ( Up, onTopLay 456 )\n        |> Scroll.toStack\n    --> topDown 123 [ 456, 789 ]\n\n","type":"( Linear.DirectionLinear, Hand.Hand (Stack.Stacked item) Possibly.Possibly Hand.Empty -> Hand.Hand (Stack.Stacked item) possiblyOrNever_ Hand.Empty ) -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap"},{"name":"to","comment":" Try to move the [`focus`](#focus) to the item at a given [`Scroll.Location`](#Location).\n\n\n#### `Scroll.to (Down |> Scroll.nearest)`\n\n```monospace\n🍊 <🍉> 🍇  ->  <🍊> 🍉 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty, filled, fillMap)\n    import Scroll exposing (Scroll, FocusGap)\n\n    Scroll.empty |> Scroll.to (Down |> Scroll.nearest)\n    --> Hand.empty\n\n    Scroll.only \"hello\"\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown \"scrollable\" [ \"world\" ] )\n        |> Scroll.toEnd Up\n        |> Scroll.to (Down |> Scroll.nearest)\n        |> fillMap Scroll.focusItem\n    --> filled \"scrollable\"\n    --: Hand (Scroll String Never FocusGap) Possibly Empty\n\nThis also works from within gaps:\n\n```monospace\n🍊 🍉 <> 🍇  ->  🍊 <🍉> 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty, filled)\n    import Stack exposing (onTopLay)\n    import Scroll exposing (Scroll, FocusGap)\n\n    Scroll.empty\n        |> Scroll.sideAlter\n            ( Down, onTopLay \"foo\" )\n        |> Scroll.to (Down |> Scroll.nearest)\n    --> filled (Scroll.only \"foo\")\n    --: Hand (Scroll String Never FocusGap) Possibly Empty\n\n\n#### `Scroll.to (Up |> Scroll.nearest)`\n\n```monospace\n<🍊> 🍉 🍇  ->  🍊 <🍉> 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty, filled, fillMap)\n    import Scroll exposing (Scroll, FocusGap)\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.to (Up |> Scroll.nearest)\n        |> fillMap Scroll.focusItem\n    --> filled 1\n    --: Hand number_ Possibly Empty\n\nThis also works from within gaps:\n\n```monospace\n🍊 <> 🍉 🍇  ->  🍊 <🍉> 🍇\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty, filled)\n    import Stack exposing (onTopLay)\n    import Scroll exposing (Scroll, FocusGap)\n\n    Scroll.empty\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Stack.only \"foo\" )\n        |> Scroll.to (Up |> Scroll.nearest)\n    --> filled (Scroll.only \"foo\")\n    --: Hand (Scroll String Never FocusGap) Possibly\n\nIf there is no next item, the result is [`empty`](Hand#empty).\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand\n    import Stack exposing (topDown)\n\n    Scroll.empty |> Scroll.to (Up |> Scroll.nearest)\n    --> Hand.empty\n\n    Scroll.only 0\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 1 [ 2, 3 ] )\n        |> Scroll.toEnd Up\n        |> Scroll.to (Up |> Scroll.nearest)\n    --> Hand.empty\n\n\n#### `Scroll.to Location`\n\n    import Element as Ui\n    import Element.Input as UIn\n    import Hand exposing (fillMap)\n    import RecordWithoutConstructorFunction exposing (RecordWithoutConstructorFunction)\n    import Scroll exposing (FocusGap, Scroll)\n    import Stack\n\n    type alias Model =\n        RecordWithoutConstructorFunction\n            { numbers : Scroll Int Never FocusGap\n            }\n\n    type Event\n        = NumberClicked Scroll.Location\n\n    update : Event -> Model -> ( Model, Cmd Event )\n    update event model =\n        case event of\n            NumberClicked location ->\n                ( { model\n                    | numbers =\n                        model.numbers\n                            |> Scroll.to location\n                            |> Hand.fillElseOnEmpty (\\_ -> model.numbers)\n                            |> Scroll.focusAlter (fillMap (\\n -> n + 1))\n                  }\n                , Cmd.none\n                )\n\n    interface : Model -> Ui.Element Event\n    interface =\n        \\{ numbers } ->\n            numbers\n                |> Scroll.map numberInterface\n                |> Scroll.toList\n                |> Ui.column []\n\n    numberInterface :\n        Scroll.Location\n        -> Int\n        -> Ui.Element Event\n    numberInterface location =\n        \\number ->\n            UIn.button []\n                { onPress = NumberClicked location |> Just\n                , label =\n                    number\n                        |> String.fromInt\n                        |> Ui.text\n                }\n\nThe same _functionality_ is often provided as `duplicate : Scroll item ... -> Scroll (Scroll item) ...`\n\n  - [turboMaCk/non-empty-list-alias: `List.NonEmpty.Zipper.duplicate`](https://package.elm-lang.org/packages/turboMaCk/non-empty-list-alias/latest/List-NonEmpty-Zipper#duplicate)\n  - [miyamoen/select-list: `SelectList.selectedMap`](https://dark.elm.dmy.fr/packages/miyamoen/select-list/latest/SelectList#selectedMap)\n  - [jjant/elm-comonad-zipper: `Zipper.duplicate`](https://package.elm-lang.org/packages/jjant/elm-comonad-zipper/latest/Zipper#duplicate)\n  - [arowM/elm-reference: `Reference.List.unwrap`](https://dark.elm.dmy.fr/packages/arowM/elm-reference/latest/Reference-List#unwrap)\n\nSaving a [`Scroll`](#Scroll) with every item becomes expensive for long [`Scroll`](#Scroll)s, though!\n\n","type":"Scroll.Location -> Scroll.Scroll item possiblyOrNever_ Scroll.FocusGap -> Hand.Hand (Scroll.Scroll item never_ Scroll.FocusGap) Possibly.Possibly Hand.Empty"},{"name":"toEnd","comment":" Focus the furthest item [`Down/Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) the focus.\n\n`Down`\n\n```monospace\n🍍 🍓 <🍊> 🍉  ->  <🍍> 🍓 🍊 🍉\n```\n\n`Up`\n\n```monospace\n🍓 <🍊> 🍉 🍇  ->  🍓 🍊 🍉 <🍇>\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (Hand, Empty)\n    import Stack exposing (Stacked, topDown)\n\n    Scroll.only 1\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 3, 4 ] )\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 4 [ 3, 2 ] )\n        |> Scroll.toEnd Down\n        |> Scroll.focusItem\n    --> 2\n\n    Scroll.only 1\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 3, 4 ] )\n        |> Scroll.toEnd Up\n        |> Scroll.focusItem\n    --> 4\n\n    Scroll.only 1\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 3, 4 ] )\n        |> Scroll.toEnd Up\n        |> Scroll.side Down\n    --> topDown 3 [ 2, 1 ]\n    --: Hand (Stacked number_) Possibly Empty\n\n","type":"Linear.DirectionLinear -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Scroll.Scroll item possiblyOrNever Scroll.FocusGap"},{"name":"toEndGap","comment":" Focus the gap beyond the furthest item [`Down|Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/).\nRemember that gaps surround everything!\n\n`Down`\n\n```monospace\n🍍 🍓 <🍊> 🍉  ->  <> 🍍 🍓 🍊 🍉\n```\n\n`Up`\n\n```monospace\n🍓 <🍊> 🍉  ->  🍓 🍊 🍉 <>\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled)\n    import Stack exposing (topDown)\n\n    Scroll.only 1\n            -- <1>\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 3 [ 4 ] )\n            -- <1> 3 4\n        |> Scroll.toGap Up\n            -- 1 <> 3 4\n        |> Scroll.focusAlter (\\_ -> filled 2)\n            -- 1 <2> 3 4\n        |> Scroll.toEndGap Down\n            -- <> 1 2 3 4\n        |> Scroll.focusAlter (\\_ -> filled 0)\n            -- <0> 1 2 3 4\n        |> Scroll.toStack\n    --> topDown 0 [ 1, 2, 3, 4 ]\n\n    Scroll.only 1\n            -- <1>\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ 3 ] )\n            -- <1> 2 3\n        |> Scroll.toEndGap Up\n            -- 1 2 3 <>\n        |> Scroll.focusAlter (\\_ -> filled 4)\n            -- 1 2 3 <4>\n        |> Scroll.toStack\n    --> topDown 1 [ 2, 3, 4 ]\n\n","type":"Linear.DirectionLinear -> Scroll.Scroll item possiblyOrNever_ Scroll.FocusGap -> Scroll.Scroll item Possibly.Possibly Scroll.FocusGap"},{"name":"toGap","comment":" Move the focus to the gap directly [`Down|Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/).\nFeel free to [plug](#focusAlter) that gap right up!\n\n\n#### `Scroll.toGap Down`\n\n```monospace\n🍍 <🍊> 🍉  ->  🍍 <> 🍊 🍉\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled)\n    import Stack exposing (topDown)\n\n    Scroll.only \"world\"\n        |> Scroll.toGap Down\n        |> Scroll.focusAlter (\\_ -> \"hello\" |> filled)\n        |> Scroll.toStack\n    --> topDown \"hello\" [ \"world\" ]\n\n\n#### `Scroll.toGap Up`\n\n```monospace\n🍍 <🍊> 🍉  ->  🍍 🍊 <> 🍉\n```\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled)\n    import Stack exposing (topDown)\n\n    Scroll.only \"hello\"\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Stack.only \"world\" )\n        |> Scroll.toGap Up\n        |> Scroll.focusAlter (\\_ -> filled \"scrollable\")\n        |> Scroll.toStack\n    --> topDown \"hello\" [ \"scrollable\", \"world\" ]\n\n","type":"Linear.DirectionLinear -> Scroll.Scroll item Basics.Never Scroll.FocusGap -> Scroll.Scroll item Possibly.Possibly Scroll.FocusGap"},{"name":"toList","comment":" Converts it to a `List`, rolled out to both ends:\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack\n\n    Scroll.only 456\n        |> Scroll.sideAlter\n            ( Down, \\_ -> Stack.only 123 )\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Stack.only 789 )\n        |> Scroll.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":"Scroll.Scroll item possiblyOrNever_ Scroll.FocusGap -> List.List item"},{"name":"toStack","comment":" Roll out the `Scroll` to both ends into a [`Stack`](Stack):\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled)\n    import Stack exposing (topDown)\n\n    Scroll.empty\n        |> Scroll.toStack\n    --> Hand.empty\n\n    Scroll.only 123\n        |> Scroll.sideAlter\n            ( Up, \\_ -> Stack.only 789 )\n        |> Scroll.toGap Up\n        |> Scroll.focusAlter (\\_-> filled 456)\n        |> Scroll.toStack\n    --> topDown 123 [ 456, 789 ]\n\nthe type information gets carried over, so\n\n    Never Scroll.FocusGap -> Stacked Never Empty\n    Possibly Scroll.FocusGap -> Stacked Possibly Empty\n\n","type":"Scroll.Scroll item possiblyOrNever Scroll.FocusGap -> Hand.Hand (Stack.Stacked item) possiblyOrNever Hand.Empty"},{"name":"toWhere","comment":" Move the focus to the nearest item [`Down|Up`](https://dark.elm.dmy.fr/packages/lue-bird/elm-linear-direction/latest/) that matches a predicate.\nIf no such item was found return with [`Hand.empty`](Hand#empty).\n\n    import Linear exposing (DirectionLinear(..))\n    import Hand exposing (filled, fillMap)\n    import Stack exposing (topDown)\n    import Linear exposing (DirectionLinear(..))\n\n    Scroll.only 4\n        |> Scroll.sideAlter\n            ( Down, \\_ -> topDown 2 [ -1, 0, 3 ] )\n        |> Scroll.toWhere ( Down, \\_ item -> item < 0 )\n        |> Hand.fillMap Scroll.focusItem\n    --> filled -1\n\n    Scroll.only 4\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ -1, 0, 3 ] )\n        |> Scroll.toWhere ( Up, \\_ item -> item < 0 )\n        |> fillMap focusItem\n    --> filled -1\n\n    Scroll.only -4\n        |> Scroll.sideAlter\n            ( Up, \\_ -> topDown 2 [ -1, 0, 3 ] )\n        |> Scroll.toWhere ( Up, \\_ item -> item < 0 )\n        |> fillMap focusItem\n    --> filled -4\n\n","type":"( Linear.DirectionLinear, { index : Basics.Int } -> item -> Basics.Bool ) -> Scroll.Scroll item possiblyOrNever_ Scroll.FocusGap -> Hand.Hand (Scroll.Scroll item never_ Scroll.FocusGap) Possibly.Possibly Hand.Empty"}],"binops":[]},{"name":"Stack","comment":" An **emptiable or non-empty** data structure where [`top`](#top), [`topRemove`](#topRemove), [`onTopLay`](#onTopLay) [`topMap`](#topMap) are `O(n)`.\n\n@docs Stacked, StackTopBelow\n\n\n## create\n\n[`Hand.empty`](Hand#empty) to create an `Empty Possibly` stack.\n\n@docs only, topDown, fromTopDown, fromList, fromString\n\n\n## scan\n\n@docs top\n@docs length, indexLast\n\n[`topRemove`](#topRemove) brings out everything below the [`top`](#top).\n\n\n## alter\n\n@docs onTopLay, topRemove\n@docs reverse\n\n\n### filter\n\n@docs fills\n\n\n### glue\n\n@docs onTopGlue, onTopStack, onTopStackAdapt\n@docs flatten\n\n\n## transform\n\n@docs map, and, topMap, belowTopMap\n@docs foldFrom, fold\n@docs toTopDown, toList, toString\n\n","unions":[{"name":"StackTopBelow","comment":" [`Stacked`](#Stacked) with a different type for the top element:\n\n    top : Hand (StackTopBelow top belowTopElement_) Never Empty -> top\n\nit's the result of:\n\n  - [`only`](#only)\n  - [`topDown`](#topDown)\n  - [`fromTopDown`](#fromTopDown)\n  - [`onTopLay`](#onTopLay)\n  - [`topMap`](#topMap)\n\n","args":["topElement","belowTopElement"],"cases":[["TopDown",["topElement","List.List belowTopElement"]]]}],"aliases":[{"name":"Stacked","comment":" A non-empty representation of a stack. [`top`](#top), [`topRemove`](#topRemove), [`onTopLay`](#onTopLay) [`topMap`](#topMap) are `O(n)`\n\n\n#### in arguments\n\n[`Hand`](Hand) `(StackFilled ...) Never Empty` → `stack` is non-empty:\n\n    top : Hand (Stacked element) Never -> element\n\n\n#### in results\n\n[`Hand`](Hand) `(StackFilled ...)`[`Possibly`](https://dark.elm.dmy.fr/packages/lue-bird/elm-allowable-state/latest/Possibly) `Empty` → stack could be empty\n\n    fromList : List element -> Hand (Stacked element) Possibly Empty\n\nWe can treat it like any [`Hand`](Hand):\n\n    import Hand exposing (Hand(..), Empty, filled, fillMap)\n    import Possibly exposing (Possibly)\n    import Stack exposing (Stacked, top, onTopLay)\n\n    Hand.empty |> onTopLay \"cherry\" -- works\n\n    toList : Empty possiblyOrNever_ (Stacked element) -> List element\n    toList =\n        \\stack ->\n            case stack of\n                Filled (Stack.TopDown top_ down) ->\n                    top_ :: down\n\n                Empty _ ->\n                    []\n\n    [ \"hi\", \"there\" ] -- comes in as an argument\n        |> Stack.fromList\n        |> fillMap (filled >> top)\n    --: Hand String Possibly Empty\n\nMost operations also allow a different type for the top element → see [`StackTopBelow`](#StackTopBelow)\n\n","args":["element"],"type":"Stack.StackTopBelow element element"}],"values":[{"name":"and","comment":" Combine its elements with elements of a given stack at the same location.\nIf one stack is longer, the extra elements are dropped.\n\n    import Stack exposing (topDown)\n\n    topDown \"alice\" [ \"bob\", \"chuck\" ]\n        |> Stack.and (topDown 2 [ 5, 7, 8 ])\n    --> topDown ( \"alice\", 2 ) [ ( \"bob\", 5 ), ( \"chuck\", 7 ) ]\n\n    topDown 4 [ 5, 6 ]\n        |> Stack.and (topDown 1 [ 2, 3 ])\n        |> Stack.map (\\_ ( n0, n1 ) -> n0 + n1)\n    --> topDown 5 [ 7, 9 ]\n\n","type":"Hand.Hand (Stack.Stacked anotherElement) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked ( element, anotherElement )) possiblyOrNever Hand.Empty"},{"name":"belowTopMap","comment":" Change every element below its [`top`](#top)\nbased on their `{ index }` in the whole stack and their current value.\nTheir type is allowed to change.\n\n    import Stack exposing (topDown, belowTopMap)\n\n    topDown 1 [ 4, 9 ]\n        |> belowTopMap (\\_ -> negate)\n    --> topDown 1 [ -4, -9 ]\n\n","type":"({ index : Basics.Int } -> belowElement -> belowElementMapped) -> Hand.Hand (Stack.StackTopBelow top belowElement) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.StackTopBelow top belowElementMapped) possiblyOrNever Hand.Empty"},{"name":"fills","comment":" Keep all [`filled`](Hand#filled) elements\nand drop all [`empty`](Hand#empty) elements.\n\n    import Hand exposing (filled)\n    import Stack exposing (topDown)\n\n    topDown Hand.empty [ Hand.empty ]\n        |> Stack.fills\n    --> Hand.empty\n\n    topDown (filled 1) [ Hand.empty, filled 3 ]\n        |> Stack.fills\n    --> topDown 1 [ 3 ]\n\nAs you can see, if only the top is [`fill`](Hand#fill) a value, the result is non-empty.\n\n","type":"Hand.Hand (Stack.StackTopBelow (Hand.Hand topContent possiblyOrNever Hand.Empty) (Hand.Hand belowElementContent belowPossiblyOrNever_ Hand.Empty)) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.StackTopBelow topContent belowElementContent) possiblyOrNever Hand.Empty"},{"name":"flatten","comment":" Glue together a bunch of stacks.\n\n    import Hand\n    import Stack exposing (topDown)\n\n    topDown\n        (topDown 0 [ 1 ])\n        [ topDown 10 [ 11 ]\n        , Hand.empty\n        , topDown 20 [ 21, 22 ]\n        ]\n        |> Stack.flatten\n    --> topDown 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":"Hand.Hand (Stack.StackTopBelow (Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty) (Hand.Hand (Stack.Stacked element) belowTopListsPossiblyOrNever_ Hand.Empty)) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty"},{"name":"fold","comment":" Fold from the [`top`](#top) as the initial accumulation value.\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    topDown 234 [ 345, 543 ]\n        |> Stack.fold max\n    --> 543\n\n`fold` doesn't take a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/)\nas an argument because at the time of writing, the best implementation would include a [`Stack.reverse`](#reverse).\n\n","type":"(belowElement -> top -> top) -> Hand.Hand (Stack.StackTopBelow top belowElement) Basics.Never Hand.Empty -> top"},{"name":"foldFrom","comment":" Reduce in a [direction](https://package.elm-lang.org/packages/lue-bird/elm-linear-direction/latest/).\n\n    import Linear exposing (DirectionLinear(..))\n    import Stack exposing (topDown)\n\n    topDown 'l' [ 'i', 'v', 'e' ]\n        |> Stack.foldFrom ( \"\", Down, String.cons )\n    --> \"live\"\n\n    topDown 'l' [ 'i', 'v', 'e' ]\n        |> Stack.foldFrom ( \"\", Up, String.cons )\n    --> \"evil\"\n\nBe aware:\n\n  - `Down` = indexes decreasing, not: from the [`top`](#top) down\n  - `Up` = indexes increasing, not: from the bottom up\n\n","type":"( accumulationValue, Linear.DirectionLinear, element -> accumulationValue -> accumulationValue ) -> Hand.Hand (Stack.Stacked element) possiblyOrNever_ Hand.Empty -> accumulationValue"},{"name":"fromList","comment":" Convert a `List element` to a `Empty Possibly (Stacked element)`.\nThe `List`s `head` becomes [`top`](#top), its `tail` is shoved down below.\n\n    import Possibly exposing (Possibly)\n    import Hand\n    import Stack exposing (topDown)\n\n    [] |> Stack.fromList\n    --> Hand.empty\n\n    [ \"hello\", \"emptiness\" ] |> Stack.fromList\n    --> topDown \"hello\" [ \"emptiness\" ]\n    --: Empty Possibly (Stacked String)\n\nWhen constructing from known elements, always prefer\n\n    import Stack exposing (topDown)\n\n    topDown \"hello\" [ \"emptiness\" ]\n\n","type":"List.List element -> Hand.Hand (Stack.Stacked element) Possibly.Possibly Hand.Empty"},{"name":"fromString","comment":" Convert a `String` to a `Hand (Stacked Char) Possibly Empty`.\nThe `String`s head becomes [`top`](#top), its tail is shoved down below.\n\n    import Possibly exposing (Possibly)\n    import Hand\n    import Stack exposing (topDown)\n\n    \"\" |> Stack.fromString\n    --> Hand.empty\n\n    \"hello\" |> Stack.fromString\n    --> topDown 'h' [ 'e', 'l', 'l', 'o' ]\n    --: Hand (Stacked Char) Possibly Empty\n\nWhen constructing from known elements, always prefer\n\n    import Stack exposing (topDown)\n\n    onTopLay 'h' (\"ello\" |> Stack.fromString)\n\n","type":"String.String -> Hand.Hand (Stack.Stacked Char.Char) Possibly.Possibly Hand.Empty"},{"name":"fromTopDown","comment":" Convert from a tuple `( top, List belowElement )`.\n\nUse [`topDown`](#topDown) if you don't already have a tuple to convert from\n(for example coming from [turboMaCk/non-empty-list-alias](https://dark.elm.dmy.fr/packages/turboMaCk/non-empty-list-alias/latest/List-NonEmpty#NonEmpty))\n\n","type":"( top, List.List belowElement ) -> Hand.Hand (Stack.StackTopBelow top belowElement) never_ Hand.Empty"},{"name":"indexLast","comment":" The position of the element at the bottom.\n\n    import Stack exposing (onTopLay)\n\n    Stack.only 3\n        |> onTopLay 2\n        |> Stack.indexLast\n    --> 1\n\n","type":"Hand.Hand (Stack.StackTopBelow top_ belowElement_) Basics.Never Hand.Empty -> Basics.Int"},{"name":"length","comment":" How many element there are.\n\n    import Stack exposing (onTopLay)\n\n    Stack.only 3\n        |> onTopLay 2\n        |> Stack.length\n    --> 2\n\n","type":"Hand.Hand (Stack.StackTopBelow top_ belowElement_) possiblyOrNever_ Hand.Empty -> Basics.Int"},{"name":"map","comment":" Change every element based on its current value and `{ index }`.\n\n    import Stack exposing (topDown)\n\n    topDown 1 [ 4, 9 ]\n        |> Stack.map (\\_ -> negate)\n    --> topDown -1 [ -4, -9 ]\n\n    topDown 1 [ 2, 3, 4 ]\n        |> Stack.map (\\{ index } n -> index * n)\n    --> topDown 0 [ 2, 6, 12 ]\n\n","type":"({ index : Basics.Int } -> element -> elementMapped) -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked elementMapped) possiblyOrNever Hand.Empty"},{"name":"onTopGlue","comment":" Put the elements of a `List` on [`top`](#top).\n\n    import Stack exposing (topDown, onTopStack)\n\n    topDown 1 [ 2 ]\n        |> Stack.onTopGlue [ -1, 0 ]\n    --> topDown -1 [ 0, 1, 2 ]\n\n`onTopGlue` only when the piped stack food is already `... Never Empty`.\nGlue a stack on top with\n\n  - [`onTopStack`](#onTopStack) takes on the `possiblyOrNever Empty` type of the piped food\n  - [`onTopStackAdapt`](#onTopStackAdapt) takes on the **`possiblyOrNever Empty` type of the argument**\n\n","type":"List.List element -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty"},{"name":"onTopLay","comment":" Add an element to the front.\n\n    import Hand\n    import Stack exposing (topDown, onTopLay)\n\n    topDown 2 [ 3 ] |> onTopLay 1\n    --> topDown 1 [ 2, 3 ]\n\n    Hand.empty |> onTopLay 1\n    --> Stack.only 1\n\n","type":"newTop -> Hand.Hand (Stack.Stacked belowElement) possiblyOrNever_ Hand.Empty -> Hand.Hand (Stack.StackTopBelow newTop belowElement) never_ Hand.Empty"},{"name":"onTopStack","comment":" Glue the elements of a stack to the end of the stack.\n\n    import Stack exposing (topDown, onTopStack)\n\n    topDown 1 [ 2 ]\n        |> onTopStack (topDown -1 [ 0 ])\n    --> topDown -1 [ 0, 1, 2 ]\n\n  - [`onTopStack`](#onTopStack) takes on the `possiblyOrNever Empty` type of the piped food\n  - [`onTopStackAdapt`](#onTopStackAdapt) takes on the `possiblyOrNever Empty` type of the argument\n\n","type":"Hand.Hand (Stack.Stacked element) possiblyOrNeverAppended_ Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty"},{"name":"onTopStackAdapt","comment":" Glue the elements of a `... Empty possiblyOrNever`/`Never` [`Stack`](#Stacked) to the [`top`](#top) of this [`Stack`](Stack).\n\n    import Hand\n    import Stack exposing (topDown, onTopStack, onTopStackAdapt)\n\n    Hand.empty\n        |> onTopStackAdapt (topDown 1 [ 2 ])\n        |> onTopStack (topDown -2 [ -1, 0 ])\n    --> topDown -2 [ -1, 0, 1, 2 ]\n\n  - [`onTopStack`](#onTopStack) takes on the `possiblyOrNever Empty` type of the piped food\n  - [`onTopStackAdapt`](#onTopStackAdapt) takes on the `possiblyOrNever Empty` type of the argument\n\n","type":"Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNeverIn_ Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty"},{"name":"only","comment":" A stack with just 1 single element.\n\n    import Hand\n    import Stack exposing (onTopLay)\n\n    Stack.only \":)\"\n    --> Hand.empty |> onTopLay \":)\"\n\n","type":"top -> Hand.Hand (Stack.StackTopBelow top belowTopElement_) never_ Hand.Empty"},{"name":"reverse","comment":" Flip the order of the elements.\n\n    import Stack exposing (topDown)\n\n    topDown \"l\" [ \"i\", \"v\", \"e\" ]\n        |> Stack.reverse\n    --> topDown \"e\" [ \"v\", \"i\", \"l\" ]\n\n","type":"Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.Stacked element) possiblyOrNever Hand.Empty"},{"name":"toList","comment":" Convert it to a `List`.\n\n    import Stack exposing (topDown)\n\n    topDown 1 [ 7 ] |> Stack.toList\n    --> [ 1, 7 ]\n\nDon't try to use this prematurely.\nKeeping type information as long as possible is always a win.\n\n","type":"Hand.Hand (Stack.Stacked element) possiblyOrNever_ Hand.Empty -> List.List element"},{"name":"toString","comment":" Convert it to a `String`.\n\n    import Stack exposing (topDown)\n\n    topDown 'H' [ 'i' ] |> Stack.toString\n    --> \"Hi\"\n\nDon't try to use this prematurely.\nKeeping type information as long as possible is always a win.\n\n","type":"Hand.Hand (Stack.Stacked Char.Char) possiblyOrNever_ Hand.Empty -> String.String"},{"name":"toTopDown","comment":" Convert to a non-empty list tuple `( top, List belowElement )`.\n\nCurrently equivalent to [`fill`](Hand#fill).\n\n    import Stack exposing (topDown, toTopDown)\n\n    topDown \"hi\" [ \"there\", \"👋\" ]\n        |> toTopDown\n    --> ( \"hi\", [ \"there\", \"👋\" ] )\n\n","type":"Hand.Hand (Stack.StackTopBelow top belowElement) Basics.Never Hand.Empty -> ( top, List.List belowElement )"},{"name":"top","comment":" The first value.\n\n    import Stack exposing (top, onTopLay)\n\n    Stack.only 3\n        |> onTopLay 2\n        |> top\n    --> 2\n\n","type":"Hand.Hand (Stack.StackTopBelow top belowTop_) Basics.Never Hand.Empty -> top"},{"name":"topDown","comment":" A stack from a top element and a `List` of elements below going down.\n","type":"top -> List.List belowElement -> Hand.Hand (Stack.StackTopBelow top belowElement) never_ Hand.Empty"},{"name":"topMap","comment":" Change the [`top`](#top) element based on its current value.\nIts type is allowed to change.\n\n    import Stack exposing (topDown, topMap)\n\n    topDown 1 [ 4, 9 ]\n        |> topMap negate\n    --> topDown -1 [ 4, 9 ]\n\n","type":"(top -> topMapped) -> Hand.Hand (Stack.StackTopBelow top belowElement) possiblyOrNever Hand.Empty -> Hand.Hand (Stack.StackTopBelow topMapped belowElement) possiblyOrNever Hand.Empty"},{"name":"topRemove","comment":" Everything after the first value.\n\n    import Stack exposing (topDown, onTopLay, onTopStack, topRemove)\n\n    Stack.only 2\n        |> onTopLay 3\n        |> onTopStack (topDown 1 [ 0 ])\n        |> topRemove\n    --> topDown 0 [ 3, 2 ]\n    --: Hand (Stacked number_) Possibly Empty\n\n","type":"Hand.Hand (Stack.StackTopBelow top_ belowElement) Basics.Never Hand.Empty -> Hand.Hand (Stack.Stacked belowElement) Possibly.Possibly Hand.Empty"}],"binops":[]}]