Option Operations Representation in Clef

Option.map : ('a -> 'b) -> 'a option -> 'b option

let map f opt =
    match opt with
    | Some x -> Some (f x)
    | None -> None

recipe {
    let! isSome = isSome optId
    let! someCase = recipe {
        let! value = getValue optId elemType
        let! mapped = app1 mapperNodeId value outputType
        return! some mapped outputType
    }
    let! noneCase = none outputType
    return! ifThenElse isSome someCase noneCase optionOutputType
}

Option.bind : ('a -> 'b option) -> 'a option -> 'b option

let bind f opt =
    match opt with
    | Some x -> f x
    | None -> None

Option.defaultValue : 'a -> 'a option -> 'a

let defaultValue def opt =
    match opt with
    | Some x -> x
    | None -> def

recipe {
    let! isSome = isSome optId
    let! someValue = getValue optId elemType
    return! ifThenElse isSome someValue defaultValueId elemType
}

Option.defaultWith : (unit -> 'a) -> 'a option -> 'a

let defaultWith defThunk opt =
    match opt with
    | Some x -> x
    | None -> defThunk ()

Option.orElse : 'a option -> 'a option -> 'a option

let orElse ifNone opt =
    match opt with
    | Some _ -> opt
    | None -> ifNone

Option.orElseWith : (unit -> 'a option) -> 'a option -> 'a option

let orElseWith ifNoneThunk opt =
    match opt with
    | Some _ -> opt
    | None -> ifNoneThunk ()

Option.filter : ('a -> bool) -> 'a option -> 'a option

let filter predicate opt =
    match opt with
    | Some x -> if predicate x then Some x else None
    | None -> None

recipe {
    let! isSome = isSome optId
    let! filteredSome = recipe {
        let! value = getValue optId elemType
        let! passes = app1 predicateId value boolType
        let! keepSome = some value elemType
        let! discardNone = none elemType
        return! ifThenElse passes keepSome discardNone optionType
    }
    let! noneCase = none elemType
    return! ifThenElse isSome filteredSome noneCase optionType
}

Option.exists : ('a -> bool) -> 'a option -> bool

let exists predicate opt =
    match opt with
    | Some x -> predicate x
    | None -> false

Option.forall : ('a -> bool) -> 'a option -> bool

let forall predicate opt =
    match opt with
    | Some x -> predicate x
    | None -> true  // Vacuously true

Option.iter : ('a -> unit) -> 'a option -> unit

let iter action opt =
    match opt with
    | Some x -> action x
    | None -> ()

Option.toList : 'a option -> 'a list

let toList opt =
    match opt with
    | Some x -> [x]
    | None -> []

Option.toArray : 'a option -> 'a array

let toArray opt =
    match opt with
    | Some x -> [| x |]
    | None -> [| |]

Option.flatten : 'a option option -> 'a option

let flatten opt =
    match opt with
    | Some inner -> inner
    | None -> None

Option.map2 : ('a -> 'b -> 'c) -> 'a option -> 'b option -> 'c option

let map2 f opt1 opt2 =
    match opt1, opt2 with
    | Some x, Some y -> Some (f x y)
    | _ -> None

Option.map3 : ('a -> 'b -> 'c -> 'd) -> 'a option -> 'b option -> 'c option -> 'd option

let map3 f opt1 opt2 opt3 =
    match opt1, opt2, opt3 with
    | Some x, Some y, Some z -> Some (f x y z)
    | _ -> None