The Maybe Monad

class hymn.types.maybe.Maybe

the maybe monad

computation that may fail

append(self, other)

the append operation of Maybe

bind(self, f)

the bind operation of Maybe

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

plus(self, other)
from_maybe(self, default)

return the value contained in the Maybe

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

classmethod from_value(cls, value)

wrap value in a Maybe monad

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

class hymn.types.maybe.Just

Just of the Maybe

class hymn.types.maybe.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()

hymn.types.maybe.is_nothing()

return True if m is Nothing

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 with maybe()

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