If you're looking for help with C#, .NET, Azure, Architecture, or would simply value an independent opinion then please get in touch here or over on Twitter.
Note: for those waiting for me to post more videos about Function Monkey they are on the way, I’m on a working / cycling holiday in Mallorca and don’t really have the setup to record decent audio.
While I’m still a complete beginner with F# and very much in the heavy learning phase I thought it might be interesting to write about some of the things I’ve learned along the way.
I can’t stress enough that I’m a beginner with this stuff – so hopefully while its interesting please don’t treat the examples shown as great usage of F#, rather observations made on my way to gaining a better understanding.
A good place to start might be with writing the F# equivalent of this simple and fairly typical C# construct:
internal class Program
{
private static int ProcessInput(string input, int state)
{
int newState = state;
switch (input)
{
case "A": newState = state + 1;
break;
case "M": newState = state * 2;
break;
}
Console.WriteLine(newState);
return newState;
}
public static void Main(string[] args)
{
bool shouldQuit = false;
int state = 0;
while (!shouldQuit)
{
string input = Console.ReadLine().ToUpper();
shouldQuit = input == "Q";
if (!shouldQuit)
{
state = ProcessInput(input, state);
}
}
}
}Essentially keep looping and processing user input until the user signals they’re done. My first attempt at this looked very much like the C# equivalent:
open System
[<EntryPoint>]
let main argv =
let processInputs value input =
let newValue = match input with
| "A" -> value + 1
| "M" -> value * 2
| _ -> value
printf "%d\n" newValue
newValue
let mutable shouldQuit = false
let mutable state = 0
while not shouldQuit do
let input = System.Console.ReadLine().ToUpper()
shouldQuit <- input = "Q"
state <- match shouldQuit with
| true -> state
| false -> processInputs state input
0 // return an integer exit codeAs you might know, in F# data is immutable by default and use of the mutable keyword is a smell – it may sometimes be necessary but its a good sign you’re going about something in a none F# way.
One way to solve this would be to replace the while loop with a recursive function however in this case the recursion is essentially unbounded as it depends on user input. To a C# mindset that is something likely to blow the stack with a good old StackOverflowException. Here’s an example of a recursive approach written in C# and the stack trace that results in the debugger after a few key presses:
class Program
{
private static int ProcessInput(string input, int state)
{
int newState = state;
switch (input)
{
case "A": newState = state + 1;
break;
case "M": newState = state * 2;
break;
}
Console.WriteLine(newState);
return newState;
}
private static int RecursiveLoop(int state)
{
string input = Console.ReadLine()?.ToUpper();
if (input == "Q")
{
return state;
}
return RecursiveLoop(ProcessInput(input, state));
}
static int Main(string[] args)
{
return RecursiveLoop(0);
}
}
Here’s the same code written in F#, with the mutable keyword eradicated, and the stack trace after a few key presses:
open System
[<EntryPoint>]
let main _ =
let processInput value input =
let newValue = match input with
| "A" -> value + 1
| "M" -> value * 2
| _ -> value
printf "%d\n" newValue
newValue
let rec inputTailLoop state =
let input = System.Console.ReadLine().ToUpper()
match input with
| "Q" -> state
| _ -> inputTailLoop (processInput state input)
let startingState = 0
let finishingState = inputTailLoop startingState
finishingState
The stack has not grown! So what’s going on?
The recursive functions, in both C# and F#, are examples of something called tail recursion. Tail recursion occurs when the very last operation a function performs is to call itself and when this occurs their is no need to preserve any data on the stack.
The F# compiler, unlike the C# compiler, recognises this and essentially is able to treat the recursive method as an iteration and avoid the stack growth and by doing so it enables us to solve a whole new class of problems without requiring mutable data.
Having posted about this on Twitter this prompted some discussion amongst the F# wizards about how tail recursion is also generally considered an anti-pattern and Isaac Abraham came through with an example as to how this could be solved using F# sequences as shown below (my butchered version of his original!):
open System
[<EntryPoint>]
let main _ =
let processInput value input =
let newValue = match input with
| "A" -> value + 1
| "M" -> value * 2
| _ -> value
printf "%d\n" newValue
newValue
let inputs = seq {
while true do
yield System.Console.ReadLine()
}
let startingState = 0
let finishingState =
inputs
|> Seq.map (fun input -> input.ToUpper())
|> Seq.takeWhile (fun input -> not(input = "Q"))
|> Seq.fold processInput startingState
finishingState
Essentially what we’ve done here is be explicit about the iteration that was implicit in the tail recursion. I’d used the Seq namespace quite heavily but I’m not sure I’d have made the leap to using the seq { } construct to solve this problem without Isaac’s help (thank you!).
For anyone interested I’m writing a simple version of the classic Star Trek game to teach myself F#. The code is, I’m sure, woeful and it gets refactored massively almost daily at the moment – but you’re welcome to take a look, it’s on GitHub.
Finally I’d like to stress again – I’m an absolute beginner at F# so please, please, don’t use the code above as exemplars but rather curios!
Recent Comments