Diagrams.RubiksCube.Model

Constructing cubes

data Side a

One side of the Rubik's Cube with 3*3 facets.

Constructors

Side

Fields

• _topLeft :: a
• _topCenter :: a
• _topRight :: a
• _middleLeft :: a
• _middleCenter :: a
• _middleRight :: a
• _bottomLeft :: a
• _bottomCenter :: a
• _bottomRight :: a

Instances

Functor Side

Methods

fmap :: (a -> b) -> Side a -> Side b

(<$) :: a -> Side b -> Side a

Applicative Side

Methods

pure :: a -> Side a

(<*>) :: Side (a -> b) -> Side a -> Side b

(*>) :: Side a -> Side b -> Side b

(<*) :: Side a -> Side b -> Side a

Foldable Side

Methods

fold :: Monoid m => Side m -> m

foldMap :: Monoid m => (a -> m) -> Side a -> m

foldr :: (a -> b -> b) -> b -> Side a -> b

foldr' :: (a -> b -> b) -> b -> Side a -> b

foldl :: (b -> a -> b) -> b -> Side a -> b

foldl' :: (b -> a -> b) -> b -> Side a -> b

foldr1 :: (a -> a -> a) -> Side a -> a

foldl1 :: (a -> a -> a) -> Side a -> a

toList :: Side a -> [a]

null :: Side a -> Bool

length :: Side a -> Int

elem :: Eq a => a -> Side a -> Bool

maximum :: Ord a => Side a -> a

minimum :: Ord a => Side a -> a

sum :: Num a => Side a -> a

product :: Num a => Side a -> a

Traversable Side

Methods

traverse :: Applicative f => (a -> f b) -> Side a -> f (Side b)

sequenceA :: Applicative f => Side (f a) -> f (Side a)

mapM :: Monad m => (a -> m b) -> Side a -> m (Side b)

sequence :: Monad m => Side (m a) -> m (Side a)

Eq a => Eq (Side a)

Methods

(==) :: Side a -> Side a -> Bool

(/=) :: Side a -> Side a -> Bool

Show a => Show (Side a)

Methods

showsPrec :: Int -> Side a -> ShowS

show :: Side a -> String

showList :: [Side a] -> ShowS

Reversing (Side a)

Methods

reversing :: Side a -> Side a

topLeft :: forall a. Lens' (Side a) a

topCenter :: forall a. Lens' (Side a) a

topRight :: forall a. Lens' (Side a) a

middleLeft :: forall a. Lens' (Side a) a

middleCenter :: forall a. Lens' (Side a) a

middleRight :: forall a. Lens' (Side a) a

bottomLeft :: forall a. Lens' (Side a) a

bottomCenter :: forall a. Lens' (Side a) a

bottomRight :: forall a. Lens' (Side a) a

rotateSideCW :: Aut (Side a)

Rotate the side clockwise.

rotateSideCCW :: Aut (Side a)

Rotate the side counter-clockwise.

data Cube a

A cube with six sides.

     +---+
     | u |
 +---+---+---+---+
 | l | f | r | b |
 +---+---+---+---+
     | d |
     +---+

Constructors

Cube

Fields

• _frontSide :: a
• _backSide :: a
• _leftSide :: a
• _rightSide :: a
• _upSide :: a
• _downSide :: a

Instances

Functor Cube

Methods

fmap :: (a -> b) -> Cube a -> Cube b

(<$) :: a -> Cube b -> Cube a

Applicative Cube

Methods

pure :: a -> Cube a

(<*>) :: Cube (a -> b) -> Cube a -> Cube b

(*>) :: Cube a -> Cube b -> Cube b

(<*) :: Cube a -> Cube b -> Cube a

Foldable Cube

Methods

fold :: Monoid m => Cube m -> m

foldMap :: Monoid m => (a -> m) -> Cube a -> m

foldr :: (a -> b -> b) -> b -> Cube a -> b

foldr' :: (a -> b -> b) -> b -> Cube a -> b

foldl :: (b -> a -> b) -> b -> Cube a -> b

foldl' :: (b -> a -> b) -> b -> Cube a -> b

foldr1 :: (a -> a -> a) -> Cube a -> a

foldl1 :: (a -> a -> a) -> Cube a -> a

toList :: Cube a -> [a]

null :: Cube a -> Bool

length :: Cube a -> Int

elem :: Eq a => a -> Cube a -> Bool

maximum :: Ord a => Cube a -> a

minimum :: Ord a => Cube a -> a

sum :: Num a => Cube a -> a

product :: Num a => Cube a -> a

Traversable Cube

Methods

traverse :: Applicative f => (a -> f b) -> Cube a -> f (Cube b)

sequenceA :: Applicative f => Cube (f a) -> f (Cube a)

mapM :: Monad m => (a -> m b) -> Cube a -> m (Cube b)

sequence :: Monad m => Cube (m a) -> m (Cube a)

Eq a => Eq (Cube a)

Methods

(==) :: Cube a -> Cube a -> Bool

(/=) :: Cube a -> Cube a -> Bool

Show a => Show (Cube a)

Methods

showsPrec :: Int -> Cube a -> ShowS

show :: Cube a -> String

showList :: [Cube a] -> ShowS

frontSide :: forall a. Lens' (Cube a) a

backSide :: forall a. Lens' (Cube a) a

leftSide :: forall a. Lens' (Cube a) a

rightSide :: forall a. Lens' (Cube a) a

upSide :: forall a. Lens' (Cube a) a

downSide :: forall a. Lens' (Cube a) a

newtype RubiksCube a

A normal Rubik's cube with 6 sides with 9 facets each.

Constructors

RubiksCube

Fields

• _cube :: Cube (Side a)

Instances

Functor RubiksCube

Methods

fmap :: (a -> b) -> RubiksCube a -> RubiksCube b

(<$) :: a -> RubiksCube b -> RubiksCube a

Applicative RubiksCube

Methods

pure :: a -> RubiksCube a

(<*>) :: RubiksCube (a -> b) -> RubiksCube a -> RubiksCube b

(*>) :: RubiksCube a -> RubiksCube b -> RubiksCube b

(<*) :: RubiksCube a -> RubiksCube b -> RubiksCube a

Eq a => Eq (RubiksCube a)

Methods

(==) :: RubiksCube a -> RubiksCube a -> Bool

(/=) :: RubiksCube a -> RubiksCube a -> Bool

Show a => Show (RubiksCube a)

Methods

showsPrec :: Int -> RubiksCube a -> ShowS

show :: RubiksCube a -> String

showList :: [RubiksCube a] -> ShowS

cube :: forall a a. Iso (RubiksCube a) (RubiksCube a) (Cube (Side a)) (Cube (Side a))

Selecting rows and columns

data Vec3 a

A list of fixed length 3.

Constructors

Vec3 a a a

Instances

Functor Vec3

Methods

fmap :: (a -> b) -> Vec3 a -> Vec3 b

(<$) :: a -> Vec3 b -> Vec3 a

Applicative Vec3

Methods

pure :: a -> Vec3 a

(<*>) :: Vec3 (a -> b) -> Vec3 a -> Vec3 b

(*>) :: Vec3 a -> Vec3 b -> Vec3 b

(<*) :: Vec3 a -> Vec3 b -> Vec3 a

Foldable Vec3

Methods

fold :: Monoid m => Vec3 m -> m

foldMap :: Monoid m => (a -> m) -> Vec3 a -> m

foldr :: (a -> b -> b) -> b -> Vec3 a -> b

foldr' :: (a -> b -> b) -> b -> Vec3 a -> b

foldl :: (b -> a -> b) -> b -> Vec3 a -> b

foldl' :: (b -> a -> b) -> b -> Vec3 a -> b

foldr1 :: (a -> a -> a) -> Vec3 a -> a

foldl1 :: (a -> a -> a) -> Vec3 a -> a

toList :: Vec3 a -> [a]

null :: Vec3 a -> Bool

length :: Vec3 a -> Int

elem :: Eq a => a -> Vec3 a -> Bool

maximum :: Ord a => Vec3 a -> a

minimum :: Ord a => Vec3 a -> a

sum :: Num a => Vec3 a -> a

product :: Num a => Vec3 a -> a

Traversable Vec3

Methods

traverse :: Applicative f => (a -> f b) -> Vec3 a -> f (Vec3 b)

sequenceA :: Applicative f => Vec3 (f a) -> f (Vec3 a)

mapM :: Monad m => (a -> m b) -> Vec3 a -> m (Vec3 b)

sequence :: Monad m => Vec3 (m a) -> m (Vec3 a)

Distributive Vec3

Methods

distribute :: Functor f => f (Vec3 a) -> Vec3 (f a)

collect :: Functor f => (a -> Vec3 b) -> f a -> Vec3 (f b)

distributeM :: Monad m => m (Vec3 a) -> Vec3 (m a)

collectM :: Monad m => (a -> Vec3 b) -> m a -> Vec3 (m b)

Representable Vec3

Associated Types

type Rep (Vec3 :: * -> *) :: *

Methods

tabulate :: (Rep Vec3 -> a) -> Vec3 a

index :: Vec3 a -> Rep Vec3 -> a

Eq a => Eq (Vec3 a)

Methods

(==) :: Vec3 a -> Vec3 a -> Bool

(/=) :: Vec3 a -> Vec3 a -> Bool

Show a => Show (Vec3 a)

Methods

showsPrec :: Int -> Vec3 a -> ShowS

show :: Vec3 a -> String

showList :: [Vec3 a] -> ShowS

Reversing (Vec3 a)

Methods

reversing :: Vec3 a -> Vec3 a

type Rep Vec3

type Rep Vec3

topRow :: Lens' (Side a) (Vec3 a)

The top three facets (from left to right).

middleRow :: Lens' (Side a) (Vec3 a)

The middle three facets (from left to right).

bottomRow :: Lens' (Side a) (Vec3 a)

The bottom three facets (from left to right).

leftCol :: Lens' (Side a) (Vec3 a)

The left column (from top to down).

centerCol :: Lens' (Side a) (Vec3 a)

The center column (from top to down).

rightCol :: Lens' (Side a) (Vec3 a)

The right column (from top to down).

Traversing facets

By layer

topLayerFacets :: Traversal' (RubiksCube a) a

The 21=4*3+9 facets in the top layer.

middleLayerFacets :: Traversal' (RubiksCube a) a

The 12=4*3 facets in the middle layer.

bottomLayerFacets :: Traversal' (RubiksCube a) a

The 21=4*3+9 facets in the bottom layer.

By position

centerFacets :: Traversal' (RubiksCube a) a

The six facets that are the center of their side.

cornerFacets :: Traversal' (RubiksCube a) a

The 24=6*4=8*3 corner facets.

edgeFacets :: Traversal' (RubiksCube a) a

The 24=6*4=12*2 edge facets.

Rotating the whole cube

type Aut a = Iso' a a

The type of automorphisms

rotateLeft :: Aut (RubiksCube a)

Rotate the whole Rubik's Cube such that the front side becomes the new left side and the top and bottom sides stay fixed.

rotateRight :: Aut (RubiksCube a)

Rotate the whole Rubik's Cube such that the front side becomes the new right side and the top and bottom sides stay fixed.

rotateDown :: Aut (RubiksCube a)

Rotate the whole Rubik's Cube such that the front side becomes the new bottom side and the left and right sides stay fixed.

rotateUp :: Aut (RubiksCube a)

Rotate the whole Rubik's Cube such that the front side becomes the new top side and the left and right sides stay fixed.

rotateCW :: Aut (RubiksCube a)

Rotate the whole Rubik's Cube such that the top side becomes the new right side and the front and back sides stay fixed.

rotateCCW :: Aut (RubiksCube a)

Rotate the whole Rubik's Cube such that the top side becomes the new left side and the front and back sides stay fixed.

Moving layers of the cube

move :: Move -> Aut (RubiksCube a)

Perform a move.

doMoves :: [Move] -> Aut (RubiksCube a)

Perform a list of moves.

undoMoves :: [Move] -> Aut (RubiksCube a)

Undo the actions of a list of moves.