Recently I've been learning how to write code in F#. For those who haven't heard of it, F# is Microsoft's/.NET's answer to a functional-first programming language. My motivation was to learn a functional programming language that would make coding for scientific computing and data analysis more expressive, concise, and maintainable, all while fitting seamlessly into the .NET ecosystem that I already know and love. F# fits that bill perfectly. Why Functional Programming? For an object oriented programmer, the idea of functional programming can be a little foreign at first. We're used to applications in which everything is an object and the application works by changing the state of those objects (mutation) over time. In contrast, functional programs consist of values and functions, and the application works by applying these functions to values in order to produce new values. This might sound similar to methods in an object oriented style, but there are two key differences: 1. Values cannot be modified (they are said to be immutable). Instead, operations create and return new values. 2. Functions should be pure, meaning that a given input always produces the same output. This is in contrast to a class method, in which some internal state of the class might have an effect on the output of the method. Let's have a look at this in a code example, in which we want to raise an employee's salary by a given factor: { Name { ; ; } Salary { ; ; }
} { Factor { ; ; } { raise = employee.Salary * Factor; employee.Salary += raise;
	}
} employee = Employee { Name = , Salary = }; raiser = SalaryRaiser { Factor = };
raiser.RaiseSalary(employee); // C# Object Oriented Example public class Employee public string get set public float get set public class SalaryRaiser public float get set ( ) public void RaiseSalary Employee employee // function not pure - depends on Factor, which isn't a parameter var // employee object is mutated directly var new "Bob" 12345.67F var new 0.05F = { Name: string; Salary: float } factor = calculateSalary employee factor = raise = employee.Salary * factor { employee Salary = employee.Salary + raise } employee = { Name = ; Salary = } updatedEmployee = calculateSalary employee factor // F# Functional Example type Employee let 0.05 let // function is pure - factor is now a parameter let // new employee record returned with let "Bob" 12345.67 let The key benefits of these functional features (immutability and pure functions) is that they make your code much more maintainable and testable, since you can be sure that values aren't accidentally being mutated (also known as side-effects) and that a given function will always behave the same for a given input. Data Types in F# In F# data types are static and strongly typed, meaning that they are determined at compile time and a given value cannot change it's type. This will be familiar to C# programmers. However, there are some slight differences that may take some getting used to: F# has a powerful type inference system meaning that you hardly ever have to explicitly state what the type is - it is inferred from context { a + b;
} = AddInt( , ) // C# ( ) public int AddInt a, b int int return var value 1 2 addInt x y = x + y value = addInt // F# let let 1 2 F# expects explicit conversion between types { a + b;
} a = ; b = ; = AddFloat(a, b); // C# ( ) public float AddFloat a, b float float return int 1 int 2 var value // ints are implicitly converted to floats addFloat a:float b:float = a + b value = addFloat a = float b = float value = addFloat a b // F# let // for the purpose of the example, explictly state the a and b must be floats let 1 2 // will throw exception since 1 and 2 are ints // instead let 1 let 2 let Other than this, F# contains all of the primitive data types that you will be used to in C# and many other languages. Collections Lists Lists in F# are similar to those in C#, except that (because they are immutable) methods like Add/Remove do not exist. Instead, to perform the equivalent operations, new lists must be created from the existing list. list = [ ; ; ] list = [ ] list = [ ; ; ] list2 = ::list list = [ ; ; ] list2 = list.[ ] // 1. Declare a list let 1 2 3 // creates a list with the elements 1, 2 and 3 // 2. Declare a list using range syntax let 1. .5 // create a list with the element 1, 2, 3, 4, and 5 // 3. Add an element to the start of a list let 1 2 3 let 4 // create a list [4;1;2;3] // 4. Remove elements from the list let 1 2 3 let 0. .1 // returns a list containing the elements between index 0 and 1. Equivalent to removing the index 3 Sequences Sequences are similar to lists, except they are lazily evaluated, meaning that the element values are not loaded in to memory until needed. This is useful for dealing with very large sequences. An equivalent very long list has to have all elements stored in memory simulataneously and may even crash your PC! list = [ ] sequence = seq { } // large list // WARNING: may crash your pc let 1. .1000000 // create a list containing 1 million elements // large sequence let 1. .1000000 Tuples The collections we have looked at previously must contain data all with the same data type (i.e. a list of ints). A tuple is different in that it contain contain multiple values each with different data types. myTuple = ( , ) myTuple = ( , ) (num, str) = myTuple // 1. declare a tuple let 1 "hello" // 2. destructure a tuple let 1 "hello" let // assigns num the value 1, and str the value "hello" Records Records group data into distinct objects, similar to classes. Records can even have method. However, as with most things in F#, records are immutable, so 'editing' a record requires you to create a new record from the existing one. = {
    Name: string; 
    Age: int;
} this.IsAdult = this.Age >= sam = { Name = ; Age = } olderSam = { sam Age = } // 1. Declare a record type with a method type Person with member 18 // 2. Create a record // Note that we don't need to tell the compiler that this is a Person record // It can infer it from the fields we provide let "Sam" 27 // 3. Create a record based on an existing one let with 28 Discriminated Unions Discriminated unions are a powerful feature in F# and may not be familiar to a lot of programmers - they certainly weren't to me! Discriminated unions allow values to be one of a number of named cases, each with potentially different types and values. This is probably shown that explained: = Active | Inactive myStatus = Status.Active = 
    | Rectangle width:float * length:float | Circle radius:float cir = Circle rect = Rectangle( , ) // 1. Basic discriminated union // this declares a Status type, that can have the value Active or Inactive type Status let // 2. A more complex example type Shape of // takes a tuple of two floats of // takes a float // both have the Shape type let 5. let 5. 6. Pattern Matching Pattern matching is very common in F# and is a way of controlling the flow of the application based on the match input value. It can be likened to using if..else statements in this manner, and if statements do exist in F#, but pattern matching is far more idiomatic (and hopefully you'll agree, more powerful). = Active | Inactive isActive status = status | Active -> | Inactive -> =
    | Error string
    | Data int handle result = result | Data data -> printfn data
    | Error error -> printfn error matchPoint point = point | ( , ) -> printfn | (x, ) -> printfn x
    | ( , y) -> printfn y
    | _ -> printfn // 1. Pattern matching a discriminated union type Status // return true if Active, return false if inactive let match with true false // 2. Pattern matching to handle errors type Result of of // handle printing data or error cases to the console let match with "My result: %i" "An error ocurred: %s" //3. Pattern matching tuple values let match with 0 0 "This is the origin" 0 "X is %i, while Y is 0" 0 "Y is %i, while X is 0" "Both values are non-zero" // _ is a catch all case Some Functional Concepts Currying and Partial Application A pure function can only have one input and one output, and this is true for functions in F# as well. However, we've already seen some functions with apparently multiple parameters. For example: addInt x y = x + y

addInt let 5 6 // evaluates to 11 Well, behind the scenes, F# is actually taking this declaration and splitting it into two separate functions, each with only one parameter. Something along the lines of: addInt x  = subFunction y = x + y
    subFunction intermediate = addInt intermediate let let let 5 // evaluates to a function that adds five to its parameter 6 // evaluates to 11 This process of taking a multi-parameter function and splitting it into a pipeline of single parameter functions is called currying. This is all well and good, but what is the practical benefit for us? Well one of the interesting consequences is something called partial application. Going back to our AddInt function in C#. It has two parameters, and you can only ever call it with two parameters. Calling it with one parameter will just lead to a compiler error. However, if we call our addInt function in F# with just one parameter, something interesting happens. It returns a function that has our first parameter baked in! This is known as partial application, and is a highly useful concept for creating reusable pieces of code. addInt x y = x + y add5 = addInt add5 add5 let let 5 // partially apply addInt to create a new function that adds 5 to the input 6 // evaluates to 11 7 //evaluates to 12 Piping Piping is a special type of operator that allows you to put the parameter to the function before the function. For example: addInt x y = x + y add5 = |> addInt let let 5 // pipe 5 into the addInt function Its use may not seem immediately obvious , but it is highly useful for creating pipelines of functions, in which the output of one function feeds directly into the input of another. [ ; ; ] |> List.map ( x -> x + ) |> List.filter ( x -> x > ) 1 2 3 // create a list fun 1 // add 1 to each element of the list fun 2 // only return elements that have a value greater than 2 (returns [3; 4]) Note that the expressions prefixed by `fun` above are simply lambda expressions (or anonymous functions) as you would see in many other languages. Composition Composition is the act of joining multiple functions together to create a single new function. This can seem pretty much the same as piping at first glance, but it is subtly different: a pipe has to start with a value and is immediately evaluated to give an output; function composition joins multiple functions together and returns that new function (i.e. nothing is evaluated at this stage). add5 = (+) double = // Example comparing piping and composition let 5 let (*) 2

// piping
5
|> add5
|> double // evaluates to 20

// composition
let add5ThenDouble = add5 >> double // compose into a new function

add5ThenDouble 5 // evaluates to 20 Conclusion This has been my brief introduction into F# for Object Oriented Programmers. The topics I have covered are by no means exhaustive, but hopefully it is enough to whet your appetite for F# and functional programming. For more resources is an excellent website and will help you dive deeper into the language. F# For Fun and Profit I post mostly about full stack .NET and Vue web development (and soon maybe some more F# content!). To make sure that you don't miss out on any posts, please follow this blog and . If you found this post helpful, please like it and share it. You can also find me on . subscribe to my newsletter Twitter Previously published here .

Flow

Microsoft

Twitter

What is Primitive Obsession and How Can we Fix it?

How to Use The Vue Draggable Library to Create an Interactive Kanban Board

Subscribe to my mailing list

Nominated for 2022 - HackerNoon Contributor of the Year - Es6

Nominated for 2022 - HackerNoon Contributor of the Year - Clean Code

Nominated for 2022 - HackerNoon Contributor of the Year - Dotnet

Nominated for 2022 - HackerNoon Contributor of the Year - Functional Programming

Too Long; Didn't Read

An Introduction to F# as Microsoft's / .NET's Answer to a Functional-First Programming Language

An Introduction to F# as Microsoft's / .NET's Answer to a Functional-First Programming Language

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

3 Tips to Improve Your Mental Health as a Developer

111 Stories To Learn About Csharp

130 Stories To Learn About Dotnet

C# 8.0 Indices and Ranges

3 Insanely Easy Changes You Can Make To Clean Up Your Code

5 Performance Tips For .Net Developers

3 Tips to Improve Your Mental Health as a Developer

111 Stories To Learn About Csharp

130 Stories To Learn About Dotnet

C# 8.0 Indices and Ranges

3 Insanely Easy Changes You Can Make To Clean Up Your Code

5 Performance Tips For .Net Developers

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps