The List Monad

class hymn.types.list.List

the list monad

nondeterministic computation

fmap(self, f)

return list obtained by applying f to each element of the list

join()

join of list monad, concatenate list of list

append(self, other)

the append operation of List

classmethod concat(cls, list_of_lists)

the concat operation of List

plus(self, other)

concatenate two lists

classmethod unit(cls, \*values)

the unit, create a List from values

property zero

the zero of list monad, an empty list

hymn.types.list.fmap(f, iterable)

fmap works like the builtin map, but return a List instead of list

Hy Specific API

list-m

alias of List

Reader Macro

@ [seq]

turn iterable seq into a List

Changed in version 1.0.0.

Note

This is the new name of reader macro ~.

Examples

Do Notation

=> (import hymn.types.list [list-m])
=> (require hymn.macros [do-monad-return])
=> (list (do-monad-return [a (list-m [1 2 3])] (+ a 1)))
[2 3 4]
=> (list (do-monad-return [a (list-m [1 2 3]) b (list-m [4 5 6])] (+ a b)))
[5 6 7 6 7 8 7 8 9]
=> (list (do-monad-return [a (list-m "123") b (list-m "xy")] (+ a b)))
["1x" "1y" "2x" "2y" "3x" "3y"]

Do Notation with :when

=> (import hymn.types.list [list-m])
=> (require hymn.macros [do-monad-return])
=> (list (do-monad-return
...         [a (list-m [1 2 4])
...          b (list-m [1 2 4])
...          :when (!= a b)]
...         (/ a b)))
[0.5 0.25 2.0 0.5 4.0 2.0]

Operations

unit accepts any number of initial values

=> (import hymn.types.list [list-m])
=> (list (list-m.unit))
[]
=> (list (list-m.unit 1))
[1]
=> (list (list-m.unit 1 3))
[1 3]
=> (list (list-m.unit 1 3 5))
[1 3 5]

fmap() works like the builtin map function, but creates List instead of the builtin list

=> (import hymn.types.list [fmap list-m])
=> (isinstance (fmap (fn [x] (+ x 1)) [0 1 2]) list-m)
True
=> (for [e (fmap (fn [x] (+ x 1)) [0 1 2])] (print e))
1
2
3

Reader Macro

=> (import hymn.types.list [list-m])
=> (require hymn.types.list :readers [@])
=> (isinstance #@ [0 1 2] list-m)
True
=> (require hymn.macros [do-monad-return])
=> (list (do-monad-return [a #@ (range 10) :when (= 1 (% a 2))] (* a 2)))
[2 6 10 14 18]