This type represents a 3x3 Rubik's Cube that can be displayed. That means that encoded in the model is also the orientation of the whole cube. This means that a cube with yellow facing upwards is not the same as a cube in the same state with the green face facing upwards.

You can use the helper functions below to manipulate and display the cube. You could for example do something like this:

import Algorithm
import Cube


Cube.solved
    |> Cube.applyAlgorithm
        (
            Algorithm.fromTurnList
                [
                    Algorithm.Turn
                        Algorithm.U
                        Algorithm.Halfway
                        Algorithm.Clockwise
                ]
        )
    |> Cube.viewUFRNoLetters

A solved cube with the initial orientation, so the up face has UpColor etc.

Apply the given moves of the algorithm to the cube. Reminder that this again depends on the orientation of the cube how the turns will be applied, though problems with this aren't expected to arise often given "normal use".

The different supported angles to display a cube from

The display angle where the U, F, and R faces can be seen

The display angle where the U, B, and L faces can be seen

Display a 3x3 cube from one of several angles, and with or without the faces annotated with their respective face letters (e.g U R B).

Display a cube that can animate turns being applied to it. You can also specify which angle to see it from and whether to annotate the faces just like on view

The function that can handle the opaque animation message type and output the next animation state and any commands the package needs to have run for it

The animation state describing the animation of an algorithm. Set this in your model while viewAnimatable is being used and AnimationMsg is being handled and your cube will animate on screen

The animation state describing a static cube with no animated turns applied to it

Pause an animation either to stop it completely or to unpause it later

Continue a paused animation. This won't have any effect if the animation is not paused

A helper function that given an animation state will tell you which turn is currently being animated if any

An opaque type that describes the internal state this package uses to manage the animation of turns on a cube

An opaque type describing the internal messages this package uses to manage the animation of a cube

Check that two algorithms produce the exact same result when applied to a cube. They also have to end at the exact same orientation, so while you may very rarely want this, you are probably looking for algorithmResultAreEquivalentIndependentOfFinalRotation

Checks that two algorithms produce the exact same result, but they are allowed to leave the cube in different orientations / rotations and still be considered equivalent

Changes the algorithm so that it leaves the cube in the same orientation that it started in if it didn't already. It doesn't change what cube state the algorithm leaves the cube in.

If you are wondering why this doesn't live in in the Algorithm module that's a valid question. It is because it makes the most sense in the context of the resulting cube that comes out of an algorithm being applied. If one was to think of it without using the Cube module one would nearly have to reimplement concepts from the Cube module.