tur/option

(defstruct Option [A])

parameterized optional value containing either some A or none.

Since: Phase TC1

(some [A])

wrap a value of type A in a some Option[A].

(some 42)  ; => some(42)

Since: Phase TC1

(none [A])

return the none Option[A] (NULL).

(none)  ; => none

Since: Phase TC1

(some? [A])

check whether an Option[A] contains a value.

(some? (some 1))  ; => true
  (some? (none))    ; => false

Since: Phase TC1

(unwrap [A])

extract the value from a typed Option[A].

(let [o (:: (make-struct Option true 7) (Option int))]
    (unwrap o))  ; => 7

Since: Phase TC1

(unwrap-or [A])

extract the value or return a default.

(unwrap-or (none) 99)   ; => 99
  (unwrap-or (some 7) 99) ; => 7

Since: Phase TC1

(unwrap-or-carrier [o : int dflt : int])

carrier-ABI shim for the Track A cascade: extract the

(option-free [o : int])

free a heap-allocated Option[A].

(option-free my-opt)

Since: Phase TC1

(option-map [A B])

apply a function to the contained value if some.

(option-map (some 3) (fn [x] (* x 2)))  ; => some(6)

Note:
  Mapping over a *literal* `(none)` with an *unannotated* lambda leaves the
  element type under-determined (`(none)` carries no element type) and fails
  to compile -- annotate the lambda or map over a typed Option value. See
  docs/reported/option-map-literal-none-unannotated-fn-no-A-inference.md.

Since: Phase TC1

(option-eq? [A])

compare two Option[A] values using a comparator.

(option-eq? (some 1) (some 1) (fn [a b] (= a b)))  ; => true

Since: Phase TC1

(definstance Eq [Option])

equality using the inner type's Eq instance.

(definstance Functor [Option])

map a function over the some payload; none unchanged.

(fmap (some 21) (fn [x] (* x 2)))  ; => some(42)

Since: stdlib-hkt-consolidation T1

(definstance Applicative [Option])

pure wraps in some; ap applies a some function to a

(ap (some f) (some 3))  ; => some(f 3)

Since: stdlib-hkt-consolidation T1

(definstance Monad [Option])

bind sequences through some; short-circuits on none.

(bind (some 20) (fn [x] (some (+ x 1))))  ; => some(21)

Since: stdlib-hkt-consolidation T1

(definstance Alternative [Option])

empty is none; alt-or picks the first some.

(alt-or (none) (some 7))  ; => some(7)

Since: stdlib-hkt-consolidation T1