The Maybe Monad

class hymn.types.maybe.Just(value)

Bases: hymn.types.maybe.Maybe

Just of the Maybe

class hymn.types.maybe.Maybe(value)

Bases: hymn.types.monadplus.MonadPlus, hymn.mixins.Ord

the maybe monad

computation that may fail

bind(f)

the bind operation of Maybe

apply function to the value if and only if this is a Just.

from_maybe(default)

return the value contained in the Maybe

if the Maybe is Nothing, it returns the default values.

classmethod from_value(value)

wrap value in a Maybe monad

return a Just if the value is evaluated as true. Nothing otherwise.

unit

alias of Just

hymn.types.maybe.from_maybe(self, default)

return the value contained in the Maybe

if the Maybe is Nothing, it returns the default values.

hymn.types.maybe.is_nothing(m)

return True if m is Nothing

hymn.types.maybe.maybe(func=None, predicate=None, nothing_on_exceptions=None)

decorator to turn func into monadic function of the Maybe monad

hymn.types.maybe.maybe_m

alias of Maybe

hymn.types.maybe.unit

alias of Just

hymn.types.maybe.Nothing = Nothing

the Maybe that represents nothing, a singleton, like None

hymn.types.maybe.zero = Nothing

the Maybe that represents nothing, a singleton, like None

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

Reader Macro

? [f]

turn f into monadic function with maybe()

Functions

<-maybe
from-maybe

alias of Maybe.from_maybe()

->maybe
to-maybe

alias of Maybe.from_value()

nothing?

alias of is_nothing()

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

=> (require hymn.dsl)
=> (import [hymn.types.maybe [Just Nothing]])
=> (do-monad [a (Just 1) b (Just 2)] (+ a b))
Just(3)
=> (do-monad [a (Just 1) b Nothing] (+ a b))
Nothing

Do Notation with :when

=> (require hymn.dsl)
=> (import [hymn.types.maybe [maybe-m]])
=> (defn safe-div [a b]
...   (do-monad-with maybe-m [:when (not (zero? b))] (/ a b)))
=> (safe-div 1 2)
Just(0.5)
=> (safe-div 1 0)
Nothing

Operations

->maybe() create a Maybe from value

=> (import [hymn.types.maybe [->maybe]])
=> (->maybe 42)
Just(42)
=> (->maybe nil)
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? (->maybe nil))
True
=> (def answer (->maybe 42))
=> (def nothing (->maybe nil))
=> (<-maybe answer "not this one")
42
=> (<-maybe nothing "I got nothing")
"I got nothing"

maybe() turns a function into monadic one

=> (import [hymn.types.maybe [maybe]])
=> (with-decorator maybe (defn add1 [n] (inc (int n))))
=> (add1 "41")
Just(42)
=> (add1 "nan")
Nothing
=> (def safe-div (maybe /))
=> (safe-div 1 2)
Just(0.5)
=> (safe-div 1 0)
Nothing

Reader Macro

=> (require hymn.types.maybe)
=> (#?int "42")
Just(42)
=> (#?int "not a number")
Nothing
=> (def safe-div #?/)
=> (safe-div 1 2)
Just(0.5)
=> (safe-div 1 0)
Nothing