How to "concat" two options

I'm looking through the F# docs and am wondering about a "missing" function in the Option module. There is a map2 that takes two options and seems to do a logical AND on it. If either is None, the result is None. Otherwise if you've got a Some(a) and Some(b), it returns a Some(f(a,b)).

Where is the logical OR function? I would expect a similar function where if just one is Some, return it. But if both are Some, it would do the Some(f(a,b)) like for the logical AND case. I can write this out manually no problem with a pattern matching.

let concat f a b =
    match a, b with
    | Some(a), Some(b) -> Some(f a b)
    | Some(a), None -> Some(a)
    | None, Some(b) -> Some(b)
    | _ -> None

Practically this could be useful if you've got a list of optional numbers and you want to add them up. The answer is None if the list is empty or only contains None values. None doesn't affect the result, like a zero. Or a couple optional strings and you want to concatenate them.

I'm assuming since F# doesn't seem to have this function in the standard library, I must be thinking about things the wrong way. Or is there a more concise way of doing it?

What you are looking for would be a function of the following type (Note that the type is different than that of map2 because the two options provided as argument need to have the same type (so that you can return one or the other when the other one is not available):

('a -> 'a -> 'a) -> 'a option -> 'a option -> 'a option

As far as I can see, this does not exist in the standard F# library, but it sounds like a potentially useful function. For example, this exists in Haskell as unionWith (see unionWith in the reducers package) - though, of course, in a more generalized form.

I think it is a very reasonable idea to add an implementation of this to your "utils" library or suggest an addition to the F# core libraries. I would also implement this using match as you did. Although it is perhaps interesting that you can also get this behaviour using map2 and orElse (which is, I think, less readable and probably slower):

let unionWith f a b = 
  Option.map2 f a b |> Option.orElse a |> Option.orElse b

I think your implementation is fine, although it can be simplified further:

let concat f a b =
    match a, b with
    | Some(a), Some(b) -> Some(f a b)
    | _, None -> a
    | None, _ -> b

Note that what you're describing is a "maybe monoid". The basic principle is that any semigroup can be turned into a monoid by adding an identity element. Your f function defines the semigroup, and None is the identity element.

Further discussion can be found here. Look for the function called optionAdd in the section titled "A generic solution".

Digression: Haskell can handle this differently, and in a cool way. Instead of passing f explicitly, it's defined by a typeclass instance, and you can then combine values using mappend. For example:

λ mappend (Just "Fizz") (Just "Buzz")
Just "FizzBuzz"

λ mappend (Just "Fizz") Nothing
Just "Fizz"

λ mappend Nothing (Just "Buzz")
Just "Buzz"

Now let's try it with integers instead of strings:

λ mappend (Just 3) (Just 4)
No instance for (Show a0)
arising from a use of ‘show_M316159813823190938125858’
The type variable ‘a0’ is ambiguous

Yikes - what happened? The problem is that there is no unique way to combine integers, so we have to be more specific via a wrapper type:

λ mappend (Sum 3) (Sum 4)
Sum {getSum = 7}

λ mappend (Product 3) (Product 4)
Product {getProduct = 12}