if, match and loops as expressions

let label = if age >= 60 then "senior" does not compile: error FS0001 says that the if is missing an else branch. In F#, if, match and even loops are expressions, so an if that produces a string must produce one in every case, and a loop with break has nowhere to break to, because F# has no break.

You will write if and match as expressions whose branches share one type, read the two warnings that keep a match honest, loop with for and while, search a list without break, and write ranges in the form F# 10 expects. Each rule comes with a run recorded on .NET 10, mistakes included.

if/then/else has a value, so every branch needs one

Here are four entries at the prompt, two of them refused:

from session import fsi

# if/then/else as an expression: a missing else, an if run for its effect, elif, and branches of two types.
fsi([
    "let age = 70;;",
    'let label = if age >= 60 then "senior";;',
    'if age >= 60 then printfn "senior";;',
    "let fare = if age < 5 then 0 elif age >= 60 then 40 else 100;;",
    'let kind = if age >= 60 then "senior" else 0;;',
    "#quit;;",
], args=["--nologo"])

$ dotnet fsi --nologo
> let age = 70;;
val age: int = 70

> let label = if age >= 60 then "senior";;

  let label = if age >= 60 then "senior";;
  ------------------------------^^^^^^^^

stdin(2,31): error FS0001: This 'if' expression is missing an 'else' branch. Because 'if' is an expression, and not a statement, add an 'else' branch which also returns a value of type 'string'.

> if age >= 60 then printfn "senior";;
senior
val it: unit = ()

> let fare = if age < 5 then 0 elif age >= 60 then 40 else 100;;
val fare: int = 40

> let kind = if age >= 60 then "senior" else 0;;

  let kind = if age >= 60 then "senior" else 0;;
  -------------------------------------------^

stdin(5,44): error FS0001: All branches of an 'if' expression must return values implicitly convertible to the type of the first branch, which here is 'string'. This branch returns a value of type 'int'.

> #quit;;

The F# conditional expressions reference states both rules. An if…then…else produces the value of the branch that runs, so the types of the branches must match: "senior" in one branch and 0 in the other is error FS0001, all branches must return the type of the first. And when there is no else, the type of the whole if is unit, so the then branch must be unit too: if age >= 60 then printfn "senior" is fine, because printfn returns (), while the "senior" branch of label is not. The compiler’s own message gives the reason: if is an expression, not a statement. elif chains tests, as else if would; step through the fare for age 70:

The four forms of if in this section, side by side:

match tries its rules in order and checks that none is missing

match compares a value with each rule in turn and takes the first one that fits. This script prices tickets with an if chain and with a match, and prints both columns; the prompt then breaks three matches on purpose:

// One ticket-price rule written twice, as if/elif/else and as a match with guards. The prices are illustrative.
let priceWithIfs age isStudent =
    if age < 5 then 0
    elif age < 12 then 50
    elif age >= 60 then 60
    elif isStudent then 70
    else 100

let priceWithMatch age isStudent =
    match age, isStudent with
    | a, _ when a < 5 -> 0
    | a, _ when a < 12 -> 50
    | a, _ when a >= 60 -> 60
    | _, true -> 70
    | _, false -> 100

printfn "%-4s %-8s %4s %6s" "Age" "Student" "ifs" "match"

for age, student in [ 3, false; 9, false; 19, true; 35, false; 67, true ] do
    printfn "%-4d %-8b %4d %6d" age student (priceWithIfs age student) (priceWithMatch age student)

from session import fsi, run

# ticket.fsx prints both versions side by side; then a match with a rule missing, a rule out of order, and a match
# whose only rule for non-students has a guard.
run("""
dotnet fsi ticket.fsx
""")
fsi([
    'let describe n =\n    match n with\n    | 0 -> "none"\n    | 1 -> "one";;',
    "try describe 2 with e -> e.GetType().Name;;",
    'let describe2 n =\n    match n with\n    | _ -> "many"\n    | 0 -> "none";;',
    "let price2 age isStudent =\n    match age, isStudent with\n    | a, _ when a < 5 -> 0\n    | _, true -> 70;;",
    "#quit;;",
], args=["--nologo"])

$ dotnet fsi ticket.fsx
Age  Student   ifs  match
3    false       0      0
9    false      50     50
19   true       70     70
35   false     100    100
67   true       60     60
$ dotnet fsi --nologo
> let describe n =
-     match n with
-     | 0 -> "none"
-     | 1 -> "one";;

      match n with
  ----------^

stdin(2,11): warning FS0025: Incomplete pattern matches on this expression. For example, the value '2' may indicate a case not covered by the pattern(s).

val describe: n: int -> string

> try describe 2 with e -> e.GetType().Name;;
val it: string = "MatchFailureException"

> let describe2 n =
-     match n with
-     | _ -> "many"
-     | 0 -> "none";;

      | 0 -> "none";;
  ------^

stdin(9,7): warning FS0026: This rule will never be matched

val describe2: n: int -> string

> let price2 age isStudent =
-     match age, isStudent with
-     | a, _ when a < 5 -> 0
-     | _, true -> 70;;

      match age, isStudent with
  ----------^^^^^^^^^^^^^^

stdin(11,11): warning FS0025: Incomplete pattern matches on this expression. For example, the value '(_,false)' may indicate a case not covered by the pattern(s). However, a pattern rule with a 'when' clause might successfully match this value.

val price2: age: int -> isStudent: bool -> int

> #quit;;

Both columns agree on all five rows. The match reads its rules from the top, as the match expressions reference describes: it compares the value with each pattern in turn and returns the result of the first that fits. A guardguard: The when clause of a match rule, such as | a when a < 5 -> 0: a bool expression that must also be true for the rule to fit, evaluated only after the pattern has fitted., the when part, adds a condition that must hold too, and it is evaluated only when the pattern has fitted. Step through a student of 19:

The compiler checks the rules. describe has rules for 0 and 1 only, and warning FS0025 gave 2 as a value no rule covers; when describe 2 ran anyway, it raised MatchFailureException. describe2 puts the wildcard _ first, so the rule for 0 can never be reached, and warning FS0026 says so. price2 shows how guards count: the compiler cannot know whether a when clause holds, so it warned FS0025 for (_,false) while noting that a guarded rule might match it.

Loops run for their effect and have the type unit

F# has four loops, and each is an expression of type unit: it runs its body for its effect and produces (). These entries use all four:

from session import fsi

# The loops of F#, each an expression of type unit: for...in over a list and a range, for...to, for...downto and
# while; then a loop body that produces a value, and break.
fsi([
    "let names = [ \"Asha\"; \"Ravi\"; \"Meera\" ];;",
    'for name in names do printfn "Hello %s" name;;',
    'for i in 1 .. 3 do printfn "pass %d" i;;',
    'for i = 1 to 3 do printfn "up %d" i;;',
    'for i = 3 downto 1 do printfn "%d..." i;;',
    "let mutable tries = 0;;",
    "while tries < 3 do tries <- tries + 1;;",
    "tries;;",
    "let r = for i in 1 .. 2 do ();;",
    "for i in 1 .. 3 do i * 2;;",
    'for i in 1 .. 5 do\n    if i = 3 then break\n    printfn "%d" i;;',
    "#quit;;",
], args=["--nologo"])

$ dotnet fsi --nologo
> let names = [ "Asha"; "Ravi"; "Meera" ];;
val names: string list = ["Asha"; "Ravi"; "Meera"]

> for name in names do printfn "Hello %s" name;;
Hello Asha
Hello Ravi
Hello Meera
val it: unit = ()

> for i in 1 .. 3 do printfn "pass %d" i;;
pass 1
pass 2
pass 3
val it: unit = ()

> for i = 1 to 3 do printfn "up %d" i;;
up 1
up 2
up 3
val it: unit = ()

> for i = 3 downto 1 do printfn "%d..." i;;
3...
2...
1...
val it: unit = ()

> let mutable tries = 0;;
val mutable tries: int = 0

> while tries < 3 do tries <- tries + 1;;
val it: unit = ()

> tries;;
val it: int = 3

> let r = for i in 1 .. 2 do ();;
val r: unit = ()

> for i in 1 .. 3 do i * 2;;

  for i in 1 .. 3 do i * 2;;
  -------------------^^^^^

stdin(10,20): warning FS0020: The result of this expression has type 'int32' and is implicitly ignored. Consider using 'ignore' to discard this value explicitly, e.g. 'expr |> ignore', or 'let' to bind the result to a name, e.g. 'let result = expr'.

val it: unit = ()

> for i in 1 .. 5 do
-     if i = 3 then break
-     printfn "%d" i;;

      if i = 3 then break
  ------------------^^^^^

stdin(12,19): warning FS0046: The identifier 'break' is reserved for future use by F#


      if i = 3 then break
  ------------------^^^^^

stdin(12,19): error FS0039: The value or constructor 'break' is not defined.

> #quit;;

for name in names takes each item of a list, as C#’s foreach does, and works on any sequence, array or range. for i in 1 .. 3 loops over a range, for i = 1 to 3 counts up without one, and for i = 3 downto 1 counts down; both include their ends. while tries < 3 repeats while its test is true, so something the test reads must change in the body, here a let mutable value. let r = for … do () showed the loop’s own value: val r: unit = ().

A loop body that produces a value earns the same warning as any discarded result: for i in 1 .. 3 do i * 2 gave FS0020 for an int32, because the loop throws each product away. If you want the doubled values, ask for a list with [ for i in 1 .. 3 -> i * 2 ] or List.map, which a later lesson covers. The four loops at a glance:

F# has no break: search with recursion or List.tryFind

The usual reason for break is a search: stop at the first item that fits. Here is one search written three ways, the first train of the day that still has a seat:

// Open seats on each train of the day, in order of departure. Which is the first train with a seat?
let trains = [ "T101", 0; "T102", 0; "T205", 3; "T309", 12 ]

// 1. A while loop with a flag, the shape a C# loop with break takes in F#.
let firstWithWhile (all: (string * int) list) =
    let mutable i = 0
    let mutable found = None

    while found.IsNone && i < all.Length do
        let number, seats = all[i]
        if seats > 0 then found <- Some number
        i <- i + 1

    found

// 2. List.tryFind returns the first element for which the test is true, or None.
let firstWithTryFind all =
    all |> List.tryFind (fun (_, seats) -> seats > 0) |> Option.map fst

// 3. A recursive function: each call looks at one train and decides whether to go on.
let rec firstWithSeats all =
    match all with
    | [] -> None
    | (number, seats) :: _ when seats > 0 -> Some number
    | _ :: rest -> firstWithSeats rest

printfn "while with a flag: %A" (firstWithWhile trains)
printfn "List.tryFind:      %A" (firstWithTryFind trains)
printfn "recursion:         %A" (firstWithSeats trains)
printfn "all trains full:   %A" (firstWithSeats [ "T101", 0; "T102", 0 ])

from session import run

# The same search three ways, then on a day when every train is full.
run("""
dotnet fsi trains.fsx
""")

$ dotnet fsi trains.fsx
while with a flag: Some "T205"
List.tryFind:      Some "T205"
recursion:         Some "T205"
all trains full:   None

All three found Some "T205", and the recursive one returned None when every train was full. The while version needs two mutable values, an index and a flag, and the loop’s test must check both. List.tryFind says what is wanted in one line: its documentation describes it as returning the first element for which the function returns true, or None. The recursive function, a recursive functionA function that calls itself, declared with let rec. Each call handles one step of the work, such as one item of a list, and calls itself on what is left. declared with let rec, looks at one train and either answers or calls itself on the rest, so stopping is simply not calling itself again:

Use the List function when one exists for the job (List.tryFind, List.exists, List.takeWhile), recursion when the step is your own, and a while loop with a flag when the code must stay close to an imperative original.

Ranges build lists, arrays and sequences

A range is written start .. finish, or start .. step .. finish, inside the brackets of the collection you want:

from session import fsi

# Range expressions in lists, arrays and sequences: a step, a step down, an empty range, and the bare { } form that
# F# 10 deprecates.
fsi([
    "[ 1 .. 3 ];;",
    "[| 0 .. 2 .. 10 |];;",
    "[ 10 .. -3 .. 1 ];;",
    "[ 5 .. 1 ];;",
    "{ 1..3 };;",
    "seq { 1..3 };;",
    "seq { 1..3 } |> Seq.sum;;",
    "#quit;;",
], args=["--nologo"])

$ dotnet fsi --nologo
> [ 1 .. 3 ];;
val it: int list = [1; 2; 3]

> [| 0 .. 2 .. 10 |];;
val it: int array = [|0; 2; 4; 6; 8; 10|]

> [ 10 .. -3 .. 1 ];;
val it: int list = [10; 7; 4; 1]

> [ 5 .. 1 ];;
val it: int list = []

> { 1..3 };;

  { 1..3 };;
  ^^^^^^^^

stdin(5,1): warning FS3873: This construct is deprecated. Sequence expressions should be of the form 'seq { ... }'

val it: int seq = seq [1; 2; 3]

> seq { 1..3 };;
val it: int seq = seq [1; 2; 3]

> seq { 1..3 } |> Seq.sum;;
val it: int = 6

> #quit;;

[ 1 .. 3 ] is a list, [| 0 .. 2 .. 10 |] an array that steps by 2, and [ 10 .. -3 .. 1 ] counts down by 3, as the for…in reference describes for a negative step. A range expressionrange expression: start .. finish, or start .. step .. finish, inside [ ], [| |] or seq { }, which lists every value from start to finish: [ 1 .. 3 ] is [1; 2; 3], and a range whose finish is below its start is empty. whose finish comes before its start is simply empty: [ 5 .. 1 ] gave [], not an error.

The braces alone are on their way out. { 1..3 } still produced a sequence, but with warning FS3873: this construct is deprecated, and sequence expressions should be of the form seq { ... }. The What’s new page for F# 10 calls this a warning for now, and says that a future version may make it an error; seq { 1..3 } is the form to write. A sequence is lazy, computing its items only when something asks for them, as Seq.sum did here; the sequences lesson of this track covers what that means. FS3873 is the newest of several changes around loops, ranges and lists that you will meet when you read code written for older or newer versions of F#:

Practise: pay an amount in notes, as one expression

dispense pays an amount with notes of an illustrative set, 500, 200 and 100, largest first, or says why it cannot. Every branch of its if and every rule of its match returns a value, so it answers for every amount without an exception:

// Pays an amount with notes of an illustrative set, largest first, or says why it cannot. Every branch is an
// expression, so dispense returns a value for every amount and raises no exception.
let notes = [ 500; 200; 100 ]

let dispense (amount: int) : Result<(int * int) list, string> =
    if amount <= 0 then
        Error "the amount must be more than 0"
    elif amount % 100 <> 0 then
        Error "the amount must be a multiple of 100"
    else
        let rec pay remaining notesLeft =
            match notesLeft with
            | [] -> []
            | note :: rest ->
                let count = remaining / note
                let taken = if count > 0 then [ (note, count) ] else []
                taken @ pay (remaining - count * note) rest

        Ok(pay amount notes)

for amount in [ 3700; 600; 100; 0; -500; 250; 2_000_000 ] do
    match dispense amount with
    | Ok counts -> printfn "%9d -> %A" amount counts
    | Error why -> printfn "%9d -> refused: %s" amount why

from session import run

# dispense on amounts that work, the edge cases 0 and a negative amount, a non-multiple of 100 and a large amount.
run("""
dotnet fsi notes.fsx
""")

$ dotnet fsi notes.fsx
     3700 -> [(500, 7); (200, 1)]
      600 -> [(500, 1); (100, 1)]
      100 -> [(100, 1)]
        0 -> refused: the amount must be more than 0
     -500 -> refused: the amount must be more than 0
      250 -> refused: the amount must be a multiple of 100
  2000000 -> [(500, 4000)]

Result holds either Ok with the notes or Error with a message; the lesson on errors and validation of this track covers it in depth. 3,700 was paid as seven 500s and one 200, 0 and -500 were refused by the first test, 250 by the second, and two million came out as 4,000 notes of 500. The inner pay is recursive: each call takes as many notes of one value as fit, then calls itself with the amount that remains and the smaller notes.

Now check the five ideas of the lesson. The practice keeps track of which ones your answers show you know, asks about the weakest first, and explains every choice once you pick it:

Interview questions

Warm-up (fresher to 2–5 years): why must every branch of an F# if/then/else have the same type, and what happens without an else?

In F#, if…then…else is an expression: it produces the value of the branch that runs, so the compiler must know one type for the whole if, and every branch must have it. if age >= 60 then "senior" else 0 is error FS0001, because the first branch makes it a string. Without an else the if has no value when the test is false, so its type is unit and the then branch must be unit as well: if ok then printfn "x" compiles, while let label = if ok then "senior" is error FS0001, whose message asks for an else branch of type string. The same rule makes match safe: every rule returns the same type, and the compiler warns FS0025 when a value has no rule.

Two harder questions follow, about porting a loop with break and about a wildcard that hid a new case:

Key takeaways

• if…then…else has the value of the branch that runs, so every branch has one type; without else the if is unit, and a branch with a value is error FS0001.
• match takes the first rule that fits, guards add conditions, FS0025 reports a value no rule covers and FS0026 a rule that can never be reached.
• for…in, for…to, for…downto and while are expressions of type unit; F# has no break or continue, and a body that produces a value earns FS0020.
• A search stops by returning: use List.tryFind and its relatives, or a recursive function, instead of a loop with a flag.
• Ranges such as [ 1 .. 3 ] and [| 0 .. 2 .. 10 |] build collections; a bare { 1..3 } warns FS3873 in F# 10, so write seq { 1..3 }.