Finally finished ch 23

Author: tclv

ch23/ChapterExercises.hs

@@ -0,0 +1,38 @@
+
+
+newtype State s a =
+  State { runState :: s -> (a, s) }
+
+instance Functor (State s) where
+  fmap f (State g) = State $ \s -> let (a, s') = g s
+                                    in (f a, s')
+
+instance Applicative (State s) where
+  (State f) <*> (State g) = State $ \s -> let (h, s') = f s
+                                              (a, s'') = g s' 
+                                           in (h a, s'')
+
+  pure a = State $ \ s -> (a, s)
+
+instance Monad (State s) where
+  (State f) >>= g = State $ \s -> let (a, s') = f s
+                                      State h   = g a
+                                   in h s'
+
+  return = pure
+
+
+get :: State s s
+get = State $ \ s -> (s, s)
+
+put :: s -> State s ()
+put s = State $ const ((), s)
+
+exec :: State s a -> s -> s
+exec s = snd . runState s
+
+eval :: State s a -> s -> a
+eval s = fst . runState s
+
+modify :: (s -> s) -> State s ()
+modify f = f <$> get >>= put

ch23/FizzBuzz.hs

@@ -0,0 +1,44 @@
+
+import Control.Monad
+import Control.Monad.Trans.State
+
+import qualified Data.DList as DL
+
+import Data.Foldable
+
+fizzBuzz :: Integer -> String
+fizzBuzz n | n `mod` 15 == 0 = "FizzBuzz"
+           | n `mod` 5  == 0 = "Buzz"
+           | n `mod` 3  == 0 = "Fizz"
+           | otherwise       = show n
+
+
+
+
+fizzbuzzList :: [Integer] -> DL.DList String
+fizzbuzzList list = execState (mapM_ addResult list) DL.empty
+
+addResult :: Integer -> State (DL.DList String) ()
+addResult n = do
+  xs <- get
+  let result = fizzBuzz n
+  put (DL.snoc xs result)
+
+fizzbuzzFromTo :: Integer -> Integer -> [String]
+fizzbuzzFromTo from to = execState (mapM_ addR' [to, to-1 .. from]) []
+
+addR' :: Integer -> State ([String]) ()
+addR' n = do
+  xs <- get 
+  let result = fizzBuzz n
+  put (result : xs)
+
+main :: IO ()
+main = do 
+  let a = toList $ fizzbuzzList $ [1 .. 100]
+      b = fizzbuzzFromTo 1 100
+
+  print $ a == b
+
+{-main :: IO ()-}
+{-main = traverse_ (putStrLn . fizzBuzz) [1..100]-}

ch23/Moi.hs

@@ -0,0 +1,22 @@
+
+
+newtype Moi s a =
+  Moi { runMoi :: s -> (a, s) }
+
+instance Functor (Moi s) where
+  fmap f (Moi g) = Moi $ \s -> let (a, s') = g s
+                                in (f a, s')
+
+instance Applicative (Moi s) where
+  (Moi f) <*> (Moi g) = Moi $ \s -> let (h, s') = f s
+                                        (a, s'') = g s' 
+                                     in (h a, s'')
+
+  pure a = Moi $ \ s -> (a, s)
+
+instance Monad (Moi s) where
+  (Moi f) >>= g = Moi $ \s -> let (a, s') = f s
+                                  Moi h   = g a
+                               in h s'
+
+  return = pure

ch23/ThrowDown.hs

@@ -26,12 +26,12 @@ intToDie n =
     x -> error $ "intToDie got non 1-6 integer: " ++ show x
 
 rollDieThreeTimes :: (Die, Die, Die)
-rollDieThreeTimes = do
+rollDieThreeTimes =
   let s = mkStdGen 0
       (d1, s1) = randomR (1, 6) s
       (d2, s2) = randomR (1, 6) s1
       (d3, _)  = randomR (1, 6) s2
-  (intToDie d1, intToDie d2, intToDie d3)
+   in (intToDie d1, intToDie d2, intToDie d3)
 
 rollDie :: State StdGen Die
 rollDie = state $ do
@@ -45,9 +45,12 @@ rollDieThreeTimes' :: State StdGen (Die, Die, Die)
 rollDieThreeTimes' =
   liftA3 (,,) rollDie' rollDie' rollDie'
 
+
+-- Repeats a single value
 infiniteDie :: State StdGen [Die]
 infiniteDie = repeat <$> rollDie
 
+-- What you actually want
 nDie :: Int -> State StdGen [Die]
 nDie n = replicateM n rollDie