The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Discriminated Unions

Next ►
►

Discriminated Unions (DUs) are a powerful feature in F# that allow you to define a type that can be one of several named cases, each potentially with different values and types. They are particularly useful for modeling data that can take on a limited set of distinct forms.

Key Concepts

  1. Definition: A Discriminated Union is defined using the type keyword followed by the union name and the possible cases.
  2. Cases: Each case can have associated data, which can be of different types.
  3. Pattern Matching: DUs are often used with pattern matching to handle the different cases.

Defining Discriminated Unions

Here is a basic example of a Discriminated Union:

type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float
    | Triangle of base: float * height: float

In this example:

  • Shape is the name of the Discriminated Union.
  • Circle, Rectangle, and Triangle are the cases.
  • Each case has associated data (e.g., radius for Circle).

Using Discriminated Unions

Creating Instances

You can create instances of a Discriminated Union by specifying the case and providing the necessary data:

let myCircle = Circle(5.0)
let myRectangle = Rectangle(4.0, 6.0)
let myTriangle = Triangle(3.0, 4.0)

Pattern Matching

Pattern matching is a powerful way to work with Discriminated Unions. It allows you to deconstruct the union and handle each case separately:

let describeShape shape =
    match shape with
    | Circle(radius) -> sprintf "A circle with radius %f" radius
    | Rectangle(width, height) -> sprintf "A rectangle with width %f and height %f" width height
    | Triangle(base, height) -> sprintf "A triangle with base %f and height %f" base height

let description = describeShape myCircle
printfn "%s" description  // Output: A circle with radius 5.000000

Practical Example

Let's consider a more practical example where we use a Discriminated Union to represent a simple command-line interface (CLI) command:

type Command =
    | Print of message: string
    | Add of x: int * y: int
    | Exit

let executeCommand command =
    match command with
    | Print(message) -> printfn "%s" message
    | Add(x, y) -> printfn "Sum: %d" (x + y)
    | Exit -> printfn "Exiting..."

let commands = [ Print("Hello, World!"); Add(3, 4); Exit ]

commands |> List.iter executeCommand

In this example:

  • Command is a Discriminated Union with three cases: Print, Add, and Exit.
  • executeCommand is a function that pattern matches on the Command type and performs the appropriate action.

Exercises

Exercise 1: Define a Discriminated Union

Define a Discriminated Union called Result that can represent either a success with a value or a failure with an error message.

type Result<'T> =
    | Success of value: 'T
    | Failure of error: string

Exercise 2: Pattern Matching with Result

Write a function handleResult that takes a Result<int> and prints a message based on whether it is a success or a failure.

let handleResult result =
    match result with
    | Success(value) -> printfn "Success with value: %d" value
    | Failure(error) -> printfn "Failure with error: %s" error

let result1 = Success(42)
let result2 = Failure("Something went wrong")

handleResult result1  // Output: Success with value: 42
handleResult result2  // Output: Failure with error: Something went wrong

Common Mistakes and Tips

  • Forgetting to handle all cases: When pattern matching, ensure you handle all possible cases of the Discriminated Union to avoid runtime errors.
  • Using meaningful names: Use descriptive names for cases and associated data to make your code more readable.
  • Leveraging pattern matching: Take full advantage of pattern matching to simplify your code and make it more expressive.

Conclusion

Discriminated Unions are a versatile and powerful feature in F# that allow you to model complex data structures in a clear and concise way. By understanding how to define and use DUs, and leveraging pattern matching, you can write more robust and maintainable code. In the next topic, we will explore the Option and Result types, which are special cases of Discriminated Unions commonly used for error handling and optional values.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved