# Functional Programming made easy in C# with Language-ext
In the title I have written FP and C# but the question you probably wonder is :
> What the hell should we want to use FP paradigms in an OO language like C# ?
Here are some arguments to answer this question (from my POV) :
{% hint style="success" %}
* Write less code and more meaningful one : improved code clarity
* Avoid side effects by using immutability and pure functions : Easier concurrent programming
* Easier testing : it’s really easy to test functions
* Easier debugging
* Funnier to write
{% endhint %}
## OK but why don’t we use a FP language instead of C# ?
In companies it’s really hard to change the habits. We don’t all work in the Sillicon Valley and in my reality the latest versions in the production environments are : Java 8, .NET Framework 4, NodeWhat ?, …
In my world organizations are not yet ready to invest in pure FP languages like F#, Kotlin, Clojure or whatever. They are stuck in legacy code…
To go further on this topic I invite you to watch this video on ***Functional Core, Imperative Shell*** :
It’s a pattern that could be really useful to every developers on earth I think.
* **Functional core (declarative)** composed of pure functions (in / out) and easy to test without any mocks.
* **Imperative shell or reactive** container the service logic that you can test with integration tests
Now I have proved the interest of FP in OO language let’s go for a quick lesson.
## Let’s demystify Functional Programming (FP)
> “In computer science, **functional programming** is a **programming** paradigm — a style of building the structure and elements of computer programs — that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.” —[ wikipedia](https://en.wikipedia.org/wiki/Functional_programming)
Basically FP is all about **functions and immutability :**
* Pure functions
* Lambda functions (anonymous)
* High order functions
* Composition
* Closures
* Currying & partial application
* Recursion
*If you have already looked at it, you have probably read other words like functors, monads and monoïds that can be very scary but in reality concepts are not.*
Let’s start by explaining 3 concepts :
### Immutability
We **never** want to **mutate an object in FP we want to avoid side effects so we prefer** creating a new one. If we have mutable objects it could be possible for another function to mutate the object we were working on concurrently.
{% hint style="success" %}
Immutability ensures a function remains pure, it makes concurrency much more easy to handle and makes our dev life easier.
{% endhint %}
### Pure Functions
A pure function don’t refer to any global state. The same inputs will always get the same output.
Combined with **immutable data** types mean you can be sure the same inputs will give the same outputs.
### Higher order function
A function that does at least one of the following:
* Takes one or more functions as arguments
* Returns a function as its result
A higher order function that takes 2 functions as arguments
Before demonstrating code I highly recommend you to read this great article about FP concepts (I won’t do better for sure) :
[http://adit.io/posts/2013-04-17-functors,\_applicatives,\_and\_monads\_in\_pictures.html#just-what-is-a-functor,-really?](http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html)
Now you know the basics behind FP we can start deep diving into Language-ext.
## What is Language-ext ?
According to the creator of the lib [**Paul Louth**](https://twitter.com/paullouth) : It’s a library that uses and abuses the features of C# to provide a functional-programming ‘base class library’ that, if you squint, can look like extensions to the language itself.
His desire here is to make programming in C# much more reliable and to make the engineer’s inertia flow in the direction of declarative and functional code rather than imperative.
It’s basically “**one lib to rule them all**” :
### Language-ext vs LinQ
Yes FP paradigms in C# exist since the introduction of LinQ. Here is a mapping between some language-ext functionalities and their equivalence in LinQ :
### **Easy immutable record types**
Implementing immutable data structures is a nightmare in OO languages (Equals, GetHashCode, IEquatable\, IComparer\, implementing operators: ==, !=, <, <=, >, >=).
That’s why there is a **Record** class in language-ext :
```csharp
public class User
{
public readonly Guid Id;
public readonly string Name;
public readonly int Age;
public User(Guid id, string name, int age)
{
Id = id;
Name = name;
Age = age;
}
}
public class UserRecord : Record
{
public readonly Guid Id;
public readonly string Name;
public readonly int Age;
public UserRecord(Guid id, string name, int age)
{
Id = id;
Name = name;
Age = age;
}
}
[Fact]
public void record_types()
{
var spongeGuid = Guid.NewGuid();
var spongeBob = new User(spongeGuid, "Spongebob", 40);
var spongeBob2 = new User(spongeGuid, "Spongebob", 40);
Assert.False(spongeBob.Equals(spongeBob2));
// Use immutable records available in Language-ext
var spongeBobRecord = new UserRecord(spongeGuid, "Spongebob", 40);
var spongeBobRecord2 = new UserRecord(spongeGuid, "Spongebob", 40);
Assert.True(spongeBobRecord.Equals(spongeBobRecord2));
}
```
### **No more out parameters**
Yes in C# we have out parameters on TryParse for example now it’s finished :
### Option
Many functional languages disallow null values, as null-references can introduce hard to find bugs. Option is a type safe alternative to null values. (it also exists in F#).
> **Avoid nulls by using an Option**
An Option\ can be in one of two states :\
**some** => the presence of a value\
**none** => lack of a value
```csharp
Option aValue = 2;
aValue.Map(x => x + 3); // Some(5)
Option none = None;
none.Map(x => x + 3); // None
//Left -> Some, Right -> None
aValue.Match(x => x + 3, () => 0); // 5
none.Match(x => x + 3, () => 0); // 0
// Returns the Some case 'as is' -> 2 and 1 in the None case
int value = aValue.IfNone(1);
int noneValue = none.IfNone(42); // 42
```
***Match*** : match down to primitive type
***Map*** : We can match down to a primitive type, or can stay in the elevated types and do logic using map.
* Lambda inside map won’t be invoked if Option is in None state
* Option is a replacement for if statements ie if obj == null
* Working in elevated context to do logic
### Lists are functors
We can map them :
```csharp
new int[] { 2, 4, 6 }.Map(x => x + 3); // 5,7,9
new List { 2, 4, 6 }.Map(x => x + 3); // 5,7,9
//Prefer use List (Immutable list)
List(2, 4, 6).Map(x => x + 3); // 5,7,9
```
### Function composition
What happens when you apply a function to another function? When you use **map on a function**, you’re just doing **function composition :**
```csharp
static Func Add2 = x => x + 2;
static Func Add3 = x => x + 3;
static int Add5(int x) => Add2.Compose(Add3)(x);
```
### Bind
Monads apply a function that **returns a wrapped value to a wrapped value**. Monads have a function “bind” to do this.
Suppose **half** is a function that only **works on even numbers.**
What if we feed it a wrapped value? This is where **bind** comes in!
```csharp
static Option Half(double x)
=> x % 2 == 0 ? x / 2 : Option.None;
[Fact]
public void bind_monad()
{
Option.Some(3).Bind(x => Half(x));// None
Option.Some(4).Bind(x => Half(x));// Some(2)
}
[Fact]
public void chain_bind_monad()
{
Option.Some(20)
.Bind(x => Half(x))// Some(10)
.Bind(x => Half(x))// Some(5)
.Bind(x => Half(x));// None
}
```
### Try
Exception handling made easier the use of try. No more needs of ugly try/catch that pollutes the flow of your code you can describe your pipeline in a really readable way.
```csharp
public void file_monad_example()
{
GetLine()
.Bind(ReadFile)
.Bind(PrintStrln)
.Match(success => Console.WriteLine("SUCCESS"),
failure => Console.WriteLine("FAILURE"));
}
static Try GetLine()
{
Console.Write("File:");
return Try(() => Console.ReadLine());
}
static Try ReadFile(string filePath) => Try(() => File.ReadAllText(filePath));
static Try PrintStrln(string line)
{
Console.WriteLine(line);
return Try(true);
}
```
Here if something fails, you have the exception in the failure match part. The better part is that **Try** has a brother called **TryAsync** that is demonstrated in the real life example.
### **Memoization**
Memoization is some kind of caching, if you memoize a function, it will be only executed once for a specific input.
```csharp
static Func GenerateGuidForUser = user => user + ":" + Guid.NewGuid();
static Func GenerateGuidForUserMemoized = memo(GenerateGuidForUser);
[Fact]
public void memoization_example()
{
GenerateGuidForUserMemoized("spongebob");// spongebob:e431b439-3397-4016-8d2e-e4629e51bf62
GenerateGuidForUserMemoized("buzz");// buzz:50c4ee49-7d74-472c-acc8-fd0f593fccfe
GenerateGuidForUserMemoized("spongebob");// spongebob:e431b439-3397-4016-8d2e-e4629e51bf62
}
```
### **Partial application**
Partial application allows you to **create new function from an existing one by setting some arguments.**
```csharp
static Func Multiply = (a, b) => a * b;
static Func TwoTimes = par(Multiply, 2);
[Fact]
public void partial_app_example()
{
Multiply(3, 4); // 12
TwoTimes(9); // 18
}
```
### **Either**
**Either** represents a value of two types, it is either **a left or a right** by convention **left** is the **failure case**, and **right** the **success case.**
```csharp
public static Either GetHtml(string url)
{
var httpClient = new HttpClient(new HttpClientHandler());
try
{
var httpResponseMessage = httpClient.GetAsync(url).Result;
return httpResponseMessage.Content.ReadAsStringAsync().Result;
}
catch (Exception ex) { return ex; }
}
[Fact]
public void either_example()
{
GetHtml("unknown url"); // Left InvalidOperationException
GetHtml("https://www.google.com"); // Right Console.WriteLine("an exception occured" + ex),
Right: r => Console.WriteLine(r)
);
}
```
### **Fold vs Reduce (Aggregate in LinQ)**
* **Fold** takes an explicit initial value for the accumulator. The accumulator and result type can differ as the accumulator is provided separately.
* **Reduce** uses the first element of the input list as the initial accumulator value (just like the Aggregate function). The accumulator and therefore result type must match the list element type.
```csharp
[Fact]
public void fold_vs_reduce()
{
//fold takes an explicit initial value for the accumulator
//Can choose the result type
var foldResult = List(1, 2, 3, 4, 5)
.Map(x => x * 10)
.Fold(0m, (x, s) => s + x); // 150m
//reduce uses the first element of the input list as the initial accumulator value
//Result type will be the one of the list
var reduceResult = List(1, 2, 3, 4, 5)
.Map(x => x * 10)
.Reduce((x, s) => s + x); // 150
}
```
### Real life example
This example demonstrates the kind of usage you could have of language-ext in application services : **chaining operations / pipelining, improve error handling, no more redundant checks, …**
```csharp
using System;
using System.Threading.Tasks;
using LanguageExt;
using static LanguageExt.Prelude;
namespace language_ext.kata.Account
{
public class AccountService
{
private readonly UserService userService;
private readonly TwitterService twitterService;
private readonly IBusinessLogger businessLogger;
public AccountService(UserService userService, TwitterService twitterService, IBusinessLogger businessLogger)
{
this.userService = userService;
this.twitterService = twitterService;
this.businessLogger = businessLogger;
}
private TryAsync CreateContext(Guid userId) =>
TryAsync(() => userService.FindById(userId)).Map(user => new RegistrationContext(user));
private TryAsync RegisterOnTwitter(RegistrationContext context) =>
TryAsync(() => twitterService.Register(context.Email, context.Name)).Map(context.SetAccount);
private TryAsync AuthenticateOnTwitter(RegistrationContext context) =>
TryAsync(() => twitterService.Authenticate(context.Email, context.Password)).Map(context.SetToken);
private TryAsync Tweet(RegistrationContext context) =>
TryAsync(() => twitterService.Tweet(context.Token, "Hello I am " + context.Name)).Map(context.SetTweetUrl);
private TryAsync UpdateUser(RegistrationContext context) =>
TryAsync(async () =>
{
await userService.UpdateTwitterAccountId(context.Id, context.AccountId);
return context;
});
public async Task> Register(Guid id)
{
return await CreateContext(id)
.Bind(RegisterOnTwitter)
.Bind(AuthenticateOnTwitter)
.Bind(Tweet)
.Bind(UpdateUser)
.Do(context => businessLogger.LogSuccessRegister(context.Id))
.Map(context => context.Url)
.IfFail(failure =>
{
businessLogger.LogFailureRegister(id, failure);
return (string)null;
});
}
}
}
```
## Conclusion
> Start using language-ext in your projects is a really good idea. This lib can make your life much more easier.
>
> You can see it at your first step to go into the FP world, before one day be able to use a language like Clojure or F#.
## Resources
All the source code is available in my github repository : .
{% embed url="" %}
If you want to go further :
* *FP in pictures* : [http://adit.io/posts/2013-04-17-functors,\_applicatives,\_and\_monads\_in\_pictures.html#just-what-is-a-functor,-really?](http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html)
* *Gitter on language-ext* :
* *Doc and examples* :
* *What’s new in C# 8* :
* *“functional core, imperative shell” video* :
* ***Domain modeling made functional book from Scott Wlaschin*** :
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://yoan-thirion.gitbook.io/knowledge-base/software-craftsmanship/functional-programming-made-easy-in-c-with-language-ext.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.