Monads

//
enum Maybe<T> {
    Just(T),
    Nothing,
}

// return nothing when the function fails.
fn divide(x: Decimal, y: Decimal) -> Maybe<Decimal> {
    if y == 0 { return Nothing }
    else { return Just(x / y) }
}
// divide(1.0, 4.0) -> returns Just(0.25)
// divide(3.0, 0.0) -> returns Nothing


// use if to test whether Maybe has a value.
let m_x = divide(3.14, 0.0); // see divide function above
// The if statement extracts x from m_x if m_x is the Just variant of Maybe
if let Just(x) = m_x {
    print!("answer: ", x)
} else {
    print!("division failed, divide by zero error...")
}

// use pattern matching 
let result = divide(3.0, 2.0);
match result {
    Just(x) => print!("answer: ", x),
    Nothing => print!("division failed, we'll get em next time."),
}

// Use Monads to compose functions that returns `Maybe` together:
fn chainable_division(maybe_x: Maybe<Decimal>, maybe_y: Maybe<Decimal>) -> Maybe<Decimal> {
    match (maybe_x, maybe_y) {
        (Just(x), Just(y)) => { // If both inputs are Just, check for division by zero and divide accordingly
            if y == 0 { return Nothing }
            else { return Just(x / y) }
        },
        _ => return Nothing // Otherwise return Nothing
    }
}
chainable_division(chainable_division(Just(2.0), Just(0.0)), Just(1.0)); // inside chainable_division fails, outside chainable_division returns Nothing

// Use a `bind` operator (also known as `map`, `flatmap`, or `shove`), to remove a lot of boilerplate (all those `Just` expressions)
// Rust example using ".map". maybe_x is passed through 2 functions that return Maybe<Decimal> and Maybe<String> respectively.
// As with normal function composition the inputs and outputs of functions feeding into each other should match wrapped types. (i.e. the add_one function should return a Maybe<Decimal> which then can be unwrapped to a Decimal for the decimal_to_string function)
let maybe_x: Maybe<Decimal> = Just(1.0)
let maybe_result = maybe_x.map(|x| add_one(x)).map(|x| decimal_to_string(x))

-- Maybe is a type constructor; Nothing and Just are data constructors.
data Maybe a = Nothing | Just a

-- Just is a data constructor. You can construct a data value by applying the Just data constructor to a value:
country = Just "China"

-- Maybe is a type constructor. You can construct a type by applying the Maybe type constructor to a type:
lookupAage :: DB -> String -> Maybe Int

halve :: Int -> Maybe Int
halve x
  | even x = Just (x `div` 2)
  | odd x  = Nothing

 -- This code halves x twice. it evaluates to Nothing if x is not a multiple of 4
halve x >>= halve


-- ??? 
chainable_division(mx,my) =   mx >>=  ( λx ->   my >>= (λy -> Just (x / y))   )

m >>= f  = case m of
        Nothing -> Nothing
        Just x -> f x

eval :: Expr -> Maybe Int
eval (Val n) = return n
eval (Div x y) = do n <- eval x
                    m <- eval y
                    safediv n m
                 

return :: a -> Maybe a  
>>= :: Maybe a -> (a -> Maybe b) -> Maybe b

??? -----> IO ----> ()
           |
          \|/
           environment