Support App.transform

Apply the transform to a Keyboard. Onwards to the final demonstration!

5 files changed, 57 insertions, 1 deletions

diff --git a/scratch/brilliant/App.hs b/scratch/brilliant/App.hs
new file mode 100644
index 000000000000..3801eac7a803
--- /dev/null
+++ b/scratch/brilliant/App.hs
@@ -0,0 +1,14 @@
+--------------------------------------------------------------------------------
+module App where
+--------------------------------------------------------------------------------
+import Keyboard (Keyboard(..))
+import Transforms (Transform(..))
+import Utils ((|>))
+
+import qualified Utils
+--------------------------------------------------------------------------------
+
+transform :: Transform -> Keyboard -> Keyboard
+transform HorizontalFlip (Keyboard xs) = xs |> fmap reverse |> Keyboard
+transform VerticalFlip (Keyboard xs) = xs |> reverse |> Keyboard
+transform (Shift n) (Keyboard xs) = xs |> fmap (Utils.rotate n) |> Keyboard
diff --git a/scratch/brilliant/Keyboard.hs b/scratch/brilliant/Keyboard.hs
index c5baaa5f2474..885acb29e4cd 100644
--- a/scratch/brilliant/Keyboard.hs
+++ b/scratch/brilliant/Keyboard.hs
@@ -6,6 +6,7 @@ import qualified Data.List as List
 --------------------------------------------------------------------------------
 
 newtype Keyboard = Keyboard [[Char]]
+  deriving (Eq)
 
 instance Show Keyboard where
   show (Keyboard xxs) =
diff --git a/scratch/brilliant/Spec.hs b/scratch/brilliant/Spec.hs
index f49a3d3d96a4..c55da72d0c37 100644
--- a/scratch/brilliant/Spec.hs
+++ b/scratch/brilliant/Spec.hs
@@ -4,10 +4,13 @@ module Spec where
 import Test.Hspec
 import Test.QuickCheck
 import Control.Exception (evaluate)
+import Keyboard (Keyboard(..))
 import Transforms (Transform(..))
 
+import qualified App
 import qualified Keyboard
 import qualified Transforms
+import qualified Utils
 --------------------------------------------------------------------------------
 
 main :: IO ()
@@ -35,3 +38,36 @@ main = hspec $ do
 
     it "return Nothing when the input is valid except for the end" $ do
       Transforms.fromString "HVS10potato" == Nothing
+
+  describe "App.transform" $ do
+    it "flips a keyboard horizontally" $ do
+      App.transform HorizontalFlip Keyboard.qwerty == do
+        Keyboard [ reverse ['1','2','3','4','5','6','7','8','9','0']
+                 , reverse ['Q','W','E','R','T','Y','U','I','O','P']
+                 , reverse ['A','S','D','F','G','H','J','K','L',';']
+                 , reverse ['Z','X','C','V','B','N','M',',','.','/']
+                 ]
+
+    it "flips a keyboard vertically" $ do
+      App.transform VerticalFlip Keyboard.qwerty == do
+        Keyboard $ reverse [ ['1','2','3','4','5','6','7','8','9','0']
+                           , ['Q','W','E','R','T','Y','U','I','O','P']
+                           , ['A','S','D','F','G','H','J','K','L',';']
+                           , ['Z','X','C','V','B','N','M',',','.','/']
+                           ]
+
+    it "shifts a keyboard N times" $ do
+      App.transform (Shift 2) Keyboard.qwerty == do
+        Keyboard $ [ Utils.rotate 2 ['1','2','3','4','5','6','7','8','9','0']
+                   , Utils.rotate 2 ['Q','W','E','R','T','Y','U','I','O','P']
+                   , Utils.rotate 2 ['A','S','D','F','G','H','J','K','L',';']
+                   , Utils.rotate 2 ['Z','X','C','V','B','N','M',',','.','/']
+                   ]
+
+    it "shifts negative amounts" $ do
+      App.transform (Shift (-3)) Keyboard.qwerty == do
+        Keyboard $ [ Utils.rotate (-3) ['1','2','3','4','5','6','7','8','9','0']
+                   , Utils.rotate (-3) ['Q','W','E','R','T','Y','U','I','O','P']
+                   , Utils.rotate (-3) ['A','S','D','F','G','H','J','K','L',';']
+                   , Utils.rotate (-3) ['Z','X','C','V','B','N','M',',','.','/']
+                   ]
diff --git a/scratch/brilliant/Transforms.hs b/scratch/brilliant/Transforms.hs
index e707defda796..810c5f960ae1 100644
--- a/scratch/brilliant/Transforms.hs
+++ b/scratch/brilliant/Transforms.hs
@@ -7,7 +7,7 @@ import Text.ParserCombinators.ReadP
 
 data Transform = VerticalFlip
                | HorizontalFlip
-               | Shift Integer
+               | Shift Int
                deriving (Eq, Show)
 
 digit :: ReadP Char
diff --git a/scratch/brilliant/Utils.hs b/scratch/brilliant/Utils.hs
index 2f401af2fb8f..c69d00333b8e 100644
--- a/scratch/brilliant/Utils.hs
+++ b/scratch/brilliant/Utils.hs
@@ -6,3 +6,8 @@ import Data.Function ((&))
 
 (|>) :: a -> (a -> b) -> b
 (|>) = (&)
+
+-- | Rotate `xs` as a cycle `n` times.
+rotate :: Int -> [a] -> [a]
+rotate n xs = take size . drop (n `mod` size) . cycle $ xs
+  where size = length xs