When we presented F# and FRP in particular, we introduced the following set of essential concepts:

Now, if we try to put together these features, we can obtain an evolution of FRP, or better, a chance to organize our code and logical architecture through a flow of choices.

To be able to handle a set of choices, such as a set of objects or functions, first of all we should have a common denominator which represents them, otherwise it won't be possible. In informatics term, we could say switch from a concrete implementation to an abstract one.

In particular, functional programming has a strict connection with mathematics, so we should create Computation Expressions. These expressions are inspired by the Monads of the functional language Haskell, which in turn are inspired by the Monads concept in mathematics.

Computation Expressions are merely expressions that execute a function given an input and return a result (output). Otherwise, in terms more similar to programming, they are interfaces with rules for the execution of their own methods. For example, this allows us to connect more Monads and handle a workflow.

In F#, one of the simplest representations of Computation Expression during the flow of choices is the following:

type Result<'TSuccess,'TFailure> =  
    | Success of 'TSuccess 
    | Failure of 'TFailure 

This code represents a general discriminate union that has as a possible result Success or Failure of the type 'TSuccess or 'Tfailure, respectively.

The next code shows how we can take full advantage of Monads, connecting more functions that return always the same output:

type Result<'TSuccess,'TFailure> =  
    | Success of 'TSuccess 
    | Failure of 'TFailure 
 
let bind inputFunc =  
    function 
    | Success s -> inputFunc s 
    | Failure f -> Failure f 
 
 
type Account = { UserName : string; IsLogged : bool; Email : string  } 
 
let validateAccount account = 
    match account with 
    | account when account.UserName = "" -> Failure "UserName is not valid" 
    | account when account.Email = "" -> Failure " Email is not empty" 
    | _ -> Success account 
 
 
let checkLogin account = 
    if(account.IsLogged) then 
        Success account 
    else 
        Failure "User is not logged" 
 
let LogIn account = 
    if(account.IsLogged) then 
        Failure "User has already Logged" 
    else 
        Success {account with IsLogged = true} 
 
let LogOut account = 
    if(account.IsLogged) then 
        Success {account with IsLogged = false} 
    else 
        Failure "User has already Logged" 
 
let ProcessNewAccount =  
    let checkLogin = bind checkLogin 
    let login = bind LogIn 
    validateAccount >> login >> checkLogin 
 
let NewFakeAccount = { UserName = ""; Email = ""; IsLogged = false } 
let AccountLogged = { UserName = "User"; Email = "[email protected]"; IsLogged = true } 
let NewAccount = { UserName = "User1"; Email = " [email protected] "; IsLogged = false } 
 
ProcessNewAccount NewFakeAccount |> printfn "Result = %A" 
ProcessNewAccount AccountLogged |> printfn "Result = %A" 
ProcessNewAccount NewAccount |> printfn "Result = %A" 

As you can see, we created different Monads: validateAccount, checkLogin, and LogIn, which return a type Result<Account,string> as a result. Later, we created a function called ProcessNewAccount that, through the use of the composition operator, (>>) connects each Monads in a definite flow. It is important to note how, for every function, it is necessary to use the method bind to avoid cast and anonymous type errors.

In the last row, three different accounts are defined, which are processed with the function ProcessNewAccount.

The result obtained through Interactive Console is as follows:

Result = Failure "UserName is not valid" 
Result = Failure "User has already Logged" 
Result = Success {UserName = "User1"; 
         IsLogged = true; 
         Email = " [email protected] ";}