Option ex

Mon.hs

module Mon where

data Option a = None | Some a deriving Show


--class Functor f where
--    fmap :: (a -> b) -> f a -> f b

instance Functor Option where
    fmap f None = None
    fmap f (Some a) = Some (f a)

instance Applicative Option where
    pure a = Some a
    (Some f) <*> (Some a) = Some $ f a
    _ <*> _ = None

--class Monad f where
--    return :: a -> f a
--    bind :: f a -> (a -> f b) -> f b

instance Monad Option where
    return a = Some a
    None >>= f = None
    (Some a) >>= f = f a 


ex1 :: Option Int
ex1 = Some 6

ex2 :: Option Int 
ex2 = None

-- ghci:  div n 0 yields exception
sdiv :: Int -> Int -> Option Int 
sdiv n 0 = None
sdiv n m = Some $ div n m


bad :: Int 
bad = 3 `div` (4 `div` 5)

-- safer.. but how to comopose sdiv ?s
better :: Option Int  
better = case (4 `sdiv` 5) of
            None -> None
            Some n -> 3 `sdiv` n

better' :: Option Int
better' = (4 `sdiv` 5) >>= (\r -> 3 `sdiv` r)

best :: Option Int 
best = do
        r <- 4 `sdiv` 5
        3 `sdiv` r
        

-- exponential time complexity
fib :: Int -> Int 
fib 0 = 0
fib 1 = 1
fib n = fib (n-2) + fib (n-1)

shortcircuit :: Option Int 
shortcircuit = do
                r <- 4 `sdiv` 0
                return $ fib 1000 -- this would take a while