Currying and Applying Arguments

I gave a talk called Some(‘F#’) is Better Than None at Winnipeg Code Camp on January 28, 2017. The talk was catered toward developers who have never looked at F# or those who never considered F# as being a useful prototyping tool.

During the talk I made a brief mention to currying and partial application. After the talk I received a great question along the lines of: if every function only takes one argument, how is it we are able to pass multiple arguments to a function?


Currying is the process of transforming a function which takes multiple arguments into a sequence of functions where each new function takes only one argument. If we were to write the function:

let addThreeNumbers x y z = x + y + z

This function looks like it takes three arguments, however the signature of addThreeNumbers is converted to int -> int -> int -> int. We can read the function signature as: addThreeNumbers has type of int goes to int goes to int goes to int. The last type in the signature denotes the return type of the function.

Applying arguments

Using the addThreeNumbers function we defined earlier, we can call the function as:

addThreeNumbers 1 2 3

Since we are passing in the full number of arguments the function evaluates immediately giving us the result of 6.

As we are passing in arguments, the function applies what it can with the arguments given. Each time we add an argument it peels off the leading type ->, eventually reaching the point where there is nothing left to apply which then evaluates the result.

// int -> int -> int -> int
let addThreeNumbers x y z = x + y + z

let result = addThreeNumbers 1 2 3
// can be thought of as
let result' = (((addThreeNumbers 1) 2) 3)

// You can also apply the arguments in steps and create 
// intermediate functions.

// addTwoNumbersWith1 :: int -> int -> int
let addTwoNumbersWith1 = addThreeNumbers 1

// addOneNumberWith1and2 :: int -> int
let addOneNumberWith1and2 = addTwoNumbersWith1 2

// six :: int
let six = addOneNumberWith1and2 3

Currying and partial application are very powerful features. Currying is the process of transforming a function which takes multiple arguments into a sequence of functions which take one parameter. Applying arguments to a curried function peels off a function from the sequence. This allows you to build reusable functions.

Advent of Code 2016: Things I’ve Learned

I’ve been engaged in the Advent of Code 2016. Attempting to improve upon my solutions from 2015. I have improved a lot since last year. However, as of Day 8 there are some things that I have notably learned. Well, some things I’ve forgotten and learned again. Here are the highlights so far:


This was added in F# 4.0. This function allows you to partition your collection into arrays of a size of your choosing.
For example:

[1 .. 6] |> Seq.chunkBySize 2;;  // seq [[|1; 2|]; [|3; 4|]; [|5; 6|]]
[1 .. 6] |> Seq.chunkBySize 3;;  // seq [[|1; 2; 3|]; [|4; 5; 6|]]

There is a caveat, if the number of items in the collection is not equally divisible by the chunk size, the last array will have fewer items.

[1 .. 6] |> Seq.chunkBySize 5;;  // seq [[|1; 2; 3; 4; 5|]; [|6|]]


This one I seem to forget is available. I always start with a for or a skip |> take and then I remember. It can make your code a lot easier to read.

Spoilers for day 8

I am using a mutable 2D array for day 8. There was a similar problem last year and I chose to go fully immutable and got destroyed by Garbage Collection. Mutability we go! The problem called for shifting pixels (which wrap) on a display. I decided to get the current row of pixels starting at origin (I define the origin as being the length of the array minus the amount we are shifting). I then could apply the shifted row to the mutable 2D array.

My initial implementation:

member this.RotateRow (y,shift) =
  let origin = width - shift
  seq { for i in {origin .. width - 1} do
          yield display.[i, y]
        for i in {0 .. origin - 1} do
          yield display.[i, y] } 
  |> applyShift

It’s not terribly bad. We get the items from shift origin to the end of the array followed by items from the start of the array to origin. We can do better with slicing.

Slicing an array or list is a matter of using the indexer after the label.

let l1 = [1 .. 100];;
l1.[6 .. 10];; // [7; 8; 9; 10; 11]
l1.[7 .. 11];; 
l1.[.. 10];;   // [1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11]
l1.[95 ..];;   // [96; 97; 98; 99; 100]

Did you notice I said indexer? Yes, slice takes the items via their position in the collection. This is something you will need to be aware of. If you want the first ten items using slice you would use [..9], as the tenth item is in position nine.

Updating my original solution using slices instead of for constructs has made my solution more concise and readable.

member this.RotateRow (y,shift) =
  let origin = width - shift
  seq { yield display.[origin .., y]
        yield display.[.. origin - 1, y] } 
  |> applyShift

By using slices I removed the need to calculate the end of the array. This eliminated the chance of an off by one error. <insert bad off by 2 joke here>


Seq.windowed is handy when you need to look for specific patterns in a collection. This function works by taking a collection and creating a sliding window of arrays with the length you specify.

Some examples of course:

let l1 = [1 .. 5];;
l1 |> Seq.windowed 2;; // seq [[|1; 2|]; [|2; 3|]; [|3; 4|]; [|4; 5|]
l1 |> Seq.windowed 3;; // seq [[|1; 2; 3|]; [|2; 3; 4|]; [|3; 4; 5|]
l1 |> Seq.windowed 4;; // seq [[|1; 2; 3; 4|]; [|2; 3; 4; 5|]]
l1 |> Seq.windowed 6;; // seq [] 

If you try to get windows larger than the size of the collection, you end up with an empty collection.

Seq.chunkBySize, slicing, and Seq.windowed are my three most notable take aways from the first 8 days of Advent of Code 2016.

ASP.Net Encode Token

TL;DR – In ASP.Net MVC use the HttpServerUtility.UrlTokenEncode() and HttpServerUtility.UrlTokenDecode() for encoding and decoding tokens/keys with unprintable characters.

Every so often we use a throw away token for generating a link. An example of this would be a link to reset a password. You don’t want to send the password to your user in an email (you should never send a password to a user in an email). Instead, you create a link with a token they can click on to create a new password. Encoding the token is straight forward, however I always seem to forget the utility to use.

I always seem to go down this progression:

    • Base64 – Convert.ToBase64String()
      • Nope. This has issues with ?token= query params due to the potential `=` signs at the end.
    • Encoded using HttpUtility.UrlEncode()
      • Nope. UrlEncode does not handle unprintable characters, when you try to decode it you get the wrong results.
    • Encoded using HttpServerUtility.UrlTokenEncode()
      • YES. That’s the one we need.

Having to use the UrlTokenEncode has been fairly rare, which is why I can’t remember it immediately. The default IdentityProvider has the email reset feature built in with the encoding/decoding happening automatically. Knowing the UrlTokenEncode comes in handy when creating links for QR Codes or other purposes.

Setting up Gulp for compiling SASS in Visual Studio 2015

I’ve been meaning to use gulp for compiling sass files in Visual Studio for a while. Using gulp instead of a Visual Studio extension gives the advantage of not always having to be in visual studio. I’ve used gulp in other projects where it was already setup and working, but have never set it up myself. I figured it was time for that to change.

Step 1: Install nodejs if you haven’t already. This gives access to the Node Package Manager (NPM). You can download nodejs using the link below.

Step 2; Add the variable NODE_PATH with a value of %AppData%\npm\node_modules. If it’s already in your environment, then you don’t need to do anything. This will give you access to globally installed packages from the command line without having to type the full path.

Step 3: Install gulp using NPM. In a command window or PowerShell type the command below and press enter.
npm install -g gulp
NPM will start installing gulp globally for your system, as denoted by the -g flag.

Step 4: Start up Visual Studio 2015 and create a new project or open an existing project.

Step 5: Add two new files in Visual Studio called “NPM Configuration File” and “Gulp Configuration File”.

  • package.json – NPM Configuration File
  • gulpfile.js – Gulp Configuration File

Note: If the templates aren’t available in Visual Studio you can create a normal json and a js file, and name them package.json and gulpfile.js.

Step 6: Modify the package.json file so it looks like the configuration below. You can change the values as you like, but the important part is the devDependencies section.

  "name": "ASP.NET",
  "version": "1.0.0",
  "description": "",
  "main": "gulpfile.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  "author": "",
  "license": "",
  "devDependencies": {
    "gulp": "^3.9.1",
    "gulp-plumber": "1.0.1",
    "gulp-autoprefixer": "^2.0.0",
    "gulp-sass": "2.0.4"

Step 7: In the solution explorer of Visual Studio, right click on the package.json file and select Restore Packages. This will download the dependencies we set up in step 7.

Note: Now would be a good time to say if you are using version control, it would be wise to add an exclusion for the node_modules directory.

Step 8: Let’s now update the gulpfile.js to compile our scss file.

var gulp         = require('gulp');
var sass         = require('gulp-sass');
var plumber      = require('gulp-plumber');
var autoprefixer = require('gulp-autoprefixer');

gulp.task("styles", function () {
  // We start with the main scss file (site.scss) and include all others from there.
  return gulp.src(["content/scss/site.scss", "content/scss/*.css"])
             .on('error', function(err) {
             .pipe(autoprefixer("last 1 version", { cascade: true }))
             // The destination directory to output the compiled css.


Step 9: At this point, it’s now just a matter of creating the content/scss/ directory and creating your sass styles.

Note: When you want to compile your css, open the “Task Runner Explorer” by right clicking the gulpfile.js in the “Solution Explorer” pane, or in the menu click on “View” -> “Other Windows” -> “Task Runner Explorer”. After doing that you should see our two tasks of “default” and “styles”. You can double click either one to compile your new files.

If you want to get really crazy, you can create a task that will watch your content/scss/ directory for changes and have them be automatically compiled.

Getting Out of the Fold

I did the Advent of Code albeit after the fact. It’s been awhile since I’ve looked at my solutions, I thought it would be good to go back and refactor. This is turning out to be a very good exercise and an indicator of how far I’ve come as a functional programmer.

In my early functional days, learning fold was the pinnacle of accomplishments. Fold can be a difficult function to learn for someone coming from strictly Object Oriented. Fold is a higher order function that takes three parameters. Higher order function is a fancy name for a function that takes another function as a parameter. The three parameters for fold are as follows, a function (known as a folder), an initial state, and a collection of elements. The signature for fold in F# is below, along with a very simple example.

Seq.fold : ('State -> 'T -> 'State) -> 'State -> seq<'T> -> 'State
Seq.fold (fun acc x -> acc + x) 0 [1; 2; 3]

My example? The folder is a function that takes two integers and adds them together. The initial state is zero, and a list that contains the integers 1, 2, and 3. That wasn’t so bad right?

More experienced developers say “That’s not a great example. We already have Seq.sum.” Absolutely, and that’s where I am going. I found I used fold in a lot of cases where there was a much better function.

Spoilers of Advent of Code Day 3

The advent of code day 3 is a perfect example of my use of fold as being a golden hammer. Day 3’s problem is a delivery person is given directions consisting of “<",">“,”v”,”^”. An example of directions could be “^^vv<><>“. That delivery person then delivers packages to the houses at each stop, some houses receive more than one package. What is the number of houses that get packages?

My initial solution using the golden fold.

let move (x,y) = function
    | '^' -> (x, y + 1)
    | 'v' -> (x, y - 1)
    | '<' -> (x - 1, y)
    | '>' -> (x + 1, y)
    | _   -> (x, y)

let countHouses dirs = 
    dirs |> Seq.fold (fun (p,(s : (int * int) Set)) d -> 
            let p' = move p d
            (p', (s.Add p'))) ((0,0), Set.ofList [(0,0)])
    |> fun (_, s) -> s |> Seq.length

The code works, but it’s not all that readable. The state is a tuple containing the current position and a set of houses visited. The folder deconstructs the tuple, moves to the new house, and adds it to the set. The final result of the fold is deconstructed and the set of houses is counted.

Let’s look at how I refactored the solution. This is after some time away from my initial solution.

let countHouses dirs = dirs |> Seq.scan move (0,0) |> Seq.distinct
                       |> Seq.length

Seq.scan is a higher order function that returns a sequence of the intermediate results. It turns out scan is exactly what I needed. You can see scan results in a much nicer solution than fold does.

Fold is a very useful and powerful function, especially when you are getting started. However, it shouldn’t be your go to function for everything. As you gain more experience you learn there are more specific functions that result in code that is a lot easier to reason about. Don’t stop learning when you get into the fold.

Surface Pro 3 Lockup on boot

tl;dr – Disabling Windows Spotlight seems to have resolved my Surface Pro 3’s lockup on boot issue. (Your results may vary)

I’ve had a Surface Pro 3 since September of 2015. Let’s just say it was a rocky start. Out of the box the machine blue screened on boot. I did a hard reset and was able to get in to use it. I went through the usual steps of doing updates, and things seemed to be going smoothly.

The next day I tried to do some reading on it however the Surface Pro 3 wouldn’t boot. It got stuck on the Surface screen without the spinning indicator. Again I had to do another hard reset. A little research revealed it was a common issue with no real solution. It was disappointing to say the least.

The system would lock up every third to fifth time I would try to use it. I tried factory resetting the device and still it didn’t want to boot consistently.

I then read somewhere that there were potential driver issues with the network card. Whether or not that was true I don’t know. What I did know was every time I hard reset the machine (and it successfully boot) the lock screen background image would flash and reset to the original. This got me thinking of something to try.

I went into All Settings (by swiping in from the right) -> Personalisation -> Lock Screen. Once there I changed the Background from Windows Spotlight to being a static picture. The Surface Pro 3 has not locked up on me since I made that change. It’s been booting consistently without any issues. I’m a happy user now.

Whether or not the fix was disabling Windows Spotlight I can’t be sure. It may be coincidence. At this point, I don’t care. It works.

Some(“F#”) is better than None

I’ve been doing object oriented programming since 2002. I’ve been looking to expand my horizons for a little while. Not that I believe OOP is bad. I have found that in some cases, modelling everything in classes can be extremely difficult and you end up with an over engineered and complex solution (usually by accident).

I started tinkering with Erlang around 2013. I really enjoy Erlang. I like the syntax, and the pattern matching is absolutely fantastic. I am also a fan of the actor model. My only issue is the problems I am solving for work don’t fit Erlang solutions (yet). Currently we primarily create desktop applications. The newer applications are in C#.

This is where F# comes in. F# is a functional language which runs on the CLR. This means you can start using F# and have it interop easily with your existing .Net applications. Below are a few reasons I started using F# over C#.

REPL (Read Evaluate Print Loop)

One advantage to using F# is the REPL. This allows you to get immediate feedback during your development process. Write a function, test it in the REPL. Modify the function, test it again. No compiling and no external test runner is required. A more apt definition of REPL would be Rapid Evolving Program Logic.

Pattern Matching

I like F#’s pattern matching. It can be concise and easier to read than a bunch of if statements. An example is comparing application versions to determine if the user requires an update.

// uMaj, uMin, uBld = user's Major, Minor, Build version
// lMaj, lMin, lBld = latest Major, Minor, Build version

// C#
if (uMaj < lMaj)
    return "Major";
else if (uMaj == lMaj && uMin < lMin)
    return "Minor";
else if (uMaj == lMaj && uMin == lMin && uBld < lBld)
    return "Build";
    return "None";

// F# - The user's version numbers are either matched or 
// bound to x for comparison
match (uMaj, uMin, uBld) with
| (x, _, _)       when x < lMaj -> "Major"
| (lMaj, x, _)    when x < lMin -> "Minor"
| (lMaj, lMin, x) when x < lBld -> "Build"
| (_, _, _)                     -> "None"

Option Type

F# tries to eliminate null values as much as possible. Nulls are still needed for working with non F# libraries. When an F# function needs the ability to return a value or no value (if there is an error), you can use the Option type. When the function returns a value you wrap it in Some, when no value is to be returned you use None. This gives you a function having a return of either Some (value) or None. A simple example of this is a divide function.

let divide a b =
   match b with
   | 0 -> None
   | _ -> Some (a/b)

After obtaining the result, you can use pattern matching to determine whether you received Some value or None. You end up with fewer NullReferenceExceptions by using options.

There are more reasons to use F#, discriminated unions, agents, and it’s fun. After a little practice and experience with F#, you find you write less code to accomplish the same task than in other .Net languages. All you need to know to get started with F# is the keywords “let“, “|>” (pipe forward), and “fun“. Happy learning!

Great F# resources:

Having a backup is not enough

I got the call on a Friday afternoon. It was shortly after 4:30 pm. The call nobody wants. A customer of one of my clients had been hit by a version of the cryptolocker ransomware virus. Their tech removed the virus, however half of their data files were encrypted. They were going to be fine. They were going to recover their data from a backup.

They paid their tech person to setup and do their backups. Except that someone did it poorly. This customer was not going to be fine. The daily backups were overwriting the same file every time. This meant that as time went on, the ransomware slowly digested the data files, the system happily backed up those newly encrypted files and overwrote any chance we had of recovering their data.

It’s very hard to believe that in this day of age with cloud and inexpensive hardware, that tech people still get this wrong.

I’ll give you a quick checklist of what I’ve been doing for a long time. If you have to wonder if what you are doing is actually a backup? It probably is not. This is a great blog that I direct everyone to when they ask me questions about backups.

I was never going to blog about this topic. Never thought I had to. Thinking now, maybe everyone should have a blog post about doing backups. Then there are no excuses.

A quick list of things I like to have for important backups:

– Multiple versions of backups. My backups never overwrite the same file. I create new backup files. Depending on what I’m backing up, I may keep the seven, fifteen, or thirty most recent backups.

– Multiple locations. My backup files are copied to multiple external hard drives, and another computer.

– Have a backup go offsite. Let a backup be Elvis, and leave the building. Take an external hard drive home with you. Use the cloud. Anything is better than nothing.

– RESTORE your backups once in a while! This is another situation I have seen in my days of doing support. “We have backups. We’ve always done backups.” I had to respond with “I’m sorry, but these backups are not going to work. It’s been backing up the wrong files.” Test your backups! A good and well practiced restore plan makes things a lot less stressful when under pressure.

Always have a reliable set of backups and know how to restore your backups in case things go wrong.

High School: CSI

Computer Science Ignored

Saturday July 20th, 2013 was going great. I got up with my son and we watched cartoons. I went golfing with some friends in a tournament, and we won. I had a wonderful supper with my family and my parents. I then went with my wife to a social (dance). We danced and talked with friends. It had been a great day.

During a conversation with a friend, who is a teacher, I was figuratively punched in the gut. I found out the local high school had its computer science class cut. This was a shock to Haley and I. The class had just started being taught the previous year. It had been about ten years since it was last taught. We went to the class and gave a small presentation and answered any questions the class (including the teacher) had. That was a fun day. However, it’s all over.

There was a lot of excitement for the upcoming year. Haley had been working with the teacher on a course outline to help improve the curriculum. We were more than happy to help out with anything they needed. We were really excited to be involved. I am currently heartbroken.

I’m left asking a lot of questions.
– Was it lack of student interest? I don’t think so. There were eleven students in the class last year, boys and girls. There were already ten new students signed up for next year. This is a school from kindergarten to grade 12 with around 470 students.

– Why is computer science still considered a sub-standard or ignorable topic in high schools? My thoughts are computer science is viewed less as a science, but more of a skilled trade. Maybe the school boards don’t understand that computer science or programming is all about problem solving, experimentation, and analysis.

– Do all physics majors become physicists? How about chemistry majors? I’m not asking this to bash the other sciences, I just don’t know the answer. I really liked physics, and the degree I was originally going for in university was chemistry. I have one friend who has a degree in chemistry and he runs his own company building houses.

– Why is it, the only way to learn programming at an early age is to do it on your own? This does seem to perpetuate the stereotype that computer geeks are anti-social. Maybe the kids just don’t have an opportunity to explore computers outside their own basement? While golfing earlier that day, one guy was talking about his wife getting frustrated with their son for watching youtube videos of minecraft instead of cartoons or playing outside. That seems like a child who would possibly be interested in a computer science course. There are a lot of video games that are good at enhancing problem solving skills.

I am going to followup and try to get the reasons for the cancellation. That way I don’t have to speculate ‘why?’.

As of writing this, the school has a forensics class. That is cool!

Windows 8 Start Screen Displays Wrong Tile Icons

My wife’s laptop had an interesting issue. The start screen in Windows 8 was showing the wrong icon for a lot of the other applications. This would appear in the start screen as well as in the taskbar when the applications were running. This made it difficult to quickly differentiate the applications when a lot of the icons showed as Photoshop.

I searched the web for an answer. The most common answer was to delete the ‘IconCache.db’ and restart the computer. This did not solve my particular problem.

After a while, I noticed it was only the applications where the icon was an external file. Any of the applications whose icons were embedded in the executable were unaffected.

I checked the file associations for extension ‘.ico’ (Control Panel -> Default Programs). It turns out Photoshop had been assigned as the default application for opening ‘.ico’ files. I changed the ‘.ico’ to be opened with ‘Windows Photo Viewer’ (the default is Paint). This didn’t fix the problem immediately, I also had to recreate the start screen tiles for those applications affected.

The problem was finally resolved.