Category: F#

_____100 |> F# Some Troubleshooting Linux

In the last article I wrote on writing a code kata with F# on OS-X or Windows, I had wanted to use Linux but things just weren’t cooperating with me. Well, since that article I have resolved some of the issues I ran into, and this is the log of those issues.

Issue 1: “How can I resolve the “Could not fix timestamps in …” “…Error: The requested feature is not implemented.””

The first issue I ran into with running the ProjectScaffold build on Linux I wrote up and posted to Stack Overflow titled “How can I resolve the “Could not fix timestamps in …” “…Error: The requested feature is not implemented.”“. You can read more about the errors I receiving on the StackOverflow Article, but below is the immediate fix. This fix should probably be added to any F# Installation instructions for Linux as part of the default.

First ensure that you have the latest version of mono. If you use the instructions to do a make and make install off of the fsharp.org site you may not actually have the latest version of mono. Instead, here’s a good way to get the latest version of mono using apt-get. More information can be found about this on the mono page here.

[sourcecode language=”bash”]
apt-get install mono-devel
apt-get install mono-complete
[/sourcecode]

Issue 2: “ProjectScaffold Error on Linux Generating Documentation”

The second issue I ran into I also posted to Stack Overflow titled “ProjectScaffold Error on Linux Generating Documentation“. This one took a lot more effort. It also spilled over from Stack Overflow to become an actual Github Issue (323) on the project. So check out those issues in case you run into any issues there.

In the next issue, to be published tomorrow, I’ll have some script tricks to use mono more efficiently to run *.exe commands and get things done with paket and fake in F# running on any operating system.

______10 |> F# – Moar Thinking Functionally (Notes)

More notes on the “Thinking Functionally” series. Previous notes are @ “_______1 |> F# – Getting Started, Thinking Functionally“.

#6 Partial Application

Breaking down functions into single parameter functions is the mathematically correct way of doing it, but that is not the only reason it is done — it also leads to a very powerful technique called partial function application.

For example:

[sourcecode language=”fsharp”]
let add42 = (+) 42 // partial application
add42 1
add42 3

[1;2;3] |> List.map add42

let twoIsLessThan = (<) 2 // partial application twoIsLessThan 1 twoIsLessThan 3 // filter each element with the twoIsLessThan function [1;2;3] |> List.filter twoIsLessThan

let printer = printfn "printing param=%i"

[1;2;3] |> List.iter printer
[/sourcecode]

Each case a partially applied function above it can then be reused in multiple contexts. It can also fix function parameters.

[sourcecode language=”fsharp”]
let add1 = (+) 1
let add1ToEach = List.map add1 // fix the "add1" function

add1ToEach [1;2;3;4]

let filterEvens =
List.filter (fun i -> i%2 = 0) // fix the filter function

filterEvens [1;2;3;4]
[/sourcecode]

Then the following shows plug in behavior that is transparent.

[sourcecode language=”fsharp”]
let adderWithPluggableLogger logger x y =
logger "x" x
logger "y" y
let result = x + y
logger "x+y" result
result

let consoleLogger argName argValue =
printfn "%s=%A" argName argValue

let addWithConsoleLogger = adderWithPluggableLogger consoleLogger
addWithConsoleLogger 1 2
addWithConsoleLogger 42 99

let popupLogger argName argValue =
let message = sprintf "%s=%A" argName argValue
System.Windows.Forms.MessageBox.Show(
text=message,caption="Logger")
|> ignore

let addWithPopupLogger = adderWithPluggableLogger popupLogger
addWithPopupLogger 1 2
addWithPopupLogger 42 99
[/sourcecode]

Designing Functions for Partial Application

Sample calls to the list library:

[sourcecode language=”fsharp”]
List.map (fun i -> i+1) [0;1;2;3]
List.filter (fun i -> i>1) [0;1;2;3]
List.sortBy (fun i -> -i ) [0;1;2;3]
[/sourcecode]

Here are the same examples using partial application:

[sourcecode language=”fsharp”]
let eachAdd1 = List.map (fun i -> i+1)
eachAdd1 [0;1;2;3]

let excludeOneOrLess = List.filter (fun i -> i>1)
excludeOneOrLess [0;1;2;3]

let sortDesc = List.sortBy (fun i -> -i)
sortDesc [0;1;2;3]
[/sourcecode]

Commonly accepted guidelines to multi-parameter function design.

  1. Put earlier: parameters ore likely to be static. The parameters that are most likely to be “fixed” with partial application should be first.
  2. Put last: the data structure or collection (or most varying argument). Makes it easier to pipe a structure or collection from function to function. Like:

    [sourcecode language=”fsharp”]
    let result =
    [1..10]
    |> List.map (fun i -> i+1)
    |> List.filter (fun i -> i>5)
    [/sourcecode]

  3. For well-known operations such as “subtract”, put in the expected order.

Wrapping BCL Function for Partial Application

Since the data parameter is generally last versus most BCL calls that have the data parameter first, it’s good to wrap the BCL.

[sourcecode language=”fsharp”]
let replace oldStr newStr (s:string) =
s.Replace(oldValue=oldStr, newValue=newStr)

let startsWith lookFor (s:string) =
s.StartsWith(lookFor)
[/sourcecode]

Then pipes can be used with the BCL call in the expected way.

[sourcecode language=”fsharp”]
let result =
"hello"
|> replace "h" "j"
|> startsWith "j"

["the"; "quick"; "brown"; "fox"]
|> List.filter (startsWith "f")
[/sourcecode]

…or we can use function composition.

[sourcecode language=”fsharp”]
let compositeOp = replace "h" "j" >> startsWith "j"
let result = compositeOp "hello"
[/sourcecode]

Understanding the Pipe Function

The pipe function is defined as:

[sourcecode language=”fsharp”]
let (|>) x f = f x
[/sourcecode]

It allows us to put the function argument in front of the function instead of after.

[sourcecode language=”fsharp”]
let doSomething x y z = x+y+z
doSomething 1 2 3
[/sourcecode]

If the function has multiple parameters, then it appears that the input is the final parameter. Actually what is happening is that the function is partially applied, returning a function that has a single parameter: the input.

[sourcecode language=”fsharp”]
let doSomething x y =
let intermediateFn z = x+y+z
intermediateFn // return intermediateFn

let doSomethingPartial = doSomething 1 2
doSomethingPartial 3
3 |> doSomethingPartial
[/sourcecode]

#7 Function Associativity and Composition

Function Associativity

This…

[sourcecode language=”fsharp”]
let F x y z = x y z
[/sourcecode]

…means this…

[sourcecode language=”fsharp”]
let F x y z = (x y) z
[/sourcecode]

Also three equivalent forms.

[sourcecode language=”fsharp”]
let F x y z = x (y z)
let F x y z = y z |> x
let F x y z = x <| y z
[/sourcecode]

Function Composition

Here’s an example

[sourcecode language=”fsharp”]
let f (x:int) = float x * 3.0 // f is int->float
let g (x:float) = x > 4.0 // g is float->bool
[/sourcecode]

We can create a new function h that takes the output of “f” and uses it as the input for “g”.

[sourcecode language=”fsharp”]
let h (x:int) =
let y = f(x)
g(y) // return output of g
[/sourcecode]

A much more compact way is this:

[sourcecode language=”fsharp”]
let h (x:int) = g ( f(x) ) // h is int->bool

//test
h 1
h 2
[/sourcecode]

These are notes, to read more check out the Function Composition.

______11 |> F# – Some Hackery – A String Calculator Kata

Now for some F# hacking. The first thing I did was actually go through a Code Kata, which I’ll present here.

The first step I took was to get a project started. For that I used the ProjectScaffold to build a clean project via bash.

First cloned…

[sourcecode language=”fsharp”]
git clone git@github.com:fsprojects/ProjectScaffold.git sharpKataStringCalc
[/sourcecode]

…then I navigated into the directory and executed the build.sh script…

[sourcecode language=”fsharp”]
cd sharpKataStringCalc/
./build.sh
[/sourcecode]

…then I got prompted for some input.

[sourcecode language=”bash”]
#####################################################

# Project Scaffold Init Script
# Please answer a few questions and we will generate
# two files:
#
# build.fsx This will be your build script
# docs/tools/generate.fsx This script will generate your
# documentation
#
# NOTE: Aside from the Project Name, you may leave any
# of these blank, but you will need to change the defaults
# in the generated scripts.
#

#####################################################

Project Name (used for solution/project files): sharpKataStringCalc
Summary (a short description): A code kata for the string calculator exercise.
Description (longer description used by NuGet): The code kata, kicked off my Roy Osherove, this is my iteration of it (at least my first iteration of it).
Author: Adron Hall
Tags (separated by spaces): fsharp f# code kata stringcalculator
Github User or Organization: adron
Github Project Name (leave blank to use Project Name):
[/sourcecode]

Once I hit enter after entering the information I’ve gotten more than a few of these broken builds.

[sourcecode language=”bash”]
Time Elapsed 00:00:00.1609190
Running build failed.
Error:
Building /Users/adronhall/Coderz/sharpKataStringCalc/sharpKataStringCalc.sln failed with exitcode 1.

———————————————————————
Build Time Report
———————————————————————
Target Duration
—— ——–
Clean 00:00:00.0019508
AssemblyInfo 00:00:00.0107624
Total: 00:00:00.6460652
Status: Failure
———————————————————————
1) Building /Users/adronhall/Coderz/sharpKataStringCalc/sharpKataStringCalc.sln failed with exitcode 1.
2) : /Users/adronhall/Coderz/sharpKataStringCalc/src/sharpKataStringCalc/sharpKataStringCalc.fsproj(0,0): Target named ‘Rebuild’ not found in the project.
3) : /Users/adronhall/Coderz/sharpKataStringCalc/tests/sharpKataStringCalc.Tests/sharpKataStringCalc.Tests.fsproj(0,0): /Users/adronhall/Coderz/sharpKataStringCalc/tests/sharpKataStringCalc.Tests/sharpKataStringCalc.Tests.fsproj: The required attribute "Project" in Import is empty
———————————————————————
[/sourcecode]

This problem I was able to solve once, based on what I did in a previous blog entry “That Non-Windows Scaffolding for OS-X and Linux |> I Broke It! But…“. Which seemed odd that I fixed it previously. To help with the build I actually opened it up in Xamarin Studio. Now, one of the problems with doing this, is that it’s only available on Windows & OS-X. I’m however interested in using this stuff on Linux too, but that’s looking a bit more difficult the more I work with the toolchain unfortunately.

After working through the issue I found that on one OS-X box I’d installed Mono via make and F# via make and that messes things up. Do one or the other and you should be ok. So on my other two OS-X boxes (I’ve a personal retina and a work retina) the build worked flawlessly, and when it works flawlessly it looks like this toward the end of the build execution.

[sourcecode language=”bash”]
Finished Target: GenerateReferenceDocs
Starting Target: GenerateDocs (==> GenerateReferenceDocs, GenerateReferenceDocs)
Finished Target: GenerateDocs
Starting Target: All (==> GenerateDocs)
Finished Target: All

———————————————————————
Build Time Report
———————————————————————
Target Duration
—— ——–
Clean 00:00:00.0035253
AssemblyInfo 00:00:00.0103142
Build 00:00:04.9369669
CopyBinaries 00:00:00.0052210
RunTests 00:00:00.6568475
CleanDocs 00:00:00.0025772
GenerateHelp 00:00:08.6989318
GenerateReferenceDocs 00:00:11.7627584
GenerateDocs 00:00:00.0003409
All 00:00:00.0000324
Total: 00:00:26.1162623
Status: Ok
———————————————————————
[/sourcecode]

I’ve gotten this to work on OS-X and Windows just fine using the straight up ProjectScaffold and the ./build.sh. So all is good, I’m going to move forward with writing the kata based on that and loop back around to straighten out the Linux issues.

To run the tests, execute the following script after creating the project scaffold.

[sourcecode language=”bash”]
./build.sh RunTests
[/sourcecode]

First off, what are the ideas behind the string calculator kata? Well here’s how Roy Osherove lays it out this particular code kata.

Before you start:

  • Try not to read ahead.
  • Do one task at a time. The trick is to learn to work incrementally.
  • Make sure you only test for correct inputs. there is no need to test for invalid inputs for this kata.

String Calculator

  1. Create a simple String calculator with a method int Add(string numbers)
    1. The method can take 0, 1 or 2 numbers, and will return their sum (for an empty string it will return 0) for example “” or “1” or “1 2”
    2. Start with the simplest test case of an empty string and move to 1 and two numbers
    3. Remember to solve things as simply as possible so that you force yourself to write tests you did not think about
    4. Remember to refactor after each passing test
  2. Allow the Add method to handle an unknown amount of numbers.
  3. Allow the Add method to handle new lines between numbers (instead of an empty space).
    1. the following input is ok: “1\n2 3” (will equal 6)
    2. the following input is NOT ok: “1 \n” (not need to prove it – just clarifying)
  4. Support different delimiters
    1. to change a delimiter, the beginning of the string will contain a separate line that looks like this: “//[delimiter]\n[numbers…]” for example “//;\n1;2” should return three where the default delimiter is ‘;’ .
    2. the first line is optional. all existing scenarios should still be supported
  5. Calling Add with a negative number will throw an exception “negatives not allowed” – and the negative that was passed.if there are multiple negatives, show all of them in the exception message
  6. Numbers bigger than 1000 should be ignored, so adding 2 + 1001 = 2
  7. Delimiters can be of any length with the following format: “//[delimiter]\n” for example: “//[***]\n1***2***3” should return 6
  8. Allow multiple delimiters like this: “//[delim1][delim2]\n” for example “//[*][%]\n1*2%3” should return 6.
  9. Make sure you can also handle multiple delimiters with length longer than one char.

Ok, so now that we’re clear on the string calculator, I’m going to dig into knocking out the first item, “Create a simple string calculator with a method int Add (string numbers)”

But first, in TDD fashion let’s write the test and make it fail first. I changed the code in the Tests.fs file in the tests directory and tests project to read as follows.

[sourcecode language=”fsharp”]
module sharpKataStringCalc.Tests

open System
open sharpKataStringCalc
open NUnit.Framework

[<TestFixture>]
type CalculatorTests() =
[<Test>]
member x.add_empty_string() =
let calculator = Calculator()
let result = calculator.Add ""
Assert.That(result, Is.EqualTo 0)
[/sourcecode]

That gets us a failing test, since we don’t even have any implementation yet. So now I’ll add the first part of the implementation code. First I created a Calculator.fs file and deleted the other file that ProjectScaffold put in there in the first place.

[sourcecode language=”fsharp”]
namespace sharpKataStringCalc

open System

type Calculator() =
member x.Add express =
0
[/sourcecode]

Ok, that gives me a passing test for the first phase of all this. Now since I’m a total F# newb still I’ve got to kind of dig around and read documentation while I’m working through this. So I’m taking a couple of hours while Roy’s suggestion is to use 30 minutes to do this kata. But I figured it is a good way to force myself to learn the syntax and start getting into an F# refactoring practice.

The first thing I started to do was write a test where I set the Calculator() again that looked something like this. I didn’t like that so I tried to pull it out of the test.

[sourcecode language=”fsharp”]
[<TestCase("1", Result = 1)>]
member x.Add_single_number_returns_that_number expression =
let calculator = Calculator()
calculator.Add expression
[/sourcecode]

I ended up with something like this then.

[sourcecode language=”fsharp”]
let calculator = Calculator()

[<TestFixture>]
type CalculatorTests() =
[<Test>]
member x.add_empty_string() =
let result = calculator.Add ""
Assert.That(result, Is.EqualTo 0)

[<TestCase("1", Result = 1)>]
member x.Add_single_number_returns_that_number expression =
calculator.Add expression
[/sourcecode]

After adding that code with that little refactor I ran it, red light fail, so I then moved on to implementation for this test.

[sourcecode language=”fsharp”]
type Calculator() =
member x.Add expression =
match expression with
| "" -> 0
| _ -> 1
[/sourcecode]

Everything passed. So now on to the next scenario other subsequent number strings. I add another test and result condition.

[sourcecode language=”fsharp”]
[<TestCase("1", Result = 1)>]
[<TestCase("2", Result = 2)>]
member x.Add_single_number_returns_that_number expression =
calculator.Add expression
[/sourcecode]

It runs, gets a red light fail, I then implement with this minor addition.

[sourcecode language=”fsharp”]
type Calculator() =
member x.Add expression =
match expression with
| "" -> 0
| _ -> Int32.Parse expression
[/sourcecode]

Before moving on, I’m just going to cover some of the syntax I’ve been using. The | delimits individual matches, individual discriminated union cases, and enumeration values. In this particular case I’m just using it to match the empty string or the
wildcard. Which speaking of, the _ is a wildcard match or specifies a generic parameter. To learn more about these in detail check out match expressions or generics. There are lots of good things in there.

The other syntax is somewhat more self-explanatory so I’m going to leave it as is for the moment. It is, in the end, when executing the tests evident what is going on at least. Alright, back to the kata. Let’s actually add two numbers. For the test I’m just going to add another TestCase with two actual numbers.

[sourcecode language=”fsharp”]
[<TestCase("1", Result = 1)>]
[<TestCase("2", Result = 2)>]
[<TestCase("1 2", Result = 3)>]
member x.Add_single_number_returns_that_number expression =
calculator.Add expression
[/sourcecode]

Fails, so on to implementation. I’m just going to do this the cheap “it works” way and do something dumb.

[sourcecode language=”fsharp”]
type Calculator() =
member x.Add expression =
match expression with
| "" -> 0
| _ when expression.Contains " " -> 3
| _ -> Int32.Parse expression
[/sourcecode]

That’ll give me a passing green light, but I’ll add another bit of attribute to the test and get another failing test.

[sourcecode language=”fsharp”]
[<TestCase("1", Result = 1)>]
[<TestCase("2", Result = 2)>]
[<TestCase("1 2", Result = 3)>]
[<TestCase("2 3", Result = 5)>]
member x.Add_single_number_returns_that_number expression =
calculator.Add expression
[/sourcecode]

I’ll add the following code to implement and get a passing test.

[sourcecode language=”fsharp”]
type Calculator() =
member x.Add expression =
match expression with
| "" -> 0
| _ when expression.Contains " " ->
let numbers = expression.Split [| ‘ ‘ |]
(Int32.Parse numbers.[0]) + (Int32.Parse numbers.[1])
| _ -> Int32.Parse expression
[/sourcecode]

Ok. So that part of the match looks for an empty space, and then takes the two numbers opposite sides of that empty space (array item 0 and 1) and then parses them and adds them together. Keep in mind that ‘ ‘ signifies a single character, and not a string, even though for the contains method that executes on a string, passing in a string with ” ” is ok and the appropriate actions are taken by the compiler.

For the tests I’m going to do a refactor and break them apart just a bit and rename them using the “ xyz “ technique of methods. After the refactor the code looked like this. I got this idea from the “Use F# to write unit tests with readable names” tip.

[sourcecode language=”fsharp”]
[<TestFixture>]
type CalculatorTests() =
[<Test>]
member x.“should return zero if no string value is passed in.“() =
let result = calculator.Add ""
Assert.That(result, Is.EqualTo 0)

[<TestCase("1", Result = 1)>]
[<TestCase("2", Result = 2)>]
member x.“take one number and return that number“ expression =
calculator.Add expression

[<TestCase("1 2", Result = 3)>]
[<TestCase("2 3", Result = 5)>]
member x.“add single number to single number and return sum“ expression =
calculator.Add expression
[/sourcecode]

At this point I’m going to take a break, and wrap this up in a subsequent part of this series. It’s been a fun troubleshooting and getting started string calculator kata. So stay tuned and I’ll be slinging some F# math at ya real soon.

Reference:

_______1 |> F# – Getting Started, Thinking Functionally (Notes)

Recently I took the plunge into writing F# on OS-X and Linux (Ubuntu specifically). This is the first of a new series I’m starting (along with my other ongoing series on JavaScript workflow and practices). In this article particularly I’m just going to provide an overview and notes of key paradigms in functional programming. Most of these notes are derived from a great series called “Thinking Functionally“.

#1 Thinking Functionally: Introduction

This is the article that kicks off the series. The emphasis is focused around realizing that a different way of thinking needs applied when using a functional language. The difference between functional thinking and imperative. The key topics of the series includes:

  • Mathematical Functions
  • Functions and Values
  • Types
  • Functions with Multiple Parameters
  • Defining Functions
  • Function Signatures
  • Organizing Functions

#2 Mathematical Functions

Functional programming, its paradigms and its origins, are all rooted in mathematics. A mathematical function looks something like this:

Add1(x) = x + 1

  • The set of values that can be used as input to the function is called the domain.
  • The set of possible output values from the function is called the range.
  • The function is said to map the domain to the range.

If F# the definition would look like this.

[sourcecode language=”fsharp”]
let add1 x = x + 1
[/sourcecode]

The signature of the function would look like this.

[sourcecode language=”fsharp”]
val add1 : int -> int
[/sourcecode]

Key Properties of Mathematical Functions

  • A function always gives the same output value for a given input value.
  • A function has no side effects.

Pure functions

  • They are trivially parallelizable.
  • I can use a function lazily.
  • A function only needs to be evaluated once. (i.e. memoization)
  • The function can be evaluated in any order.

Prospectively “Unhelpful” properties of mathematical functions

  • The input and output values are immutable.
  • A function always has exactly one input and one output

#3 Function Values and Simple Values

Looking at this function again:

[sourcecode language=”fsharp”]let add1 x = x + 1[/sourcecode]

The x means:

  • Accept some value from the input domain.
  • Use the name “x” to represent that value so that we can refer to it later.

It is also referred to as x is bound to the input value. In this binding it will only ever be that input value. This is not an assignment of a variable. Emphasis on the fact that there are no “variables”, only values. This is a critical part of functional thinking.

Function Values: this is a value that provides binding for a function to a name.

Simple Values: This is what one might think of as constants.

[sourcecode language=”fsharp”]let c = 5[/sourcecode]

Simple Values vs. Function Values

Both are bound to names using the keyword let. The key difference is a function needs to be application to an argument to get a result, and a simple value doesn’t, as it is the value it is.

“Values” vs. “Objects”

In F# most things are referred to as “values”, contrary to “objects” in C# (or other languages like JavaScript for that matter). A value is just a member of a domain, such as a domain of ints, string, or functions that map ints to strings. In theory a value is immutable and has no behavior attached to it. However in F#, even some primitive values have some object-like behavior such as calling a member or property with dot notation syntax like “theValue”.Length or something similar.

Naming Values

Most of the naming is the general ruleset that applies to practically every language. However there is one odd feature that comes in handy in some scenarios. Let’s say you want to have a name such as “this is my really long and flippantly ridiculous name” for a domain. Well, what you can use is the “this is my really long and flippantly ridiculous name“ to have that be the name. It’s a strange feature, but I’ll cover more of it in subsequent articles.

In F# it is also practice to name functions and values with camel case instead of pascal case (camelCase vs. PascalCase).

#4 How Types Work with Functions

Function signatures look like this, with the arrow notation.

[sourcecode language=”fsharp”]
val functionName : domain -> range
[/sourcecode]

Example functions:

[sourcecode language=”fsharp”]
let intToString x = sprintf "x is %i" x // format int to string
let stringToInt x = System.Int32.Parse(x)
[/sourcecode]

Example function signatures:

[sourcecode language=”fsharp”]
val intToString : int -> string
val stringToInt : string -> int
[/sourcecode]

This means:

  • intToString has a domain of int which it maps onto the range string.
  • stringToInt has a domain of string which it maps onto the range int.

Primitive Types

Standard known types you’d expect: string, int, float, bool, char, byte, etc.

Type Annotations

Sometimes type might not be inferred, if that is the case, the compiler can take annotations to resolve type.

[sourcecode language=”fsharp”]
let stringLength (x:string) = x.Length
let stringLengthAsInt (x:string) :int = x.Length
[/sourcecode]

Function Types as Parameters

A function that takes other functions as parameters, or returns a function, is called a higher-order function (sometimes abbreviated as HOF).

Example:

[sourcecode language=”fsharp”]
let evalWith5ThenAdd2 fn = fn 5 + 2
[/sourcecode]

The signature looks like:

[sourcecode language=”fsharp”]
val evalWith5ThenAdd2 : (int -> int) -> int
[/sourcecode]

Looking at an example executing. The example:

[sourcecode language=”fsharp”]
let times3 x = x * 3
evalWith5ThenAdd2 times3
[/sourcecode]

The signature looks like:

[sourcecode language=”fsharp”]
val times3 : int -> int
val it : int = 17
[/sourcecode]

Also these are very sensitive to types, so beward.

[sourcecode language=”fsharp”]
let times3float x = x * 3.0
evalWith5ThenAdd2 times3float
[/sourcecode]

Gives an error:

[sourcecode language=”fsharp”]
error FS0001: Type mismatch. Expecting a int -> int but
given a float -> float
[/sourcecode]

Function as Output

A function value can also be the output of a function. For example, the following function will generate an “adder” function that adds using the input value.

[sourcecode language=”fsharp”]
let adderGenerator numberToAdd = (+) numberToAdd
[/sourcecode]

Using Type Annotations to Constrain Function Types

This example:

[sourcecode language=”fsharp”]
let evalWith5ThenAdd2 fn = fn 5 +2
[/sourcecode]

Becomes this:

[sourcecode language=”fsharp”]
let evalWith5AsInt (fn:int->int) = fn 5
[/sourcecode]

…or maybe this:

[sourcecode language=”fsharp”]
let evalWith5AsFloat (fn:int->float) = fn 5
[/sourcecode]

The “unit” Type

When a function returns no output, it still requires a range, and since there isn’t a void function in mathematical functions this supplants the void as return output. This special range is called a “unit” and has one specific value only, a “()”. It is similar to a void type or a null in C# but also is not, in that it is the value “()”.

Parameterless Functions

For a WAT moment here, parameterless functions come up. In this example we might expect “unit” and “unit”.

[sourcecode language=”fsharp”]
let printHello = printf "hello world"
[/sourcecode]

But what we actually get is:

[sourcecode language=”fsharp”]
hello world
val printHello : unit = ()
[/sourcecode]

Like I said, a very WAT kind of moment. To get what we expect, we need to force the definition to have a “unit” argument, as shown.

[sourcecode language=”fsharp”]
let printHelloFn () = printf "hello world"
[/sourcecode]

Then we get what we expect.

[sourcecode language=”fsharp”]
val printHelloFn : unit -> unit
[/sourcecode]

So why is this? Well, you’ll have to dive in a little deeper and check out the F# for fun and profit “Thinking Functional” entry on “How Types Work with Functions” for the full low down on that. Suffice it I’ve documented how you get what you would expect, the writer on the site goes into the nitty gritty of what is actually happening here. Possibly, you might have guessed what is happen already. There is also some strange behavior that takes place with forcing unit types with the ignore function that you may want to read on that article too, but if you’re itching to move on, and get going faster than digging through all of this errata, keep going. I’m going to jump ahead to the last section I want to cover for this blog entry of notes, currying.

#5 Currying

Haskell Curry
Haskell Curry

Breaking multi-parameter functions into smaller one-parameter functions. The way to write a function with more than one parameter is to use a process called currying. For more history on this check out Haskell Curry the mathematician to dive deep into his work (which also covers a LOT of other things beside merely currying, like combinatory logic and Curry’s paradox for instance).

Basic example:

[sourcecode language=”fsharp”]
let printTwoParameters x y =
printfn "x=%i y=%i" x y
[/sourcecode]

This of course looks neat enough right? Well, if we look at the compiler rewrite, it gets rather interesting.

[sourcecode language=”fsharp”]
let printTwoParameters x =
let subFunction y =
printfn "x=%i y=%i" x y
subFunction
[/sourcecode]

That Non-Windows Scaffolding for OS-X and Linux |> I Broke It! But…

I dove into the ProjectScaffold solution recently to see where I could get with this project. Just like in the instructions I first cloned the project.

[sourcecode language=”bash”]
git clone
[/sourcecode]

Then executed the shell script to get an appropriate download of Paket and related tools.

[sourcecode language=”bash”]
$ ./build.sh
[/sourcecode]

On OS-X my first attempt I got scaffolding but a bad build right off. See the video below for that example.

Trying the same thing on Ubuntu gave me this issue. This issue seemed to be different from the OS-X issue so I’m working to resolve it separately.

[sourcecode language=”bash”]
adron@ubuntu ~/C/ProjectScaffold> ./build.sh
No version specified. Downloading latest stable.
Github download failed. Try downloading Paket directly from ‘nuget.org’.
Error getting response stream (Write: The authentication or decryption has failed.): SendFailure
[/sourcecode]

Then trying it on OS-X gave me this issue.  :-/

Grumble grumble, fuss, fuss, alright, going into debugging and troubleshooting mode. I made a video of the exact steps I went through.

So if you have any ideas, let me know, I’m currently looking through the code and trying out some things. Once I get this working I’ll update this blog entry below the video with the updated resolution. Thanks!

UPDATED: Dammit, the dumbest things are what always punch me in the face the hardest. I fixed it, and it didn’t require a pull request after all! When naming a project be sure to use only string characters to be safe. As I wrote in the github issue, the name “sharp-kata-01” breaks the build in a way that gives completely erroneous messages. Once I renamed it things moved forward.