about summary refs log tree commit diff
path: root/users/wpcarro/scratch/haskell-programming-from-first-principles/state.hs
blob: f63e0ecdf11cfe76bc3de9788c58df1a0d4d7b41 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
module StateScratch where

--------------------------------------------------------------------------------
import System.Random
-- import Control.Monad.Trans.State
import Data.Function ((&))

import qualified Control.Applicative as Ap
import qualified Control.Monad as M
--------------------------------------------------------------------------------

data Die
  = DieOne
  | DieTwo
  | DieThree
  | DieFour
  | DieFive
  | DieSix
  deriving (Eq, Show)

intToDie :: Integer -> Maybe Die
intToDie 1 = Just DieOne
intToDie 2 = Just DieTwo
intToDie 3 = Just DieThree
intToDie 4 = Just DieFour
intToDie 5 = Just DieFive
intToDie 6 = Just DieSix
intToDie _ = Nothing

rollDie :: Moi StdGen Die
rollDie = do
  (n, s) <- randomR (1, 6)
  case intToDie n of
    Just d  -> pure (d, s)
    Nothing -> pure (DieOne, s)

rollsToGetN :: Integer -> StdGen -> [Die]
rollsToGetN n g = go 0 [] g
  where
    go sum result gen
      | sum >= n = result
      | otherwise =
        let (dice, nextGen) = randomR (1, 6) gen
        in case intToDie dice of
          Nothing -> go (sum + dice) result nextGen
          Just d  -> go (sum + dice) (d : result) nextGen

--------------------------------------------------------------------------------

newtype Moi s a = Moi { runMoi :: s -> (a, s) }

instance Functor (Moi s) where
  fmap f (Moi run) =
    Moi $ \s -> let (x, t) = run s
                in (f x, t)

instance Applicative (Moi s) where
  pure x = Moi $ \s -> (x, s)
  (Moi f) <*> (Moi run) =
    Moi $ \s -> let (g, t) = f s
                    (x, u) = run t
                in (g x, u)

instance Monad (Moi s) where
  (Moi run1) >>= f =
    Moi $ \s -> let (x, t) = run1 s
                    (Moi run2) = f x
                in run2 t

--------------------------------------------------------------------------------

fizzBuzz :: Integer -> String
fizzBuzz n | n `mod` 15 == 0 = "FizzBuzz"
           | n `mod`  5 == 0 = "Buzz"
           | n `mod`  3 == 0 = "Fizz"
           | otherwise       = show n

--------------------------------------------------------------------------------

get :: Moi s s
get = Moi $ \s -> (s, s)

put :: s -> Moi s ()
put x = Moi $ \s -> ((), x)

exec :: Moi s a -> s -> s
exec (Moi run) x = x & run & snd

eval :: Moi s a -> s -> a
eval (Moi run) x = x & run & fst

modify :: (s -> s) -> Moi s ()
modify f = Moi $ \s -> ((), f s)