[{"name":"AUF","comment":" Types and helpers to deal with Adjust U Face (AUF), which\nare the moves needed either to adjust the U face to the right\nangle for executing your algorithms for several algorithm sets\nsuch as OLL and PLL, or the last move needed to solve the cube\nfor example after PLL. See\n<https://www.speedsolving.com/wiki/index.php/AUF>\nfor more information\n\n\n# Definition and Constructors\n\n@docs AUF, all\n\n\n# Helpers\n\n@docs toAlgorithm, toString, fromString\n\n","unions":[{"name":"AUF","comment":" The 4 different AUFs. U, U', U2, and nothing.\nUse these value constructors together with [@all](#all)\nwhen you need to construct in different ways.\n","args":[],"cases":[["None",[]],["Clockwise",[]],["Halfway",[]],["CounterClockwise",[]]]}],"aliases":[],"values":[{"name":"all","comment":" A nonempty list containing all the possible aufs.\nCould for example be used to generate a random auf or\ngenerate all the possible versions of an algorithm\n\n    import List.Nonempty\n\n    -- They are all there!\n    List.Nonempty.length all --> 4\n\n    -- Generate a random one\n    List.Nonempty.sample all\n\n    import PLL\n\n    -- Get all versions of a Y perm\n    all\n        |> List.Nonempty.map (Tuple.pair PLL.Y)\n        |> List.Nonempty.map (\\(pll, postAuf) ->\n            List.Nonempty.map\n                (\\preAuf -> (preAuf, pll, postAuf))\n                all\n        )\n\n","type":"List.Nonempty.Nonempty AUF.AUF"},{"name":"fromString","comment":" Attempts to parse an algorithmic representation of an AUF\n\n    fromString \"U'\" --> Ok CounterClockwise\n\n    fromString \"\" --> Ok None\n\n    fromString \"U B\"\n    --> Err\n    -->     (\"An AUF must be no move or \"\n    -->         ++ \"a single turn of the U layer\"\n    -->     )\n\n","type":"String.String -> Result.Result String.String AUF.AUF"},{"name":"toAlgorithm","comment":" Get the algorithm that corresponds to the AUF\n\n    import Algorithm\n\n    toAlgorithm Halfway\n    -->  Algorithm.build\n    -->    [ Algorithm.Turn\n    -->        Algorithm.U\n    -->        Algorithm.Halfway\n    -->        Algorithm.Clockwise\n    -->    ]\n\n","type":"AUF.AUF -> Algorithm.Algorithm"},{"name":"toString","comment":" Get an algorithm string representation of the AUF\n\n    toString Halfway --> \"U2\"\n\n","type":"AUF.AUF -> String.String"}],"binops":[]},{"name":"Algorithm","comment":" Documentation to come\n\n@docs Algorithm, Turn, TurnDirection, TurnLength, Turnable, allTurnDirections, allTurnLengths, allTurnables, allTurns, append, appendTo, build, empty, toTurnList, fromString, inverse, toString\n\n","unions":[{"name":"Algorithm","comment":" Placeholder\n","args":[],"cases":[]},{"name":"Turn","comment":" Placeholder\n","args":[],"cases":[["Turn",["Algorithm.Turnable","Algorithm.TurnLength","Algorithm.TurnDirection"]]]},{"name":"TurnDirection","comment":" Placeholder\n","args":[],"cases":[["Clockwise",[]],["CounterClockwise",[]]]},{"name":"TurnLength","comment":" Placeholder\n","args":[],"cases":[["OneQuarter",[]],["Halfway",[]],["ThreeQuarters",[]]]},{"name":"Turnable","comment":" Placeholder\n","args":[],"cases":[["U",[]],["D",[]],["L",[]],["R",[]],["F",[]],["B",[]],["M",[]],["S",[]],["E",[]],["X",[]],["Y",[]],["Z",[]]]}],"aliases":[],"values":[{"name":"allTurnDirections","comment":" All possible turn directions\n\n    List.length allTurnDirections --> 2\n\n","type":"List.List Algorithm.TurnDirection"},{"name":"allTurnLengths","comment":" All possible turn lengths\n\n    List.length allTurnLengths --> 3\n\n","type":"List.List Algorithm.TurnLength"},{"name":"allTurnables","comment":" All possible turnables\n\n    List.length allTurnables --> 12\n\n","type":"List.List Algorithm.Turnable"},{"name":"allTurns","comment":" All possible combinations of turnables, lengths and directions\n\n    List.length allTurns\n    --> List.length allTurnables * List.length allTurnLengths * List.length allTurnDirections\n\n","type":"List.List Algorithm.Turn"},{"name":"append","comment":" We append the first argument, so b ++ a\n","type":"Algorithm.Algorithm -> Algorithm.Algorithm -> Algorithm.Algorithm"},{"name":"appendTo","comment":" We append to the first argument, so a ++ b\n","type":"Algorithm.Algorithm -> Algorithm.Algorithm -> Algorithm.Algorithm"},{"name":"build","comment":" Placeholder\n","type":"List.List Algorithm.Turn -> Algorithm.Algorithm"},{"name":"empty","comment":" Placeholder\n","type":"Algorithm.Algorithm"},{"name":"fromString","comment":" Placeholder\n","type":"String.String -> Result.Result String.String Algorithm.Algorithm"},{"name":"inverse","comment":" Placeholder\n","type":"Algorithm.Algorithm -> Algorithm.Algorithm"},{"name":"toString","comment":" Placeholder\n","type":"Algorithm.Algorithm -> String.String"},{"name":"toTurnList","comment":" Placeholder\n","type":"Algorithm.Algorithm -> List.List Algorithm.Turn"}],"binops":[]},{"name":"Cube","comment":" Documentation to come\n\n@docs Cube, applyAlgorithm, solved, viewUBLWithLetters, viewUFRNoLetters, viewUFRWithLetters\n\n","unions":[{"name":"Cube","comment":" Placeholder\n","args":[],"cases":[["Cube",["Internal.Cube.Cube"]]]}],"aliases":[],"values":[{"name":"applyAlgorithm","comment":" Placeholder\n","type":"Algorithm.Algorithm -> Cube.Cube -> Cube.Cube"},{"name":"solved","comment":" Placeholder\n","type":"Cube.Cube"},{"name":"viewUBLWithLetters","comment":" Placeholder\n","type":"List.List (Html.Attribute msg) -> Basics.Int -> Cube.Cube -> Html.Html msg"},{"name":"viewUFRNoLetters","comment":" Placeholder\n","type":"List.List (Html.Attribute msg) -> Basics.Int -> Cube.Cube -> Html.Html msg"},{"name":"viewUFRWithLetters","comment":" Placeholder\n","type":"List.List (Html.Attribute msg) -> Basics.Int -> Cube.Cube -> Html.Html msg"}],"binops":[]},{"name":"Cube.Advanced","comment":" Documentation to come\n\n@docs render\n\n","unions":[],"aliases":[],"values":[{"name":"render","comment":" Placeholder\n","type":"Cube.Cube -> Cube.Advanced.Types.Rendering"}],"binops":[]},{"name":"Cube.Advanced.Types","comment":" Documentation to come\n\n@docs Color, CubieRendering, Rendering\n\n","unions":[{"name":"Color","comment":" Placeholder\n","args":[],"cases":[["UpColor",[]],["DownColor",[]],["FrontColor",[]],["BackColor",[]],["LeftColor",[]],["RightColor",[]],["PlasticColor",[]]]}],"aliases":[{"name":"CubieRendering","comment":" Placeholder\n","args":[],"type":"{ u : Cube.Advanced.Types.Color, d : Cube.Advanced.Types.Color, f : Cube.Advanced.Types.Color, b : Cube.Advanced.Types.Color, l : Cube.Advanced.Types.Color, r : Cube.Advanced.Types.Color }"},{"name":"Rendering","comment":" Placeholder\n","args":[],"type":"{ ufr : Cube.Advanced.Types.CubieRendering, ufl : Cube.Advanced.Types.CubieRendering, ubl : Cube.Advanced.Types.CubieRendering, ubr : Cube.Advanced.Types.CubieRendering, dfr : Cube.Advanced.Types.CubieRendering, dfl : Cube.Advanced.Types.CubieRendering, dbl : Cube.Advanced.Types.CubieRendering, dbr : Cube.Advanced.Types.CubieRendering, uf : Cube.Advanced.Types.CubieRendering, df : Cube.Advanced.Types.CubieRendering, db : Cube.Advanced.Types.CubieRendering, ub : Cube.Advanced.Types.CubieRendering, ur : Cube.Advanced.Types.CubieRendering, ul : Cube.Advanced.Types.CubieRendering, dl : Cube.Advanced.Types.CubieRendering, dr : Cube.Advanced.Types.CubieRendering, fl : Cube.Advanced.Types.CubieRendering, fr : Cube.Advanced.Types.CubieRendering, br : Cube.Advanced.Types.CubieRendering, bl : Cube.Advanced.Types.CubieRendering, u : Cube.Advanced.Types.CubieRendering, d : Cube.Advanced.Types.CubieRendering, f : Cube.Advanced.Types.CubieRendering, b : Cube.Advanced.Types.CubieRendering, l : Cube.Advanced.Types.CubieRendering, r : Cube.Advanced.Types.CubieRendering }"}],"values":[],"binops":[]},{"name":"PLL","comment":" Types and helper functions to work with the Permutate Last\nLayer (PLL) algorithm set, the last step of the CFOP method. See\n<https://www.speedsolving.com/wiki/index.php/PLL>\nfor further information\n\n\n# Definition And Constructors\n\n@docs PLL, all\n\n\n# Helpers\n\n@docs getLetters\n\n\n# Collections\n\n@docs Algorithms, getAlgorithm, referenceAlgorithms\n\n","unions":[{"name":"PLL","comment":" All the cases are represented here. Use the value constructors here\nor [@all](#all) to specify a given case in your code, and pass these to\nany of the helper functions\n","args":[],"cases":[["H",[]],["Ua",[]],["Ub",[]],["Z",[]],["Aa",[]],["Ab",[]],["E",[]],["F",[]],["Ga",[]],["Gb",[]],["Gc",[]],["Gd",[]],["Ja",[]],["Jb",[]],["Na",[]],["Nb",[]],["Ra",[]],["Rb",[]],["T",[]],["V",[]],["Y",[]]]}],"aliases":[{"name":"Algorithms","comment":" A collection of algorithms that solves the respective case\n","args":[],"type":"{ h : Algorithm.Algorithm, ua : Algorithm.Algorithm, ub : Algorithm.Algorithm, z : Algorithm.Algorithm, aa : Algorithm.Algorithm, ab : Algorithm.Algorithm, e : Algorithm.Algorithm, f : Algorithm.Algorithm, ga : Algorithm.Algorithm, gb : Algorithm.Algorithm, gc : Algorithm.Algorithm, gd : Algorithm.Algorithm, ja : Algorithm.Algorithm, jb : Algorithm.Algorithm, na : Algorithm.Algorithm, nb : Algorithm.Algorithm, ra : Algorithm.Algorithm, rb : Algorithm.Algorithm, t : Algorithm.Algorithm, v : Algorithm.Algorithm, y : Algorithm.Algorithm }"}],"values":[{"name":"all","comment":" A non-empty list of all the PLLs. Can for example\nbe used for randomly selecting a pll\n\n    import List.Nonempty\n\n    -- All the PLLs are there!\n    List.Nonempty.length all --> 21\n\n    -- We could for example select a random PLL case\n    -- via this\n    List.Nonempty.sample all\n\n","type":"List.Nonempty.Nonempty PLL.PLL"},{"name":"getAlgorithm","comment":" Get the algorithm for the PLL case from an algorithm collection.\nThis helps avoid any typos or need to write your own case statements\nin order to get the algorithm for a case passed to a function\n\n    getAlgorithm referenceAlgorithms Y\n    --> referenceAlgorithms.y\n\n","type":"PLL.Algorithms -> PLL.PLL -> Algorithm.Algorithm"},{"name":"getLetters","comment":" Generates a string of the identifying letters of the case.\n\nThis could be used either for serialization purposes, or for\nbuilding a string to display the user in some instances.\n\n    -- Format is always first letter capitalized and\n    -- the second one lower case if applicable\n    getLetters Ua --> \"Ua\"\n\n    getLetters H --> \"H\"\n\n","type":"PLL.PLL -> String.String"},{"name":"referenceAlgorithms","comment":" Plls verified to be correct so they can be used to verify user selected plls\nor for displaying a pll case somewhere on the site.\n\nThey have been chosen to be the optimally lowest move count in HTM just for a\nsmall performance boost.\n\nThe example tests below are just meant for an easier\nto read version of all the algorithms that are verified to be correct.\nThey are also tested via elm-verify-examples so the string versions are\ncorrect equivalents to the code below.\n\n    import Algorithm\n\n    -- Edges Only\n\n    Algorithm.fromString \"R2 U2 R U2 R2 U2 R2 U2 R U2 R2\"\n    --> Ok referenceAlgorithms.h\n\n    Algorithm.fromString \"F2 U' (L R') F2 (L' R) U' F2\"\n    --> Ok referenceAlgorithms.ua\n\n    Algorithm.fromString \"F2 U (R' L) F2 (R L') U F2\"\n    --> Ok referenceAlgorithms.ub\n\n    Algorithm.fromString \"R B' R' B F R' F B' R' B R F2\"\n    --> Ok referenceAlgorithms.z\n\n    -- Corners Only\n\n    Algorithm.fromString \"R' F R' B2 R F' R' B2 R2\"\n    --> Ok referenceAlgorithms.aa\n\n    Algorithm.fromString \"R B' R F2 R' B R F2 R2\"\n    --> Ok referenceAlgorithms.ab\n\n    Algorithm.fromString \"D R' D2 F' D L D' F D2 R D' F' L' F\"\n    --> Ok referenceAlgorithms.e\n\n    -- Corners And Edges\n\n    Algorithm.fromString \"L F R' F' L' F' D2 B' L' B D2 F' R F2\"\n    --> Ok referenceAlgorithms.f\n\n    Algorithm.fromString \"F2' D (R' U R' U' R) D' F2 L' U L\"\n    --> Ok referenceAlgorithms.ga\n\n    Algorithm.fromString \"R' U' R B2 D (L' U L U' L) D' B2\"\n    --> Ok referenceAlgorithms.gb\n\n    Algorithm.fromString \"R2' D' F U' F U F' D R2 B U' B'\"\n    --> Ok referenceAlgorithms.gc\n\n    Algorithm.fromString \"R U R' F2 D' (L U' L' U L') D F2\"\n    --> Ok referenceAlgorithms.gd\n\n    Algorithm.fromString \"B2 R' U' R B2 L' D L' D' L2\"\n    --> Ok referenceAlgorithms.ja\n\n    Algorithm.fromString \"B2 (L U L') B2 (R D' R D) R2\"\n    --> Ok referenceAlgorithms.jb\n\n    Algorithm.fromString \"L U' R U2 L' U R' L U' R U2 L' U R'\"\n    --> Ok referenceAlgorithms.na\n\n    Algorithm.fromString \"R' U L' U2 R U' L R' U L' U2 R U' L\"\n    --> Ok referenceAlgorithms.nb\n\n    Algorithm.fromString \"F2 R' F' U' F' U F R F' U2 F U2 F'\"\n    --> Ok referenceAlgorithms.ra\n\n    Algorithm.fromString \"R2 F R U R U' R' F' R U2 R' U2 R\"\n    --> Ok referenceAlgorithms.rb\n\n    Algorithm.fromString \"F2 D R2 U' R2 F2 D' L2 U L2\"\n    --> Ok referenceAlgorithms.t\n\n    Algorithm.fromString \"R' U R' U' B' R' B2 U' B' U B' R B R\"\n    --> Ok referenceAlgorithms.v\n\n    Algorithm.fromString \"F2 D R2 U R2 D' R' U' R F2 R' U R\"\n    --> Ok referenceAlgorithms.y\n\n","type":"PLL.Algorithms"}],"binops":[]}]