The Maybe Monad¶
- class hymn.types.maybe.Maybe¶
the maybe monad
computation that may fail
- bind(self, f)¶
the bind operation of
Maybe
apply function to the value if and only if this is a
Just
.
- plus(self, other)¶
- hymn.types.maybe.from_maybe()¶
alias of
from_maybe()
- hymn.types.maybe.to_maybe()¶
alias of
from_value()
Hy Specific API¶
- maybe-m
alias of
Maybe
- <-maybe
- from-maybe
alias of
from_maybe()
- ->maybe
- to-maybe
alias of
to_maybe()
- nothing?
alias of
is_nothing()
Reader Macro¶
- ? [f]
turn
f
into monadic function withmaybe()
Examples¶
Comparison¶
Maybes are comparable if the wrapped values are comparable. Just
is
greater than Nothing
in any case.
=> (import hymn.types.maybe [Just Nothing])
=> (> (Just 2) (Just 1))
True
=> (= (Just 1) (Just 2))
False
=> (= (Just 2) (Just 2))
True
=> (= Nothing Nothing)
True
=> (= Nothing (Just 1))
False
=> (< (Just -1) Nothing)
False
Do Notation¶
=> (import hymn.types.maybe [Just Nothing])
=> (require hymn.macros [do-monad-return])
=> (do-monad-return [a (Just 1) b (Just 2)] (+ a b))
Just(3)
=> (do-monad-return [a (Just 1) b Nothing] (+ a b))
Nothing
Do Notation with :when¶
=> (import hymn.types.maybe [maybe-m])
=> (require hymn.macros [do-monad-with])
=> (defn safe-div [a b]
... (do-monad-with maybe-m [:when (not (= 0 b))] (/ a b)))
=> (safe-div 1 2)
Just(0.5)
=> (safe-div 1 0)
Nothing
Operations¶
Use ->maybe()
to create a Maybe
from value
=> (import hymn.types.maybe [->maybe])
=> (->maybe 42)
Just(42)
=> (->maybe None)
Nothing
nothing?()
returns True
if the value is Nothing
=> (import hymn.types.maybe [Just Nothing nothing?])
=> (nothing? Nothing)
True
=> (nothing? (Just 1))
False
<-maybe()
returns the value in the monad, or a default value if it is
Nothing
=> (import hymn.types.maybe [<-maybe ->maybe nothing?])
=> (nothing? (->maybe None))
True
=> (setv answer (->maybe 42))
=> (setv nothing (->maybe None))
=> (<-maybe answer "not this one")
42
=> (<-maybe nothing "I got nothing")
"I got nothing"
append()
adds up the values, handling Nothing
gracefully
=> (import hymn.types.maybe [Just Nothing])
=> (.append (Just 42) Nothing)
Just(42)
=> (.append (Just 42) (Just 42))
Just(84)
=> (.append Nothing (Just 42))
Just(42)
maybe()
turns a function into monadic one
=> (import hymn.types.maybe [maybe])
=> (defn [maybe] add1 [n] (+ 1 (int n)))
=> (add1 "41")
Just(42)
=> (add1 "nan")
Nothing
=> (import hy.pyops [/])
=> (setv safe-div (maybe /))
=> (safe-div 1 2)
Just(0.5)
=> (safe-div 1 0)
Nothing
Reader Macro¶
=> (require hymn.types.maybe :readers [?])
=> (#? int "42")
Just(42)
=> (#? int "not a number")
Nothing
=> (import hy.pyops [/])
=> (setv safe-div #? /)
=> (safe-div 1 2)
Just(0.5)
=> (safe-div 1 0)
Nothing