F# Exception Handling

As a developer using F# exception handling is an important aspect of writing robust code. Exception handling allows you to gracefully handle unexpected errors and exceptions that may occur during the execution of your program.

In this article, we will explore the best practices of F# exception handling and provide tips on raising and catching exceptions, handling different types of exceptions, and best practices when it comes to writing exception handling code that is efficient, maintainable, and effective.

Understanding Exceptions in F#

In F# exceptions are raised when an error occurs during the execution of a program.

An exception is a runtime event that disrupts the normal flow of program execution and can occur for various reasons, such as invalid input, unexpected behavior, or unexpected state.

When an exception is raised, the normal flow of the program is interrupted, and the runtime searches for an exception handler that can handle the exception. If an appropriate exception handler is not found, the program terminates.

The concept of an exception is the term used to describe a problem that occurs when a program is being executed. F# exceptions are raised when a program is being run when an exceptional circumstance arises during the execution of the program, such as dividing by zero when the program is running.

The use of exceptions provides a method by which one part of the program can transfer control to another part.

The following constructs are available for handling exceptions in F#:

raise exprThe given exception is raised.
failwith exprThe exception System.Exception is raised.
try expr with rulesCatch the matching expressions according to the pattern rules.
try expr finally exprThe final expression is set to be executed both in the event of a successful computation as well as in the event of an exception.
| 😕 ArgumentExceptionAn exception rule that matches the type of exception specified by the .NET framework.
| 😕 ArgumentException as eThe rule binds the name “e” to the object value of an exception object that matches the given .NET exception type.
| Failure(msg) → exprA rule that matches a data-carrying F# exception that has been given.
| exn → exprAn exception rule that matches any exception, and binds the name exn to the exception object value of that exception.
| exn when expr → exprAn exception match rule that binds the name exn to the value of the exception object under the given conditions.

In order to understand how Exception Handling works, let us begin with the basic syntax.


In F#, the syntax for handling exceptions is as follows:

exception exception-type of argument-type


  • exception-type introduces a new type of exception in F#.
  • argument-type this type can be specified by argument-type when raising an exception.
  • Tuples can be used for argument-type when multiple arguments are needed.

F# uses the try…with expression for handling exceptions.

Here is the syntax for a try … with expression:

   | pattern1 -> expression2
   | pattern2 -> expression3

The try…finally expression can be used to execute clean-up code even if an exception is thrown by a block of code in the middle of the block.

Try … finally is expressed using the following syntax:


When an error or exceptional condition occurs, the raise function is used to notify the user. As part of the exception object, information about the error is also captured.

The syntax for the raise function can be summarized as follows:

raise (expression)

F# exceptions are generated by the failwith function.

Its syntax is as follows:

failwith error-message-string

An argument exception is generated by the invalidArg function.

invalidArg parameter-name error-message-string

Divide By Zero Exception


This program shows how to handle exceptions with a simple try… with block:let division a b = try Some (a / b) with | 😕 System.DivideByZeroException -> printfn "Division by zero!"; Nonelet result = division 220 0

When compiling the program, it prints the following:

FABLE: Cannot type test (evals to false): System.DivideByZeroException

Type Error

Exceptions can be declared using F#’s exception type. Exception types can be directly used in filters in a try…with expression.
Here is an example:


exception Err1 of string // Using a tuple type as the argument type. exception Err2 of string * intlet compare a b = try if a = b then raise (Err1("Equal Number Error")) else raise (Err2("Error Not detected", 100)) with | Err1(str) -> printfn "Error1 %s" str | Err2(str, i) -> printfn "Error2 %s %d" str i compare 7 7 compare 22 14

And the output will be as follows:

Error1 Equal Number Error
Error2 Error Not detected 22

Nested Exception handling

This example illustrates how to handle nested exceptions in the following way:


let divideAndLog x y = try // Outer try block let result = x / y printfn "Result: %d" result try // Inner try block if result = 0 then raise (System.DivideByZeroException()) else printfn "No exception in inner try block" with | ex -> printfn "Inner exception: %s" ex.Message raise ex // re-raise the exception with | ex -> printfn "Outer exception: %s" ex.MessagedivideAndLog 10 2 divideAndLog 10 0

Prints out the following output:

Result: 5
No exception in inner try block
Outer exception: Attempted to divide by zero.

Failwith Function

Below is an example that greets the user if their name matches, otherwise it will throw an exception:


let greetPerson name = match name with | "John" -> printfn "Hello, John! How are you?" | "Ben" -> printfn "Hello, Ben! How are you?" | _ -> failwith "Unknown person" try greetPerson "Alice" with | ex -> printfn "Caught exception: %s" ex.Message

And the output will be:

Caught exception: Unknown person

invalidArg Exception

InvalidArg generates an exception when it encounters an invalid argument. This can be demonstrated by the following program:


let days = [| "Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday" |] let findDay day = if (day > 7 || day < 1) then invalidArg "day" (sprintf "You have entered %d." day) days.[day – 1] printfn "%s" (findDay 3) printfn "%s" (findDay 6) printfn "%s" (findDay 8)

And the result will be:


Unhandled Exception:
System.ArgumentException: You have entered 8.
Parameter name: day
  at Main.findDay (System.Int32 day) [0x00028] in <643d27b54fc9e525a7450383b5273d64>:0 
  at <StartupCode$main>.$Main.main@ () [0x000d1] in <643d27b54fc9e525a7450383b5273d64>:0 
[ERROR] FATAL UNHANDLED EXCEPTION: System.ArgumentException: You have entered 8.
Parameter name: day
  at Main.findDay (System.Int32 day) [0x00028] in <643d27b54fc9e525a7450383b5273d64>:0 
  at <StartupCode$main>.$Main.main@ () [0x000d1] in <643d27b54fc9e525a7450383b5273d64>:0

Example Explanation:

We have a list of days called days with elements representing the names of the days of the week. We also have a function called findDay that takes an integer argument day, which represents the day of the week (1 for Sunday, 2 for Monday, and so on).

Inside the findDay function, we first check if the day value is greater than 7 or less than 1 using an if statement. If it is, we use the invalidArg function to raise an exception with the error message “You have entered x.” where x is the value of day formatted as a string using the sprintf function.

Otherwise, if day is a valid value between 1 and 7, we use the days array to look up the corresponding day name using the days.[day – 1] indexing syntax, where day – 1 is used to convert the day value to the zero-based index of the array.

Finally, we print the day name returned by the findDay function for three different day values (3, 6, and 8) using printfn statements.

Note that the findDay function may raise an exception if an invalid day value is passed, and this exception can be caught and handled using appropriate error handling techniques such as a try-with block.

You can help others learn about the power and flexible nature of F# exception handling by sharing our article on social media below. This will enable them to create dynamic and interactive applications.

F# Exception Best Practices

To write robust code in F#, it’s important to follow best practices for exception handling.

Here are some guidelines to keep in mind when handling exceptions in your F# code:

  • It’s generally not recommended to catch generic exceptions, such as System.Exception, as it can make it difficult to identify and fix issues in your code. Instead, catch specific exceptions that you expect to be raised and handle them accordingly. This allows you to provide meaningful error messages and take appropriate actions based on the specific exception that occurred.
  • Exception handling code should be concise and focused on handling the exception at hand. Avoid adding unnecessary logic or complex operations in the exception handling code, as it can make it harder to understand and maintain. Keep the code in the with block minimal and focused on handling the exception and providing appropriate feedback to the user.
  • Swallowing exceptions, which means catching an exception and not taking any action, can hide potential issues in your code and make it harder to diagnose and fix problems. Instead of simply ignoring exceptions, consider logging them or displaying appropriate error messages to alert users about the issue.
  • F# provides powerful pattern matching capabilities that can be used to handle different types of exceptions differently. You can use pattern matching to match on exception types, properties, or custom data associated with the exception. This allows you to provide tailored error handling based on the specific exception that occurred.
  • In some cases, using result types, such as Result <‘T, ‘TError>, can be a more functional way to handle errors in F# code. Result types allow you to explicitly represent success and failure cases in the return values of functions, without using exceptions. This can lead to more predictable and easier-to-understand code, especially in functional programming paradigms.


F# Exception handling is a critical aspect of writing robust and reliable code. By following best practices for exception handling, such as being specific in catching exceptions, keeping exception handling code focused, avoiding swallowing exceptions, using pattern matching, considering result types, handling exceptions at appropriate levels of abstraction, and using logging and monitoring for error tracking, you can effectively handle exceptions and build more resilient and stable applications. Remember to thoroughly test your exception handling code to ensure its correctness. With careful exception handling, you can improve the stability and reliability of your F# code, providing a better experience for your users and making your applications more robust.

We value your feedback.

Subscribe To Our Newsletter
Enter your email to receive a weekly round-up of our best posts. Learn more!

Leave a Reply

Your email address will not be published. Required fields are marked *