[{"name":"PartialOrComplete","comment":" We there, yet?\n\n@docs PartialOrComplete\n\n\n## observe\n\n@docs value, completeElseOnPartial, isComplete\n\n\n## alter\n\n@docs onPartialMapFlat\n\n\n## recurse\n\n@docs recurseUntilComplete\n\n\n## transform\n\n\n### `Maybe`\n\n@docs completeOnJust, justOnComplete\n\n\n### `Result`\n\n@docs completeOnOk, okOnComplete\n\n","unions":[{"name":"PartialOrComplete","comment":" Either we're done and have a `Complete` result,\nor we just have incomplete → `Partial` information.\n\nCheck the [readme](https://dark.elm.dmy.fr/packages/lue-bird/elm-partial-or-complete/latest/) for use-cases\n\n","args":["partial","complete"],"cases":[["Partial",["partial"]],["Complete",["complete"]]]}],"aliases":[],"values":[{"name":"completeElseOnPartial","comment":" Recover the case where the [`PartialOrComplete`](#PartialOrComplete) is `Partial`\nto return a `complete` value.\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n\n    listTakeFromLast : Int -> (List element -> List element)\n    listTakeFromLast lengthToTake list =\n        list\n            |> List.Linear.foldUntilCompleteFrom []\n                Down\n                (\\element takenSoFar ->\n                    if takenSoFar.length >= lengthToTake then\n                        takenSoFar |> Complete\n\n                    else\n                        { length = takenSoFar.length + 1\n                        , list = element :: takenSoFar\n                        }\n                            |> Partial\n                )\n            -- succeed even if we've taken less then the maximum amount of elements\n            |> PartialOrComplete.completeElseOnPartial .list\n\nNote: `PartialOrComplete.completeElseOnPartial identity`\ncan be simplified to [`PartialOrComplete.value`](#value)\n\n","type":"(partial -> complete) -> PartialOrComplete.PartialOrComplete partial complete -> complete"},{"name":"completeOnJust","comment":" `Partial ()` on `Nothing`, `Complete` with the value on `Just`\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n\n    [ Nothing, Nothing, Just 55, Nothing ]\n        |> List.Linear.foldUntilCompleteFrom ()\n            Up\n            (\\element () -> element |> PartialOrComplete.completeOnJust)\n        |> PartialOrComplete.justOnComplete\n    --> Just 55\n\n","type":"Maybe.Maybe complete -> PartialOrComplete.PartialOrComplete () complete"},{"name":"completeOnOk","comment":" `Partial` with the error on `Err`, `Complete` with the value on `Ok`\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n\n    [ Err \"a\", Err \"b\", Ok 55, Err \"d\" ]\n        |> List.Linear.foldUntilCompleteFrom \"empty list\"\n            Up\n            (\\element _ -> element |> PartialOrComplete.completeOnOk)\n        |> PartialOrComplete.okOnComplete\n    --> Ok 55\n\n","type":"Result.Result partial complete -> PartialOrComplete.PartialOrComplete partial complete"},{"name":"isComplete","comment":" Conveniently check whether a [`PartialOrComplete`](#PartialOrComplete) is `Complete`.\n\nPrefer `case..of` except for situations like\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n\n    listMember : element -> (List element -> Bool)\n    listMember needle list =\n        list\n            |> List.Linear.foldUntilCompleteFrom ()\n                Up\n                (\\element () ->\n                    if element == needle then\n                        Complete ()\n\n                    else\n                        Partial ()\n                )\n            |> PartialOrComplete.isComplete\n\n","type":"PartialOrComplete.PartialOrComplete partial_ complete_ -> Basics.Bool"},{"name":"justOnComplete","comment":" `Nothing` on `Partial`, `Just` the complete value on `Complete`.\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n\n    [ Nothing, Nothing, Just 55, Nothing ]\n        |> List.Linear.foldUntilCompleteFrom ()\n            Up\n            (\\element () -> element |> PartialOrComplete.completeOnJust)\n        |> PartialOrComplete.justOnComplete\n    --> Just 55\n\n","type":"PartialOrComplete.PartialOrComplete partial_ complete -> Maybe.Maybe complete"},{"name":"okOnComplete","comment":" `Err` with the value on `Partial`, `Ok` with the value on `Complete`.\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n\n    [ Err \"a\", Err \"b\", Ok 55, Err \"d\" ]\n        |> List.Linear.foldUntilCompleteFrom \"empty list\"\n            Up\n            (\\element _ -> element |> PartialOrComplete.completeOnOk)\n        |> PartialOrComplete.okOnComplete\n    --> Ok 55\n\n","type":"PartialOrComplete.PartialOrComplete partial complete -> Result.Result partial complete"},{"name":"onPartialMapFlat","comment":" In case the [`PartialOrComplete`](#PartialOrComplete)\nis `Partial`, do another step, arriving at another [`PartialOrComplete`](#PartialOrComplete) state.\n\nThis is like an \"andThen\" from the `Partial` case.\n\n","type":"(partial -> PartialOrComplete.PartialOrComplete partialMapped complete) -> PartialOrComplete.PartialOrComplete partial complete -> PartialOrComplete.PartialOrComplete partialMapped complete"},{"name":"recurseUntilComplete","comment":" Create a tail-recursive function of one argument\n\n    pow : Int -> Int -> Int\n    pow base exponent =\n        { result = 1, exponent = abs exponent }\n            |> PartialOrComplete.recurseUntilComplete\n                (\\state ->\n                    case state.exponent of\n                        0 ->\n                            Complete state.result\n\n                        exponentAtLeast1 ->\n                            Partial\n                                { exponent = exponentAtLeast1 - 1\n                                , result = state.result * base\n                                }\n                )\n\n","type":"(partial -> PartialOrComplete.PartialOrComplete partial complete) -> partial -> complete"},{"name":"value","comment":" Treat a `Partial` result the same as if it was `Complete`\n\n    [ Partial 3, Complete 10 ] |> List.map PartialOrComplete.value\n    --> [ 3, 10 ]\n\nOften used after a `...UntilComplete.foldUpFrom`:\n\n    import Linear exposing (Direction(..))\n    import List.Linear\n    import Set exposing (Set)\n\n    whileValidMove : List Movement -> Set ValidMove\n    whileValidMove movementRay =\n        movementRay\n            |> List.Linear.foldUntilCompleteFrom Set.empty\n                Up\n                (\\movement ->\n                    case movement |> toValidMove of\n                        Nothing ->\n                            Complete\n\n                        Just validMove ->\n                            \\soFar -> soFar |> Set.insert validMove |> Partial\n                )\n            -- succeed even if we've reached the end of the board\n            |> PartialOrComplete.value\n\nFor more control over how to recover from a `Partial` case, use a `case..of`\nor [`PartialOrComplete.completeElseOnPartial`](#completeElseOnPartial)\n\n","type":"PartialOrComplete.PartialOrComplete value value -> value"}],"binops":[]}]