F# 函数返回

Question

I'm new to F# and playing around a bit, I already did work with C#. One thing that recently confused me a bit was returning values in functions. I do unterstand that everything is an expression (as described here ) and that the following code won't compile nor execute:

let foo x =
   if x = 0 then x + 2 //The compiler will complain here due to a missing else branch.
   x - 2

Instead, you would have to write that:

let foo x =
   if x = 0 then x + 2
   else x - 2

I do see why that is and a similar problem also occurs when having a loop.

But consider a function which equals a "contains" function of a list in C#:

public static bool Contains(int num, List<int> list) {
   foreach (int i in list) {
      if (i == num) return true;
   }
   return false;
}

If you would translate that one by one, the compiler will tell you there is missing an else branch and I do unterstand why:

let Contains (num : int) list =
   for i in list do
      if i = x then true //Won't compile due to a missing else branch!
   false

Instead, you'd probably write a recursive function like that:

let rec Contains (num : int) list =
   match list with
   |  [] -> false
   |  head::tail -> head = num || (Contains num tail)

And I'm be fine with that, but in some situations, it is hard to do pattern matching. Is there really no way to do the described above? Couldn't one use a keyword like yield (or something similar to "return" in C#)?

Answer 1

I agree with you: early exits in C# can be convenient, especially to increase readability by avoiding nested if .

In F#, to avoid nested if or too big pattern matching (ie with too much cases or an input tuple with too much items), we can extract sub-functions: with meaningful name, it improves the code readability.

With lists and sequences ( IEnumerable ) in C#, code is generally more declarative using built-in methods or LINQ than using for/foreach loops. It's not always true but it's worth trying. By the way, in some situations, ReSharper can suggest to refactor for/foreach loops to LINQ queries.

→ This coding style is easily translatable to F#:

• List:
  • C# → list.Contains(num)
  • F# → [1;2;3] |> List.contains 1
• Sequence:
  • C# → list.Any(x => x == num)
  • F# → seq { 1;2;3 } |> Seq.exists ((=) 1)
  • F# → seq { 1;2;3 } |> Seq.contains 1

Answer 2

An early return in C# is really just a GOTO. And I would consider that bad style, except for the "bouncer pattern" (validation). The argument there usually is to get rid of mental overload as early as possible. Given F#'s expressiveness, most validation can happen through types, so the otherwise ubiquitous if param = null || invalid(param) return if param = null || invalid(param) return style is not (or at least less) needed. Once you embrace the functional style, you'll find that there is less and less need for it. If needed, you can always simulate the goto:-)

exception Ret of string

let needsEarlyReturn foos =
    try
        for f in foos do
            if f > 42 then Ret "don't do" |> raise
            // more code
            if f > 7 then Ret "that ever" |> raise
        "!"
    with Ret v -> v

Answer 3

Keep in mind that the F# compiler converts tail recursion into a loop. So the solution is really to use a tail-recursive helper function even if you're using a type that doesn't have the pattern matching support of the F# list. Some examples:

A contains method for any IEnumerable<int> :

let contains item (xs : int seq) =
    use e = xs.GetEnumerator()
    let rec helper() = e.MoveNext() && (e.Current = item || helper())
    helper()

A similar method for a System.Collections.Generic.List<int> :

let contains item (xs : ResizeArray<int>) =
    let rec helper i = i < xs.Count && (xs.[i] = item || helper (i + 1)) 
    helper 0

In general, you can use a helper function for early exit like this (to keep the examples simple, the loop is infinite; the only way out is through the early exit):

let shortCircuitLoop shouldReturn getNextValue seed =
    let rec helper accumulator =
        if shouldReturn accumulator then accumulator else helper (getNextValue accumulator)
    helper seed

A C# version of this:

T ShortCircuit<T>(Func<T, bool> shouldReturn, Func<T, T> getNextValue, T seed) {
    while (true)
    {
        if (shouldReturn(seed))
            return seed;
        seed = getNextValue(seed);
    }
}

These examples are for illustration only, of course, as a pedagogical exercise. In production code, as noted by Romain Deneau, you'll want to use the library functions such as Seq.contains , List.contains , and so on.