F# 9: Nullable Reference Types and Advancing Null Safety

Handling null values has been a constant challenge in software development, ever since Tony Hoare referred to it as his “billion-dollar mistake.” Despite its risks, null has remained an integral part of languages like C# and Java. F# has historically stood out for its approach to eliminating null in idiomatic development, offering a safer experience for developers.

With the release of F# 9, the introduction of Nullable Reference Types (NRTs) marks a milestone in F#’s interoperability with other languages like C#, which introduced similar features in C# 8. In this article, we’ll explore how Nullable Reference Types work in F#, their impact on writing safer code, and their benefits in interoperability scenarios.

---

The Legacy of Null in F#

From its initial version, F# avoided the use of null in its idiomatic core. Fundamental language constructs like records, discriminated unions, and tuples did not allow assignment of null values. For example:

type Person = { Name : string }
type Vehicle = Car | Bike
type TwoStrings = string * string

let x : Person = null  // Error: 'null' is not a valid value for this type.
let y : Vehicle = null // Similar error.

This design ensured that developers avoided common issues like NullReferenceException. However, in interoperability scenarios with C# or JavaScript, where null is common, F# had to handle such cases explicitly.

For these cases, developers could use attributes like [<AllowNullLiteral>], which allowed assignment of null values to specific types:

[<AllowNullLiteral>]
type NullablePerson = { Name : string }

let x : NullablePerson = null // Allowed due to the attribute.

Despite these tools, the use of null in F# remained limited to specific interactions, as the language primarily focused on safer alternatives like the option type.

---

What Are Nullable Reference Types in F# 9?

In F# 9, Nullable Reference Types take null safety to the next level, especially in interoperability scenarios. This feature allows developers to distinguish between reference types that can be null and those that cannot. The compiler generates warnings when potentially nullable values are used without proper handling.

For example:

let x : string | null = null

let handleString (s: string | null) =
    match s with
    | null -> "No value"
    | value -> value.ToUpper() // `value` is guaranteed to be non-null here.

The | null suffix explicitly introduces nullability into types, helping the compiler identify potential risks and alerting developers to possible issues.

---

How to Enable Nullable Reference Types

By default, Nullable Reference Types are disabled in F# 9. To enable them, include the following property in your project file:

<Nullable>enable</Nullable>

This activates a series of compiler checks and allows the use of the | null suffix. Additionally, it sets a #if NULLABLE preprocessor directive, which is useful for gradual migrations.

---

Syntax Additions

In projects with Nullable enabled, reference types are non-nullable by default. To explicitly declare types that allow null, use the following notation:

type NullableField = { Name: string | null }
type NestedNullable = List<string | null> | null

This notation can be used in:

• Fields of records or unions.
• Type aliases.
• Function parameters and return values.

For example:

type Person = { Name: string | null; Age: int }
let createPerson (name: string | null) = { Name = name; Age = 30 }

---

Key Benefits of Nullable Reference Types

1. Improved Interoperability with C# Nullability annotations in F# are reflected in compiled .dll files, allowing C# consumers to distinguish between nullable and non-nullable types.

type Example = { Name: string | null }

This code generates metadata that C# can interpret correctly, enhancing interoperability in mixed projects.

2. Detailed Compiler Warnings The compiler issues warnings when:

An instance member is accessed on a nullable type.

A null value is passed to a non-nullable parameter.

Redundant patterns are used to check non-nullable values.

3. Support for Gradual Migration During the migration of an existing codebase, you can use custom aliases to handle nullable types:

type NullString = string | null
let handleNullable (s: NullString) = Option.ofObj s

---

Practical Examples

Active Patterns for Null Handling:

Active patterns make it easier to handle null values in complex combinations:

type AB = A | B of string | null

let handleUnion ab =
    match ab with
    | A -> "No value"
    | B Null -> "Null value"
    | B (NonNull value) -> value.ToUpper()

Argument Validation:

F# 9 introduces functions like nullArgCheck and nonNull to validate arguments at the start of a function:

let validateArgument (arg: string | null) =
    let arg = nullArgCheck (nameof arg) arg
    arg.Length // `arg` is now non-null.

---

Limitations and Considerations

1. Flow Analysis Compatibility F# does not implement flow analysis to eliminate nullability in constructs like if or while conditions, unlike C#. This requires rewriting certain patterns to use match or active patterns.
2. Combining Nullability with Value Types The compiler generates errors if you attempt to combine | null with value types like int. For such cases, Option is recommended.
3. Gradual Migration While Nullable Reference Types are a powerful addition, their adoption requires careful planning, especially in large projects with external dependencies.

---

Conclusion

Nullable Reference Types in F# 9 are a fundamental tool for writing safer and more robust code, particularly in interoperability scenarios with languages like C#. Their ability to distinguish between nullable and non-nullable types helps identify potential errors at compile time and reduces risks in production.

Although their adoption involves certain adjustments to existing codebases, the benefits in clarity, safety, and compatibility with other languages make exploring this feature worthwhile. Enable them in your next project and experience how F# continues to lead the way toward more reliable software development.