[{"name":"Accessors","comment":" Accessors are a way of operating on nested data in Elm that doesn't require gobs of boilerplate.\n\n\n## Optic: is the opaque underlying interface that enables the rest of the library to work.\n\n@docs Optic\n\n\n## Type Aliases: are shorthands from the Optics nomenclature that make writing your own accessors more convenient and hopefully easier to understand.\n\n@docs Iso, Lens, Prism, Traversal\n\n\n## Constructors\n\nAccessors are built using these functions:\n\n@docs traversal, lens, prism, iso\n\n\n## Action functions\n\nAction functions are functions that take an accessor and let you perform a\nspecific action on data using that accessor.\n\n@docs get, all, try, has, is, map, over, set, new, name, to, from\n\n\n## Lifters for composing w/ indexed optics\n\n@docs ixd\n\n\n## Type aliases for custom and action functions\n\n@docs Iso_, Lens_, Prism_, Traversal_\n@docs An_Optic, An_Iso, A_Lens, A_Prism\n@docs An_Optic_, An_Iso_, A_Lens_, A_Prism_\n\n\n## Common Optics to mitigate `import` noise. Not everything is re-exported.\n\n@docs just, ok, err\n@docs values, keyed, key, keyI, key_\n@docs each, eachIdx, at\n@docs every, everyIdx, ix\n@docs fst, snd\n\n","unions":[],"aliases":[{"name":"A_Lens","comment":" This MUST be a non-type changing Lens or Iso\n","args":["pr","s","a"],"type":"Base.A_Lens pr s a"},{"name":"A_Lens_","comment":" This MUST be a Lens or Iso\n","args":["pr","s","t","a","b"],"type":"Base.A_Lens_ pr s t a b"},{"name":"A_Prism","comment":" This MUST be a non-type changing Prism or Iso\n","args":["ls","s","a"],"type":"Base.A_Prism ls s a"},{"name":"A_Prism_","comment":" This MUST be a Prism or Iso\n","args":["ls","s","t","a","b"],"type":"Base.A_Prism_ ls s t a b"},{"name":"An_Iso","comment":" This MUST be a Prism or Iso\n","args":["s","a"],"type":"Base.An_Iso s a"},{"name":"An_Iso_","comment":" This MUST be a Prism or Iso\n","args":["s","t","a","b"],"type":"Base.An_Iso_ s t a b"},{"name":"An_Optic","comment":" This MUST be a Prism or Iso\n","args":["pr","ls","s","a"],"type":"Base.An_Optic pr ls s a"},{"name":"An_Optic_","comment":" Any Optic\n","args":["pr","ls","s","t","a","b"],"type":"Base.An_Optic_ pr ls s t a b"},{"name":"Iso","comment":" The isomorphism is both \"lens\" and \"prism\".\n","args":["pr","ls","s","a","x","y"],"type":"Base.Iso pr ls s a x y"},{"name":"Iso_","comment":" The isomorphism is both \"lens\" and \"prism\".\n","args":["pr","ls","s","t","a","b","x","y"],"type":"Base.Iso_ pr ls s t a b x y"},{"name":"Lens","comment":" `Lens` that cannot change type of the object.\n","args":["ls","s","a","x","y"],"type":"Base.Lens ls s a x y"},{"name":"Lens_","comment":" The lens is \"not a prism\".\n","args":["ls","s","t","a","b","x","y"],"type":"Base.Lens_ ls s t a b x y"},{"name":"Optic","comment":" Any Optic is both \"lens\" and \"prism\".\n","args":["pr","ls","s","t","a","b","x","y"],"type":"Base.Optic pr ls s t a b x y"},{"name":"Prism","comment":" `Prism` that cannot change the type of the object.\n","args":["pr","s","a","x","y"],"type":"Base.Prism pr s a x y"},{"name":"Prism_","comment":" The prism is \"not a lens\".\n","args":["pr","s","t","a","b","x","y"],"type":"Base.Prism_ pr s t a b x y"},{"name":"Traversal","comment":" `Traversal` that cannot change the type of the object.\n","args":["s","a","x","y"],"type":"Base.Traversal s a x y"},{"name":"Traversal_","comment":" The traversal is neither \"lens\" or \"prism\".\n","args":["s","t","a","b","x","y"],"type":"Base.Traversal_ s t a b x y"}],"values":[{"name":"all","comment":" Used with a Prism, think of `!!` boolean coercion in Javascript except type safe.\n\n    Just \"Stuff\"\n        |> all just\n    --> [\"Stuff\"]\n\n    Nothing\n        |> all just\n    --> []\n\n","type":"Accessors.An_Optic_ pr ls s t a b -> s -> List.List a"},{"name":"at","comment":" at: Structure Preserving accessor over List members.\nalias for [`List.Accessors.at`](List-Accessors#at)\n","type":"Basics.Int -> Accessors.Traversal (List.List a) a x y"},{"name":"each","comment":" This accessor combinator lets you access values inside List.\nalias for [`List.Accessors.each`](List-Accessors#each)\n","type":"Accessors.Traversal_ (List.List a) (List.List b) a b x y"},{"name":"eachIdx","comment":" This accessor lets you traverse a list including the index of each element\nalias for [`List.Accessors.eachIdx`](List-Accessors#eachIdx)\n","type":"Accessors.Traversal_ (List.List a) (List.List b) ( Basics.Int, a ) b x y"},{"name":"err","comment":" This accessor lets you access values inside the Err variant of a Result.\nalias for [`Result.Accessors.onErr`](Result-Accessors#onErr)\n\n    import Accessors exposing (..)\n    import Lens as L\n\n    maybeRecord : { foo : Result String { bar : Int }, qux : Result String { bar : Int } }\n    maybeRecord = { foo = Ok { bar = 2 }\n                  , qux = Err \"Not an Int\"\n                  }\n\n    try (L.foo << err) maybeRecord\n    --> Nothing\n\n    try (L.qux << err) maybeRecord\n    --> Just \"Not an Int\"\n\n    map (L.foo << err) String.toUpper maybeRecord\n    --> { foo = Ok { bar = 2 }, qux = Err \"Not an Int\" }\n\n    map (L.qux << err) String.toUpper maybeRecord\n    --> { foo = Ok { bar = 2 }, qux = Err \"NOT AN INT\" }\n\n","type":"Accessors.Prism_ pr (Result.Result a ignored) (Result.Result b ignored) a b x y"},{"name":"every","comment":" This accessor combinator lets you access values inside Array.\nalias for [`Array.Accessors.each`](Array-Accessors#each)\n\n    import Accessors exposing (..)\n    import Array exposing (Array)\n    import Lens as L\n\n    arrayRecord : {foo : Array {bar : Int}}\n    arrayRecord =\n        { foo =\n            Array.fromList [{ bar = 2 }, { bar = 3 }, {bar = 4}]\n        }\n\n    all (L.foo << every << L.bar) arrayRecord\n    --> [2, 3, 4]\n\n    map (L.foo << every << L.bar) ((+) 1) arrayRecord\n    --> {foo = Array.fromList [{bar = 3}, {bar = 4}, {bar = 5}]}\n\n","type":"Accessors.Traversal_ (Array.Array a) (Array.Array b) a b x y"},{"name":"everyIdx","comment":" This accessor lets you traverse an Array including the index of each element\nalias for [`Array.Accessors.eachIdx`](Array-Accessors#eachIdx)\n\n    import Accessors exposing (..)\n    import Lens as L\n    import Array exposing (Array)\n\n    arrayRecord : { foo : Array { bar : Int } }\n    arrayRecord = { foo = [ {bar = 2}\n                          , {bar = 3}\n                          , {bar = 4}\n                          ] |> Array.fromList\n                  }\n\n    multiplyIfGTOne : (Int, { bar : Int }) -> { bar : Int }\n    multiplyIfGTOne ( idx, ({ bar } as rec) ) =\n        if idx > 0 then\n            { bar = bar * 10 }\n        else\n            rec\n\n\n    all (L.foo << everyIdx) arrayRecord\n    --> [(0, {bar = 2}), (1, {bar = 3}), (2, {bar = 4})]\n\n    map (L.foo << everyIdx) multiplyIfGTOne arrayRecord\n    --> {foo = [{bar = 2}, {bar = 30}, {bar = 40}] |> Array.fromList}\n\n    all (L.foo << everyIdx << ixd L.bar) arrayRecord\n    --> [2, 3, 4]\n\n    map (L.foo << everyIdx << ixd L.bar) ((+) 1) arrayRecord\n    --> {foo = [{bar = 3}, {bar = 4}, {bar = 5}] |> Array.fromList}\n\n","type":"Accessors.Traversal_ (Array.Array b) (Array.Array c) ( Basics.Int, b ) c x y"},{"name":"from","comment":" Get the inverse of an isomorphism\n","type":"Accessors.An_Iso_ s t a b -> b -> t"},{"name":"fst","comment":" Lens over the first component of a Tuple\nalias for [`Tuple.Accessors.fst`](Tuple-Accessors#fst)\n\n    import Accessors exposing (..)\n\n    charging : (String, Int)\n    charging = (\"It's over\", 1)\n\n    get fst charging\n    --> \"It's over\"\n\n    set fst \"It's over\" charging\n    --> (\"It's over\", 1)\n\n    map fst (\\s -> String.toUpper s ++ \"!!!\") charging\n    --> (\"IT'S OVER!!!\", 1)\n\n","type":"Accessors.Lens_ ls ( a, two ) ( b, two ) a b x y"},{"name":"get","comment":" The get function takes:\n\n  - An accessor,\n  - A datastructure with type `super`\n    and returns the value accessed by that combinator.\n\n```\nget (foo << bar) myRecord\n```\n\n","type":"Accessors.A_Lens_ pr s t a b -> s -> a"},{"name":"has","comment":" Used with a Prism, think of `!!` boolean coercion in Javascript except type safe.\n\n    Just 1234\n        |> has just\n    --> True\n\n    Nothing\n        |> has just\n    --> False\n\n    [ \"Wooo\", \"Things\" ]\n        |> has (at 7)\n    --> False\n\n    [ \"Wooo\", \"Things\" ]\n        |> has (at 0)\n    --> True\n\n","type":"Accessors.An_Optic_ pr ls s t a b -> s -> Basics.Bool"},{"name":"is","comment":" alias for `has`\n","type":"Accessors.An_Optic_ pr ls s t a b -> s -> Basics.Bool"},{"name":"iso","comment":" An isomorphism constructor.\n","type":"String.String -> (s -> a) -> (b -> t) -> Accessors.Iso_ pr ls s t a b x y"},{"name":"ix","comment":" alias for [`Array.Accessors.at`](Array-Accessors#at)\n\n    import Accessors exposing (..)\n    import Array exposing (Array)\n    import Lens as L\n\n    arr : Array { bar : String }\n    arr = Array.fromList [{ bar = \"Stuff\" }, { bar =  \"Things\" }, { bar = \"Woot\" }]\n\n    try (ix 1) arr\n    --> Just { bar = \"Things\" }\n\n    try (ix 9000) arr\n    --> Nothing\n\n    try (ix 0 << L.bar) arr\n    --> Just \"Stuff\"\n\n    set (ix 0 << L.bar) \"Whatever\" arr\n    --> Array.fromList [{ bar = \"Whatever\" }, { bar =  \"Things\" }, { bar = \"Woot\" }]\n\n    set (ix 9000 << L.bar) \"Whatever\" arr\n    --> arr\n\n","type":"Basics.Int -> Accessors.Traversal (Array.Array a) a x y"},{"name":"ixd","comment":" Lift an optic over an indexed traversal\n","type":"Accessors.An_Optic_ pr ls s t a b -> Accessors.Traversal_ ( ix, s ) t a b x y"},{"name":"just","comment":" This accessor combinator lets you access values inside Maybe.\n\n    import Accessors exposing (..)\n    import Lens as L\n\n    maybeRecord : { foo : Maybe { bar : Maybe {stuff : Maybe Int} }, qux : Maybe { bar : Maybe Int } }\n    maybeRecord = { foo = Just { bar = Just { stuff = Just 2 } }\n                  , qux = Nothing\n                  }\n\n    try (L.foo << just << L.bar << just << L.stuff) maybeRecord\n    --> Just (Just 2 )\n\n    try (L.qux << just << L.bar) maybeRecord\n    --> Nothing\n\n    map (L.foo << just << L.bar << just << L.stuff << just) ((+) 1) maybeRecord\n    --> {foo = Just {bar = Just { stuff = Just 3 }}, qux = Nothing}\n\n    map (L.qux << just << L.bar << just) ((+) 1) maybeRecord\n    --> {foo = Just {bar = Just {stuff = Just 2}}, qux = Nothing}\n\n","type":"Accessors.Prism_ pr (Maybe.Maybe a) (Maybe.Maybe b) a b x y"},{"name":"key","comment":" key: NON-structure preserving accessor over Dict's\nalias for [`Dict.Accessors.at`](Dict-Accessors#at)\n\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Dict exposing (Dict)\n    import Accessors exposing (..)\n    import Lens as L\n\n    dict : Dict String {bar : Int}\n    dict = Dict.fromList [(\"foo\", {bar = 2})]\n\n    get (key \"foo\") dict\n    --> Just {bar = 2}\n\n    get (key \"baz\") dict\n    --> Nothing\n\n    try (key \"foo\" << just << L.bar) dict\n    --> Just 2\n\n    set (key \"foo\") Nothing dict\n    --> Dict.remove \"foo\" dict\n\n    set (key \"baz\" << just << L.bar) 3 dict\n    --> dict\n\n","type":"String.String -> Accessors.Lens ls (Dict.Dict String.String a) (Maybe.Maybe a) x y"},{"name":"keyI","comment":" key: NON-structure preserving accessor over Dict's\nalias for [`Dict.Accessors.id`](Dict-Accessors#id)\n\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Dict exposing (Dict)\n    import Accessors exposing (..)\n    import Lens as L\n\n    dict : Dict Int {bar : Int}\n    dict = Dict.fromList [(1, {bar = 2})]\n\n    get (keyI 1) dict\n    --> Just {bar = 2}\n\n    get (keyI 0) dict\n    --> Nothing\n\n    try (keyI 1 << just << L.bar) dict\n    --> Just 2\n\n    set (keyI 1) Nothing dict\n    --> Dict.remove 1 dict\n\n    set (keyI 0 << just << L.bar) 3 dict\n    --> dict\n\n","type":"Basics.Int -> Accessors.Lens ls (Dict.Dict Basics.Int a) (Maybe.Maybe a) x y"},{"name":"key_","comment":" `key_`: NON-structure preserving accessor over Dict's\nalias for [`Dict.Accessors.at_`](Dict-Accessors#at_)\n\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Dict exposing (Dict)\n    import Accessors exposing (..)\n    import Lens as L\n\n    dict : Dict Char {bar : Int}\n    dict = Dict.fromList [('C', {bar = 2})]\n\n    keyC : Char -> Lens ls (Dict Char { bar : Int })  (Maybe { bar : Int }) x y\n    keyC =\n        key_ String.fromChar\n\n    get (keyC 'C') dict\n    --> Just {bar = 2}\n\n    get (keyC 'Z') dict\n    --> Nothing\n\n    try (keyC 'C' << just << L.bar) dict\n    --> Just 2\n\n    set (keyC 'C') Nothing dict\n    --> Dict.remove 'C' dict\n\n    set (keyC 'Z' << just << L.bar) 3 dict\n    --> dict\n\n","type":"(comparable -> String.String) -> comparable -> Accessors.Lens ls (Dict.Dict comparable a) (Maybe.Maybe a) x y"},{"name":"keyed","comment":" keyed: This accessor lets you traverse a Dict including the index of each element\nalias for [`Dict.Accessors.eachIdx`](Dict-Accessors#eachIdx)\n\n    import Accessors exposing (..)\n    import Lens as L\n    import Dict exposing (Dict)\n\n    dictRecord : {foo : Dict String {bar : Int}}\n    dictRecord = { foo = [ (\"a\", { bar = 2 })\n                         , (\"b\", { bar = 3 })\n                         , (\"c\", { bar = 4 })\n                         ] |> Dict.fromList\n                 }\n\n    multiplyIfA : (String, { bar : Int }) -> { bar : Int }\n    multiplyIfA ( key, ({ bar } as rec) ) =\n        if key == \"a\" then\n            { bar = bar * 10 }\n        else\n            rec\n\n\n    all (L.foo << keyed) dictRecord\n    --> [(\"a\", {bar = 2}), (\"b\", {bar = 3}), (\"c\", {bar = 4})]\n\n    map (L.foo << keyed) multiplyIfA dictRecord\n    --> {foo = [(\"a\", {bar = 20}), (\"b\", {bar = 3}), (\"c\", {bar = 4})] |> Dict.fromList}\n\n    all (L.foo << keyed << ixd L.bar) dictRecord\n    --> [2, 3, 4]\n\n    map (L.foo << keyed << ixd L.bar) ((+) 1) dictRecord\n    --> {foo = [(\"a\", {bar = 3}), (\"b\", {bar = 4}), (\"c\", {bar = 5})] |> Dict.fromList}\n\n","type":"Accessors.Traversal_ (Dict.Dict key a) (Dict.Dict key b) ( key, a ) b x y"},{"name":"lens","comment":" This exposes a description field that's necessary for use with the name function\nfor getting unique names out of compositions of accessors. This is useful when you\nwant type safe keys for a Dictionary but you still want to use elm/core implementation.\n\n    foo : Optic attr view over -> Optic { rec | foo : attr } view over\n    foo =\n        makeOneToOne\n            \".foo\"\n            .foo\n            (\\change rec -> { rec | foo = change rec.foo })\n\n","type":"String.String -> (s -> a) -> (s -> b -> t) -> Accessors.Lens_ ls s t a b x y"},{"name":"map","comment":" The map function takes:\n\n  - An accessor,\n  - A function `(sub -> sub)`,\n  - A datastructure with type `super`\n    and it returns the data structure, with the accessible field changed by applying\n    the function to the existing value.\n\n```\nmap (foo << qux) ((+) 1) myRecord\n```\n\n","type":"Accessors.An_Optic_ pr ls s t a b -> (a -> b) -> s -> t"},{"name":"name","comment":" This function gives the name of the function as a string...\n","type":"Accessors.An_Optic_ pr ls s t a b -> String.String"},{"name":"new","comment":" Use prism to reconstruct.\n","type":"Accessors.A_Prism_ ls s t a b -> b -> t"},{"name":"ok","comment":" This accessor lets you access values inside the Ok variant of a Result.\nalias for [`Result.Accessors.onOk`](Result-Accessors#onOk)\n\n    import Accessors exposing (..)\n    import Lens as L\n\n    maybeRecord : { foo : Result String { bar : Int }, qux : Result String { bar : Int } }\n    maybeRecord = { foo = Ok { bar = 2 }\n                  , qux = Err \"Not an Int\"\n                  }\n\n    try (L.foo << ok << L.bar) maybeRecord\n    --> Just 2\n\n    try (L.qux << ok << L.bar) maybeRecord\n    --> Nothing\n\n    map (L.foo << ok << L.bar) ((+) 1) maybeRecord\n    --> { foo = Ok { bar = 3 }, qux = Err \"Not an Int\" }\n\n    map (L.qux << ok << L.bar) ((+) 1) maybeRecord\n    --> { foo = Ok { bar = 2 }, qux = Err \"Not an Int\" }\n\n","type":"Accessors.Prism_ pr (Result.Result ignored a) (Result.Result ignored b) a b x y"},{"name":"over","comment":" alias for `map`\n\n    over (foo << qux) ((+) 1) myRecord\n\n","type":"Accessors.An_Optic_ pr ls s t a b -> (a -> b) -> s -> t"},{"name":"prism","comment":" A prism constructor.\n\nParameters are: reconstructor and a splitter.\n\nReconstructor takes a final value and constructs a final object.\n\nThe splitter turns initial object either to final object directly (if initial object is of wrong variant),\nor spits out `a`.\n\n","type":"String.String -> (b -> t) -> (s -> Result.Result t a) -> Accessors.Prism_ pr s t a b x y"},{"name":"set","comment":" The set function takes:\n\n  - An accessor,\n  - A value of the type `sub`,\n  - A datastructure with type `super`\n    and it returns the data structure, with the accessible field changed to be\n    the set value.\n\n```\nset (foo << bar) \"Hi!\" myRecord\n```\n\n","type":"Accessors.An_Optic_ pr ls s t a b -> b -> s -> t"},{"name":"snd","comment":" alias for [`Tuple.Accessors.snd`](Tuple-Accessors#snd)\n\n    import Accessors exposing (..)\n\n    meh : (String, Int)\n    meh = (\"It's over\", 1)\n\n    get snd meh\n    --> 1\n\n    set snd 1125 meh\n    --> (\"It's over\", 1125)\n\n    meh\n        |> set snd 1125\n        |> map fst (\\s -> String.toUpper s ++ \"!!!\")\n        |> map snd ((*) 8)\n    --> (\"IT'S OVER!!!\", 9000)\n\n","type":"Accessors.Lens_ ls ( one, a ) ( one, b ) a b x y"},{"name":"to","comment":" Alias of `get` for isomorphisms\n","type":"Accessors.An_Iso_ s t a b -> s -> a"},{"name":"traversal","comment":" This exposes a description field that's necessary for use with the name function\nfor getting unique names out of compositions of accessors. This is useful when you\nwant type safe keys for a Dictionary but you still want to use elm/core implementation.\n\n    each : Optic pr ls a b x y -> Traversal (List a) (List b) x y\n    each =\n        Base.traversal \"[]\"\n            identity\n            List.map\n\n","type":"String.String -> (s -> List.List a) -> ((a -> b) -> s -> t) -> Accessors.Traversal_ s t a b x y"},{"name":"try","comment":" Used with a Prism, think of `!!` boolean coercion in Javascript except type safe.\n\n    [\"Stuff\", \"things\"]\n        |> try (at 2)\n    --> Nothing\n\n    [\"Stuff\", \"things\"]\n        |> try (at 0)\n    --> Just \"Stuff\"\n\n","type":"Accessors.An_Optic_ pr ls s t a b -> s -> Maybe.Maybe a"},{"name":"values","comment":" values: This accessor lets you traverse a Dict including the index of each element\nalias for [`Dict.Accessors.each`](Dict-Accessors#each)\n\n    import Accessors exposing (..)\n    import Lens as L\n    import Dict exposing (Dict)\n\n    dictRecord : {foo : Dict String {bar : Int}}\n    dictRecord = { foo = [ (\"a\", { bar = 2 })\n                         , (\"b\", { bar = 3 })\n                         , (\"c\", { bar = 4 })\n                         ] |> Dict.fromList\n                 }\n\n    all (L.foo << values) dictRecord\n    --> [{bar = 2}, {bar = 3}, {bar = 4}]\n\n    map (L.foo << values << L.bar) ((*) 10) dictRecord\n    --> {foo = [(\"a\", {bar = 20}), (\"b\", {bar = 30}), (\"c\", {bar = 40})] |> Dict.fromList}\n\n    all (L.foo << values << L.bar) dictRecord\n    --> [2, 3, 4]\n\n    map (L.foo << values << L.bar) ((+) 1) dictRecord\n    --> {foo = [(\"a\", {bar = 3}), (\"b\", {bar = 4}), (\"c\", {bar = 5})] |> Dict.fromList}\n\n","type":"Accessors.Traversal_ (Dict.Dict key a) (Dict.Dict key b) a b x y"}],"binops":[]},{"name":"Array.Accessors","comment":" Array.Accessors\n\n@docs each, eachIdx, at, id\n\n","unions":[],"aliases":[],"values":[{"name":"at","comment":" This accessor combinator lets you access Array indices.\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Accessors exposing (..)\n    import Array exposing (Array)\n    import Array.Accessors as Array\n    import Lens as L\n\n    arr : Array { bar : String }\n    arr = Array.fromList [{ bar = \"Stuff\" }, { bar = \"Things\" }, { bar = \"Woot\" }]\n\n    try (Array.at 1) arr\n    --> Just { bar = \"Things\" }\n\n    try (Array.at 9000) arr\n    --> Nothing\n\n    try (Array.at 0 << L.bar) arr\n    --> Just \"Stuff\"\n\n    set (Array.at 0 << L.bar) \"Whatever\" arr\n    --> Array.fromList [{ bar = \"Whatever\" }, { bar = \"Things\" }, { bar = \"Woot\" }]\n\n    set (Array.at 9000 << L.bar) \"Whatever\" arr\n    --> arr\n\n","type":"Basics.Int -> Base.Traversal (Array.Array a) a x y"},{"name":"each","comment":" This accessor combinator lets you access values inside Array.\n\n    import Accessors exposing (..)\n    import Array exposing (Array)\n    import Array.Accessors as Array\n    import Lens as L\n\n    arrayRecord : {foo : Array {bar : Int}}\n    arrayRecord =\n        { foo =\n            Array.fromList [{ bar = 2 }, { bar = 3 }, {bar = 4}]\n        }\n\n    all (L.foo << Array.each << L.bar) arrayRecord\n    --> [2, 3, 4]\n\n    map (L.foo << Array.each << L.bar) ((+) 1) arrayRecord\n    --> {foo = Array.fromList [{bar = 3}, {bar = 4}, {bar = 5}]}\n\n","type":"Base.Traversal_ (Array.Array a) (Array.Array b) a b x y"},{"name":"eachIdx","comment":" This accessor lets you traverse a list including the index of each element\n\n    import Accessors exposing (..)\n    import Array exposing (Array)\n    import Array.Accessors as Array\n    import Lens as L\n\n    arrayRecord : { foo : Array { bar : Int } }\n    arrayRecord = { foo = [ {bar = 2}\n                          , {bar = 3}\n                          , {bar = 4}\n                          ] |> Array.fromList\n                  }\n\n    multiplyIfGTOne : (Int, { bar : Int }) -> { bar : Int }\n    multiplyIfGTOne ( idx, ({ bar } as rec) ) =\n        if idx > 0 then\n            { bar = bar * 10 }\n        else\n            rec\n\n    all (L.foo << Array.eachIdx) arrayRecord\n    --> [(0, {bar = 2}), (1, {bar = 3}), (2, {bar = 4})]\n\n    map (L.foo << Array.eachIdx) multiplyIfGTOne arrayRecord\n    --> {foo = [{bar = 2}, {bar = 30}, {bar = 40}] |> Array.fromList}\n\n    all (L.foo << Array.eachIdx << ixd L.bar) arrayRecord\n    --> [2, 3, 4]\n\n    map (L.foo << Array.eachIdx << ixd L.bar) ((+) 1) arrayRecord\n    --> {foo = [{bar = 3}, {bar = 4}, {bar = 5}] |> Array.fromList}\n\n","type":"Base.Traversal_ (Array.Array b) (Array.Array c) ( Basics.Int, b ) c x y"},{"name":"id","comment":" This accessor combinator lets you access a record with a particular id in an Array.\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Accessors exposing (..)\n    import Array exposing (Array)\n    import Array.Accessors as Array\n    import Lens as L\n\n    arr : Array { id : Int, bar : String }\n    arr = Array.fromList [{ id = 7, bar = \"Stuff\" }, { id = 1, bar = \"Things\" }, { id = 5, bar = \"Woot\" }]\n\n    try (Array.id 1) arr\n    --> Just { id = 1, bar = \"Things\" }\n\n    try (Array.id 9000) arr\n    --> Nothing\n\n    try (Array.id 7 << L.bar) arr\n    --> Just \"Stuff\"\n\n    set (Array.id 7 << L.bar) \"Whatever\" arr\n    --> Array.fromList [{ id = 7, bar = \"Whatever\" }, { id = 1, bar = \"Things\" }, { id = 5, bar = \"Woot\" }]\n\n    set (Array.id 9000 << L.bar) \"Whatever\" arr\n    --> arr\n\n","type":"Basics.Int -> Base.Traversal (Array.Array { m | id : Basics.Int }) { m | id : Basics.Int } x y"}],"binops":[]},{"name":"Dict.Accessors","comment":" Dict.Accessors\n\n@docs each, eachIdx, at, id, at_\n\n","unions":[],"aliases":[],"values":[{"name":"at","comment":" at: NON-structure preserving accessor over Dict's\n\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Accessors exposing (..)\n    import Dict exposing (Dict)\n    import Dict.Accessors as Dict\n    import Lens as L\n\n    dict : Dict String {bar : Int}\n    dict = Dict.fromList [(\"foo\", {bar = 2})]\n\n    get (Dict.at \"foo\") dict\n    --> Just {bar = 2}\n\n    get (Dict.at \"baz\") dict\n    --> Nothing\n\n    try (Dict.at \"foo\" << just << L.bar) dict\n    --> Just 2\n\n    set (Dict.at \"foo\") Nothing dict\n    --> Dict.remove \"foo\" dict\n\n    set (Dict.at \"baz\" << just << L.bar) 3 dict\n    --> dict\n\n","type":"String.String -> Base.Lens ls (Dict.Dict String.String a) (Maybe.Maybe a) x y"},{"name":"at_","comment":" `at_`: NON-structure preserving accessor over Dict's\n\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Accessors exposing (..)\n    import Dict exposing (Dict)\n    import Dict.Accessors as Dict\n    import Lens as L\n\n    dict : Dict Char {bar : Int}\n    dict = Dict.fromList [('C', {bar = 2})]\n\n    atC : Char -> Lens ls (Dict Char {bar : Int})  (Maybe {bar : Int}) x y\n    atC =\n        Dict.at_ String.fromChar\n\n    get (atC 'C') dict\n    --> Just {bar = 2}\n\n    get (atC 'Z') dict\n    --> Nothing\n\n    try (atC 'C' << just << L.bar) dict\n    --> Just 2\n\n    set (atC 'C') Nothing dict\n    --> Dict.remove 'C' dict\n\n    set (atC 'Z' << just << L.bar) 3 dict\n    --> dict\n\n","type":"(comparable -> String.String) -> comparable -> Base.Lens ls (Dict.Dict comparable a) (Maybe.Maybe a) x y"},{"name":"each","comment":" each: This accessor lets you traverse a Dict including the index of each element\n\n    import Accessors exposing (..)\n    import Dict exposing (Dict)\n    import Dict.Accessors as Dict\n    import Lens as L\n\n    dictRecord : { foo : Dict String { bar : Int } }\n    dictRecord = { foo = [ (\"a\", { bar = 2 })\n                         , (\"b\", { bar = 3 })\n                         , (\"c\", { bar = 4 })\n                         ] |> Dict.fromList\n                 }\n\n    all (L.foo << Dict.each) dictRecord\n    --> [{bar = 2}, {bar = 3}, {bar = 4}]\n\n    map (L.foo << Dict.each << L.bar) ((*) 10) dictRecord\n    --> {foo = [(\"a\", {bar = 20}), (\"b\", {bar = 30}), (\"c\", {bar = 40})] |> Dict.fromList}\n\n    all (L.foo << Dict.each << L.bar) dictRecord\n    --> [2, 3, 4]\n\n    map (L.foo << Dict.each << L.bar) ((+) 1) dictRecord\n    --> {foo = [(\"a\", {bar = 3}), (\"b\", {bar = 4}), (\"c\", {bar = 5})] |> Dict.fromList}\n\n","type":"Base.Traversal_ (Dict.Dict key a) (Dict.Dict key b) a b x y"},{"name":"eachIdx","comment":" keyed: This accessor lets you traverse a Dict including the index of each element\n\n    import Accessors exposing (..)\n    import Dict exposing (Dict)\n    import Dict.Accessors as Dict\n    import Lens as L\n\n    dictRecord : {foo : Dict String {bar : Int}}\n    dictRecord = { foo = [ (\"a\", { bar = 2 })\n                         , (\"b\", { bar = 3 })\n                         , (\"c\", { bar = 4 })\n                         ] |> Dict.fromList\n                 }\n\n    multiplyIfA : (String, { bar : Int }) -> { bar : Int }\n    multiplyIfA ( key, ({ bar } as rec) ) =\n        if key == \"a\" then\n            { bar = bar * 10 }\n        else\n            rec\n\n\n    all (L.foo << Dict.eachIdx) dictRecord\n    --> [(\"a\", {bar = 2}), (\"b\", {bar = 3}), (\"c\", {bar = 4})]\n\n    map (L.foo << Dict.eachIdx) multiplyIfA dictRecord\n    --> {foo = [(\"a\", {bar = 20}), (\"b\", {bar = 3}), (\"c\", {bar = 4})] |> Dict.fromList}\n\n    all (L.foo << Dict.eachIdx << ixd L.bar) dictRecord\n    --> [2, 3, 4]\n\n    map (L.foo << Dict.eachIdx << ixd L.bar) ((+) 1) dictRecord\n    --> {foo = [(\"a\", {bar = 3}), (\"b\", {bar = 4}), (\"c\", {bar = 5})] |> Dict.fromList}\n\n","type":"Base.Traversal_ (Dict.Dict key a) (Dict.Dict key b) ( key, a ) b x y"},{"name":"id","comment":" id: NON-structure preserving accessor over Dict's\n\nIn terms of accessors, think of Dicts as records where each field is a Maybe.\n\n    import Accessors exposing (..)\n    import Dict exposing (Dict)\n    import Dict.Accessors as Dict\n    import Lens as L\n\n    dict : Dict Int {bar : Int}\n    dict = Dict.fromList [(1, {bar = 2})]\n\n    get (Dict.id 1) dict\n    --> Just {bar = 2}\n\n    get (Dict.id 0) dict\n    --> Nothing\n\n    try (Dict.id 1 << just << L.bar) dict\n    --> Just 2\n\n    set (Dict.id 1) Nothing dict\n    --> Dict.remove 1 dict\n\n    set (Dict.id 0 << just << L.bar) 3 dict\n    --> dict\n\n","type":"Basics.Int -> Base.Lens ls (Dict.Dict Basics.Int a) (Maybe.Maybe a) x y"}],"binops":[]},{"name":"List.Accessors","comment":" List.Accessors\n\n@docs each, eachIdx, at, id\n\n","unions":[],"aliases":[],"values":[{"name":"at","comment":" at: Structure Preserving accessor over List members.\n\n    import Accessors exposing (..)\n    import List.Accessors as List\n    import Lens as L\n\n    list : List { bar : String }\n    list = [{ bar = \"Stuff\" }, { bar =  \"Things\" }, { bar = \"Woot\" }]\n\n    try (List.at 1) list\n    --> Just { bar = \"Things\" }\n\n    try (List.at 9000) list\n    --> Nothing\n\n    try (List.at 0 << L.bar) list\n    --> Just \"Stuff\"\n\n    set (List.at 0 << L.bar) \"Whatever\" list\n    --> [{ bar = \"Whatever\" }, { bar =  \"Things\" }, { bar = \"Woot\" }]\n\n    set (List.at 9000 << L.bar) \"Whatever\" list\n    --> list\n\n","type":"Basics.Int -> Base.Traversal (List.List a) a x y"},{"name":"each","comment":" This accessor combinator lets you access values inside List.\n\n    import Accessors exposing (..)\n    import List.Accessors as List\n    import Lens as L\n\n    listRecord : { foo : List { bar : Int } }\n    listRecord = { foo = [ {bar = 2}\n                         , {bar = 3}\n                         , {bar = 4}\n                         ]\n                 }\n\n    all (L.foo << List.each << L.bar) listRecord\n    --> [2, 3, 4]\n\n    map (L.foo << List.each << L.bar) ((+) 1) listRecord\n    --> {foo = [{bar = 3}, {bar = 4}, {bar = 5}]}\n\n","type":"Base.Traversal_ (List.List a) (List.List b) a b x y"},{"name":"eachIdx","comment":" This accessor lets you traverse a list including the index of each element\n\n    import Accessors exposing (..)\n    import List.Accessors as List\n    import Lens as L\n\n    listRecord : {foo : List {bar : Int}}\n    listRecord = { foo = [ {bar = 2}\n                         , {bar = 3}\n                         , {bar = 4}\n                         ]\n                 }\n\n    multiplyIfGTOne : (Int, { bar : Int }) -> { bar : Int }\n    multiplyIfGTOne ( idx, ({ bar } as rec) ) =\n        if idx > 0 then\n             { bar = bar * 10 }\n        else\n            rec\n\n    all (L.foo << List.eachIdx) listRecord\n    --> [(0, {bar = 2}), (1, {bar = 3}), (2, {bar = 4})]\n\n    map (L.foo << List.eachIdx) multiplyIfGTOne listRecord\n    --> {foo = [{bar = 2}, {bar = 30}, {bar = 40}]}\n\n    all (L.foo << List.eachIdx << ixd L.bar) listRecord\n    --> [2, 3, 4]\n\n    map (L.foo << List.eachIdx << ixd L.bar) ((+) 1) listRecord\n    --> {foo = [{bar = 3}, {bar = 4}, {bar = 5}]}\n\n","type":"Base.Traversal_ (List.List a) (List.List b) ( Basics.Int, a ) b x y"},{"name":"id","comment":" id: Structure Preserving accessor over List members.\n\n    import Accessors exposing (..)\n    import List.Accessors as List\n    import Lens as L\n\n    list : List { id : Int, bar : String }\n    list = [{ id = 7, bar = \"Stuff\" }, { id = 1, bar =  \"Things\" }, { id = 5, bar = \"Woot\" }]\n\n    try (List.id 1) list\n    --> Just { id = 1, bar = \"Things\" }\n\n    try (List.id 0) list\n    --> Nothing\n\n    try (List.id 7 << L.bar) list\n    --> Just \"Stuff\"\n\n    set (List.id 7 << L.bar) \"Whatever\" list\n    --> [{ id = 7, bar = \"Whatever\" }, { id = 1, bar =  \"Things\" }, { id = 5, bar = \"Woot\" }]\n\n    set (List.id 9000 << L.bar) \"Whatever\" list\n    --> list\n\n","type":"Basics.Int -> Base.Traversal (List.List { a | id : Basics.Int }) { a | id : Basics.Int } x y"}],"binops":[]},{"name":"Maybe.Accessors","comment":"\n\n@docs just\n\n","unions":[],"aliases":[],"values":[{"name":"just","comment":" This accessor combinator lets you access values inside Maybe.\nsee [`try_`](Maybe-Accessors#try_) for a flattening lens.\n\n    import Base exposing (try, map)\n    import Dict exposing (Dict)\n    import Dict.Accessors as Dict\n    import Maybe.Accessors as Maybe\n    import Lens as L\n\n    maybeRecord : { foo : Maybe { bar : Maybe {stuff : Maybe Int} }, qux : Maybe { bar : Maybe Int } }\n    maybeRecord = { foo = Just { bar = Just { stuff = Just 2 } }\n                  , qux = Nothing\n                  }\n\n    try (L.foo << Maybe.just << L.bar << Maybe.just << L.stuff) maybeRecord\n    --> Just (Just 2)\n\n    try (L.qux << Maybe.just << L.bar) maybeRecord\n    --> Nothing\n\n    map (L.foo << Maybe.just << L.bar << Maybe.just << L.stuff << Maybe.just) ((+) 1) maybeRecord\n    --> {foo = Just {bar = Just { stuff = Just 3 }}, qux = Nothing}\n\n    map (L.qux << Maybe.just << L.bar << Maybe.just) ((+) 1) maybeRecord\n    --> {foo = Just {bar = Just {stuff = Just 2}}, qux = Nothing}\n\n","type":"Base.Prism_ pr (Maybe.Maybe a) (Maybe.Maybe b) a b x y"}],"binops":[]},{"name":"Result.Accessors","comment":"\n\n@docs ok, err\n\n","unions":[],"aliases":[],"values":[{"name":"err","comment":" This accessor lets you access values inside the Err variant of a Result.\n\n    import Accessors exposing (..)\n    import Result.Accessors as Result\n    import Lens as L\n\n    maybeRecord : { foo : Result String { bar : Int }, qux : Result String { bar : Int } }\n    maybeRecord = { foo = Ok { bar = 2 }\n                  , qux = Err \"Not an Int\"\n                  }\n\n    try (L.foo << Result.err) maybeRecord\n    --> Nothing\n\n    try (L.qux << Result.err) maybeRecord\n    --> Just \"Not an Int\"\n\n    map (L.foo << Result.err) String.toUpper maybeRecord\n    --> { foo = Ok { bar = 2 }, qux = Err \"Not an Int\" }\n\n    map (L.qux << Result.err) String.toUpper maybeRecord\n    --> { foo = Ok { bar = 2 }, qux = Err \"NOT AN INT\" }\n\n","type":"Base.Prism_ pr (Result.Result a ignored) (Result.Result b ignored) a b x y"},{"name":"ok","comment":" This accessor lets you access values inside the Ok variant of a Result.\n\n    import Accessors exposing (..)\n    import Result.Accessors as Result\n    import Lens as L\n\n    maybeRecord : { foo : Result String { bar : Int }, qux : Result String { bar : Int } }\n    maybeRecord = { foo = Ok { bar = 2 }\n                  , qux = Err \"Not an Int\"\n                  }\n\n    try (L.foo << Result.ok << L.bar) maybeRecord\n    --> Just 2\n\n    try (L.qux << Result.ok << L.bar) maybeRecord\n    --> Nothing\n\n    map (L.foo << Result.ok << L.bar) ((+) 1) maybeRecord\n    --> { foo = Ok { bar = 3 }, qux = Err \"Not an Int\" }\n\n    map (L.qux << Result.ok << L.bar) ((+) 1) maybeRecord\n    --> { foo = Ok { bar = 2 }, qux = Err \"Not an Int\" }\n\n","type":"Base.Prism_ pr (Result.Result ignored a) (Result.Result ignored b) a b x y"}],"binops":[]},{"name":"SelectList.Accessors","comment":" This module exposes some helpers for \"miyamoen/select-list\"\n\n@docs each, eachIdx, selected\n\n","unions":[],"aliases":[],"values":[{"name":"each","comment":" This accessor combinator lets you access values inside List.\n\n    import Accessors exposing (..)\n    import SelectList.Accessors as SL\n    import Lens as L\n    import SelectList exposing (SelectList)\n\n    listRecord : { foo : SelectList { bar : Int } }\n    listRecord =\n        { foo = SelectList.fromLists [{ bar = 1 }] { bar = 2 } [{ bar = 3 }, { bar = 4 }]\n        }\n\n    all (L.foo << SL.each << L.bar) listRecord\n    --> [1, 2, 3, 4]\n\n    map (L.foo << SL.each << L.bar) ((+) 1) listRecord\n    --> { foo = SelectList.fromLists [{ bar = 2 }] { bar = 3 } [{ bar = 4 }, { bar = 5 }] }\n\n","type":"Base.Traversal_ (SelectList.SelectList a) (SelectList.SelectList b) a b x y"},{"name":"eachIdx","comment":" This accessor lets you traverse a list including the index of each element\n\n    import Accessors exposing (..)\n    import SelectList.Accessors as SL\n    import Lens as L\n    import SelectList exposing (SelectList)\n\n    listRecord : { foo : SelectList { bar : Int } }\n    listRecord =\n        { foo = SelectList.fromLists [{ bar = 1 }] { bar = 2 } [{ bar = 3 }, { bar = 4 }]\n        }\n\n    multiplyIfGTOne : (Int, { bar : Int }) -> { bar : Int }\n    multiplyIfGTOne ( idx, ({ bar } as rec) ) =\n        if idx > 0 then\n            { bar = bar * 10 }\n        else\n            rec\n\n\n    all (L.foo << SL.eachIdx) listRecord\n    --> [(0, {bar = 1}), (1, {bar = 2}), (2, {bar = 3}), (3, {bar = 4})]\n\n    map (L.foo << SL.eachIdx) multiplyIfGTOne listRecord\n    --> { foo = SelectList.fromLists [{ bar = 1 }] { bar = 20 } [{ bar = 30 }, { bar = 40 }] }\n\n    all (L.foo << SL.eachIdx << ixd L.bar) listRecord\n    --> [1, 2, 3, 4]\n\n    map (L.foo << SL.eachIdx << ixd L.bar) ((+) 1) listRecord\n    --> {foo = SelectList.fromLists [{bar = 2}] {bar = 3} [{bar = 4}, {bar = 5}]}\n\n","type":"Base.Traversal_ (SelectList.SelectList a) (SelectList.SelectList b) ( Basics.Int, a ) b x y"},{"name":"selected","comment":" This accessor lets you traverse a list including the index of each element\n\n    import Accessors exposing (..)\n    import SelectList.Accessors as SL\n    import Lens as L\n    import SelectList exposing (SelectList)\n\n    listRecord : { foo : SelectList { bar : Int } }\n    listRecord =\n        { foo = SelectList.fromLists [{ bar = 1 }] { bar = 2 } [{ bar = 3 }, { bar = 4 }]\n        }\n\n    multiplyIfGTOne : (Int, { bar : Int }) -> (Int, { bar : Int })\n    multiplyIfGTOne ( idx, ({ bar } as rec) ) =\n        if idx > 0 then\n            ( idx, { bar = bar * 10 } )\n        else\n            (idx, rec)\n\n    get (L.foo << SL.selected << L.bar) listRecord\n    --> 2\n\n    set (L.foo << SL.selected << L.bar) 37 listRecord\n    --> { foo = SelectList.fromLists [{ bar = 1 }] { bar = 37 } [{ bar = 3 }, { bar = 4 }] }\n\n    map (L.foo << SL.selected << L.bar) ((*) 10) listRecord\n    --> { foo = SelectList.fromLists [{ bar = 1 }] { bar = 20 } [{ bar = 3 }, { bar = 4 }] }\n\n","type":"Base.Lens ls (SelectList.SelectList a) a x y"}],"binops":[]},{"name":"Tree.Accessors","comment":" List.Accessors\n\n@docs at, label_, path, at_, id\n@docs each\n\n","unions":[],"aliases":[],"values":[{"name":"at","comment":" This accessor combinator lets you access the label at a particular TreePath.\n\n    import Accessors exposing (..)\n    import Tree exposing (Tree, tree)\n    import Tree.Accessors as Tree\n    import Tree.Extra.Lue exposing (leaf)\n    import Lens as L\n\n    simpleTree : Tree String\n    simpleTree =\n        tree \"root\"\n            [ tree \"a\" [ leaf \"b\"]\n            , tree \"x\" [ leaf \"y\"]\n            ]\n\n    try (Tree.at [0]) simpleTree\n    --> Just \"a\"\n\n    map (Tree.at [0]) String.toUpper simpleTree\n    --> tree \"root\" [ tree \"A\" [ leaf \"b\" ] , tree \"x\" [ leaf \"y\" ] ]\n\n","type":"TreePath.TreePath -> Base.Traversal (Tree.Tree a) a x y"},{"name":"at_","comment":" ","type":"(a -> String.String) -> a -> Base.Traversal (Tree.Tree { z | id : a }) (Tree.Tree { z | id : a }) x y"},{"name":"each","comment":" This accessor combinator lets you modify the type of each label of a Tree.\n\n    import Accessors exposing (..)\n    import Tree exposing (Tree, tree)\n    import Tree.Accessors as Tree\n    import Tree.Extra.Lue exposing (leaf)\n    import Lens as L\n\n    simpleTree : Tree String\n    simpleTree =\n        tree \"r\"\n            [ tree \"a\" [ leaf \"b\"]\n            , tree \"x\" [ leaf \"y\"]\n            ]\n\n    all Tree.each simpleTree\n    --> [\"r\", \"a\", \"b\", \"x\", \"y\"]\n\n    set Tree.each \"1\" simpleTree\n    --> tree \"1\" [ tree \"1\" [ leaf \"1\" ] , tree \"1\" [ leaf \"1\" ] ]\n\n    map Tree.each (\\s -> \"gimme an \" ++ String.toUpper s ++ \"!\") simpleTree\n    --> tree \"gimme an R!\" [ tree \"gimme an A!\" [ leaf \"gimme an B!\" ] , tree \"gimme an X!\" [ leaf \"gimme an Y!\" ] ]\n\n","type":"Base.Traversal_ (Tree.Tree a) (Tree.Tree b) a b x y"},{"name":"id","comment":" ","type":"String.String -> Base.Traversal (Tree.Tree { z | id : String.String }) (Tree.Tree { z | id : String.String }) x y"},{"name":"label_","comment":" This accessor combinator lets you access the label of a given Tree.\n\n    import Accessors exposing (..)\n    import Tree exposing (Tree, tree)\n    import Tree.Accessors as Tree\n    import Tree.Extra.Lue exposing (leaf)\n    import Lens as L\n\n    simpleTree : Tree String\n    simpleTree =\n        tree \"root\"\n            [ tree \"a\" [ leaf \"b\"]\n            , tree \"x\" [ leaf \"y\"]\n            ]\n\n    get (Tree.label_) simpleTree\n    --> \"root\"\n\n    set (Tree.label_) \"top 'o the mornin' to yah!\" simpleTree\n    --> tree \"top 'o the mornin' to yah!\" [ tree \"a\" [ leaf \"b\" ] , tree \"x\" [ leaf \"y\" ] ]\n\n    map (Tree.label_) String.toUpper simpleTree\n    --> tree \"ROOT\" [ tree \"a\" [ leaf \"b\" ] , tree \"x\" [ leaf \"y\" ] ]\n\n","type":"Base.Lens ls (Tree.Tree a) a x y"},{"name":"path","comment":" This accessor combinator lets you access a sub-tree at a given TreePath.\n\n    import Accessors exposing (..)\n    import Tree exposing (Tree, tree)\n    import Tree.Accessors as Tree\n    import Tree.Extra.Lue exposing (leaf)\n    import Lens as L\n\n    simpleTree : Tree String\n    simpleTree =\n        tree \"root\"\n            [ tree \"a\" [ leaf \"b\"]\n            , tree \"x\" [ leaf \"y\"]\n            ]\n\n    try (Tree.path [0,0]) simpleTree\n    --> Just (leaf \"b\")\n\n    set (Tree.path [1,0]) (tree \"hey!\" [leaf \"deeper\"]) simpleTree\n    --> tree \"root\" [ tree \"a\" [ leaf \"b\" ] , tree \"x\" [ tree \"hey!\" [leaf \"deeper\"] ] ]\n\n    map (Tree.path [0]) (Tree.mapLabel (\\s -> \"gimme an \" ++ String.toUpper s ++ \"!\")) simpleTree\n    --> tree \"root\" [ tree \"gimme an A!\" [ leaf \"b\" ] , tree \"x\" [ leaf \"y\" ] ]\n\n","type":"TreePath.TreePath -> Base.Traversal (Tree.Tree a) (Tree.Tree a) x y"}],"binops":[]},{"name":"Tuple.Accessors","comment":"\n\n@docs fst, snd\n\n","unions":[],"aliases":[],"values":[{"name":"fst","comment":" Lens over the first component of a Tuple\n\n    import Base exposing (get, set, map)\n    import Tuple.Accessors as Tuple\n\n    charging : (String, Int)\n    charging = (\"It's over\", 1)\n\n    get Tuple.fst charging\n    --> \"It's over\"\n\n    set Tuple.fst \"It's over\" charging\n    --> (\"It's over\", 1)\n\n    map Tuple.fst (\\s -> String.toUpper s ++ \"!!!\") charging\n    --> (\"IT'S OVER!!!\", 1)\n\n","type":"Base.Lens_ ls ( a, two ) ( b, two ) a b x y"},{"name":"snd","comment":"\n\n    import Base exposing (get, set, map)\n    import Tuple.Accessors as Tuple\n\n    meh : (String, Int)\n    meh = (\"It's over\", 1)\n\n    get Tuple.snd meh\n    --> 1\n\n    set Tuple.snd 1125 meh\n    --> (\"It's over\", 1125)\n\n    meh\n        |> set Tuple.snd 1125\n        |> map Tuple.fst (\\s -> String.toUpper s ++ \"!!!\")\n        |> map Tuple.snd ((*) 8)\n    --> (\"IT'S OVER!!!\", 9000)\n\n","type":"Base.Lens_ ls ( one, a ) ( one, b ) a b x y"}],"binops":[]}]