F# Relational Operators

Functional programming languages have gained significant popularity in recent years, and F# is no exception. F# is a powerful, functional-first language that runs on the .NET platform, making it an excellent choice for developing robust and scalable applications. One essential aspect of programming in F# is understanding and effectively using relational operators, which are essential for comparing values and making decisions in your code.

What are Relational Operators?

Relational operators are symbols or keywords used in programming languages to compare values and determine the relationship between them. F# provides a set of relational operators that allow you to perform various comparisons between different types of data. These operators are fundamental for controlling the flow of your program and making decisions based on conditions. They evaluate to a boolean result, indicating whether the comparison is true or false. F# supports a variety of relational operators, each serving a specific purpose in comparing different types of values. These operators include:

Equality and Inequality Operators (= and <>)

The equality operator (=) checks if two values are equal, while the inequality operator (<>) checks if two values are not equal. Let’s explore these concepts with some code examples:

[<EntryPoint>]
let main(args: string[]): int =

    let a: int = 5
    let b: int = 5
    let c: int = 3
    
    let isEqual: bool = a = b // true
    printfn "%d equal to %d: %b" a b isEqual
    
    let isNotEqual: bool = a <> c // true
    printfn "%d not equal to %d: %b" a c isNotEqual
    
    0 // Return exit code 0 to indicate successful execution

In the above example, isEqual evaluates to true because 5 is equal to 5, while isNotEqual evaluates to true because 5 is not equal to 3.

Less Than and Greater Than Operators (< and >)

The less than operator (<) checks if the left operand is less than the right operand, while the greater than operator (>) checks if the left operand is greater than the right operand. Here’s how these operators work in practice:

[<EntryPoint>]
let main(args: string[]): int =

    let a: int = 3
    let b: int = 5
    let c: int = 2
    
    let isLessThan: bool = a < b // true
    printfn "%d less than %d: %b" a b isLessThan
    
    let isGreaterThan: bool = a > c // true
    printfn "%d greater than %d: %b" a c isGreaterThan
    
    0 // Return exit code 0 to indicate successful execution

In this example, isLessThan evaluates to true because 3 is less than 5, and isGreaterThan evaluates to true because 3 is greater than 2.

Less Than or Equal To and Greater Than or Equal To Operators (<= and >=)

The less than or equal to operator (<=) checks if the left operand is less than or equal to the right operand, while the greater than or equal to operator (>=) checks if the left operand is greater than or equal to the right operand:

[<EntryPoint>]
let main(args: string[]): int =

    let a: int = 5
    let b: int = 5
    let c: int = 3
    
    let isLessThanOrEqualTo: bool = a <= b // true
    printfn "%d less than or equal to %d: %b" a b isLessThanOrEqualTo
    
    let isGreaterThanOrEqualTo: bool = a >= c // true
    printfn "%d greater than or equal to %d: %b" a c isGreaterThanOrEqualTo
    
    0 // Return exit code 0 to indicate successful execution

Here, isLessThanOrEqualTo evaluates to true because 5 is equal to 5, and isGreaterThanOrEqualTo evaluates to true because 5 is greater than 3.

Relational Operators in Conditional Statements

Relational operators are commonly used in conditional statements, where decisions are made based on the comparison of values. Let’s consider an example where we use these operators in an if statement:

let compareNumbers (x: int) (y: int) =

    if x < y then
      printfn "%d is less than %d" x y
      
    elif x = y then
      printfn "%d is equal to %d" x y
      
    else
      printfn "%d is greater than %d" x y

[<EntryPoint>]
let main(args: string[]): int =

    let a: int = 4
    let b: int = 7
    
    // Compare a and b
    compareNumbers a b
    
    0 // Return exit code 0 to indicate successful execution

In this example, the compareNumbers function takes two parameters (x and y) and uses the less than (<) and equality (=) operators to determine the relationship between the two numbers. The function then prints a message based on the result.

Relational Operators with Different Data Types

F# is a statically typed language, and its type system allows for expressive and concise code. When working with relational operators, it’s essential to consider how they behave with different data types.

Numeric Types

Relational operators work seamlessly with numeric types, including integers and floating-point numbers. Here’s an example:

let compareFloats (x: float) (y: float) =

    if x < y then
        printfn "%.2f is less than %.2f" x y
        
    elif x = y then
        printfn "%.2f is equal to %.2f" x y
        
    else
        printfn "%.2f is greater than %.2f" x y


[<EntryPoint>]
let main(args: string[]): int =

    compareFloats 3.5 2.0
    compareFloats 1.0 1.0
    compareFloats 4.5 5.2
    
    0 // Return exit code 0 to indicate successful execution

In this case, the compareFloats function compares two floating-point numbers using the less than (<) and equality (=) operators.

String Type

Relational operators can also be applied to strings. When used with strings, these operators compare the lexicographical order of the strings:

let compareStrings (str1: string) (str2: string) =

    if str1 < str2 then
        printfn "%s comes before %s" str1 str2
        
    elif str1 = str2 then
        printfn "%s is equal to %s" str1 str2
        
    else
        printfn "%s comes after %s" str1 str2

[<EntryPoint>]
let main(args: string[]): int =

    compareStrings "Apple" "Banana"
    compareStrings "Edward" "Cherish"
    
    0 // Return exit code 0 to indicate successful execution

In this example, the compareStrings function compares two strings based on their lexicographical order.

Custom Types and Operator Overloading

F# allows you to define custom types and overload operators for those types. This capability enhances the language’s flexibility and expressiveness. Let’s create a simple example to illustrate operator overloading:

// Define a record type Point representing a point in a 2D space with X and Y coordinates.
type Point = { X: int; Y: int }

// Overload the <= operator for the Point record
// This operator checks if the X and Y coordinates of p1 are less than or equal to those of p2.
// For other relational operators, replace the <= operator with the desired operator.
let (<=) (p1: Point) (p2: Point) =
    p1.X <= p2.X && p1.Y <= p2.Y

[<EntryPoint>]
let main(args: string[]): int =

    // Create two Point instances
    let point1: Point = { X = 3; Y = 5 }
    let point2: Point = { X = 7; Y = 8 }
    
    // Check if point1 is less than or equal to point2 using the overloaded <= operator
    if point1 <= point2 then
        printfn "point1 is less than or equal to point2"
        
    else
        printfn "point1 is greater than point2"

    0 // Return exit code 0 to indicate successful execution

In this example, we define a custom type Point representing a point in a 2D space. We then overload the <= operator to compare two Point instances based on their X and Y coordinates.

Conclusion

Relational operators are fundamental tools in programming languages, enabling developers to compare values and make decisions based on those comparisons. In F#, the set of relational operators provides a concise and expressive way to handle different types of comparisons.

Throughout this article, we explored the standard F# relational operators, their usage with various data types, and even touched on the ability to overload operators for custom types.