Unquote, App.config, and You

"What curious eye doth quote deformities?"
-- Shakespeare, Romeo and Juliet
Act I, Scene IV, Line 31

I've started using Unquote for my assertions with F# xUnit tests.  I find that its step-by-step failure messages really help in figuring out what is going on.

One thing that really throw me when I first used it was the System.MissingMethodException exception that Unquote was throwing at runtime.  Luckily I was able to find this StackOverflow answer.  It seems that you need to do a binding redirect for FSharp.Core, so you'll need to set up an App.config file in your test project like this example of the Coin Changer kata (using MapFold).

	<?xml version="1.0" encoding="utf-8" ?>
	<configuration>
	<runtime>
	<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
	<dependentAssembly>
	<assemblyIdentity name="FSharp.Core"
	publicKeyToken="b03f5f7f11d50a3a"
	culture="neutral"/>
	<bindingRedirect oldVersion="4.3.1.0"
	newVersion="4.4.0.0"/>
	</dependentAssembly>
	</assemblyBinding>
	</runtime>
	</configuration>

view raw App.config hosted with ❤ by GitHub

	namespace CoinChanger
	module Changer =
	let change coins amount =
	coins
	|> List.mapFold
	(fun amount coin -> List.replicate <| amount / coin <| coin, amount % coin)
	amount
	|> fst
	|> List.reduce (@)

view raw Changer.fs hosted with ❤ by GitHub

	namespace CoinChangerTests
	module ChangerTests =
	open Xunit
	open Swensen.Unquote
	open CoinChanger.Changer
	[<Theory>]
	[<InlineData(0)>]
	[<InlineData(1)>]
	[<InlineData(99)>]
	let ``given pennies it must return coins equal to amount given`` amount =
	let pennies = [1]
	test <@
	change pennies amount |> List.length = amount
	@>
	[<Theory>]
	[<InlineData(0, 10)>]
	[<InlineData(1, 5)>]
	[<InlineData(42, 25)>]
	[<InlineData(99, 20)>]
	let ``given number of coins and value it must return number of coins`` number value =
	let coins = [value]
	test <@
	change coins <| number * value |> List.length = number
	@>
	[<Theory>]
	[<InlineData(1)>]
	[<InlineData(10)>]
	[<InlineData(99)>]
	let ``given coin values it must return coins of that value`` value =
	let coins = [value]
	let amount = 99
	test <@
	let unique = change coins amount |> List.distinct
	unique |> List.length = 1
	&&
	unique |> List.head = value
	@>
	[<Fact>]
	let ``given full register and 1 of each coin it must return 1 of each coin`` () =
	let register = [25; 10; 5; 1]
	let amount = List.sum register
	test <@
	change register amount |> List.distinct = register
	@>
	[<Theory>]
	[<InlineData(0)>]
	[<InlineData(1)>]
	[<InlineData(42)>]
	[<InlineData(99)>]
	let ``given full register it must return coins summing to amount`` amount =
	let register = [25; 10; 5; 1]
	test <@
	change register amount |> List.sum = amount
	@>

view raw ChangerTests.fs hosted with ❤ by GitHub

Happy coding.

Behold the Power of Mutation!

"And – ere a man hath power to say ‘ Behold!’ –"
-- Shakespeare, A Midsummer Night's Dream
Act I, Scene I, Line 147

One of the things I found very interesting in the Pluralsight class "Exploring C# 6 with Jon Skeet" was that the new interpolated strings works with expressions.  Since C# is a mutable language we can easily abuse this!

	> $"I Love C# {((Func<int>)(() => { int x = 6; return x; }))()}!"
	"I Love C# 6!"
	> ((Func<int>)(() => { int x = 6; return x; }))()
	6
	> var six = 6;
	> six
	6
	> $"I Love C# {((Func<int>)(() => { return six; }))()}!"
	"I Love C# 6!"
	> $"I Love C# {((Func<int>)(() => { six++; return six; }))()}!"
	"I Love C# 7!"
	> var wat = $"I Love C# {((Func<int>)(() => { six++; return six; }))()}!"
	. ;
	> wat
	"I Love C# 8!"
	> wat
	"I Love C# 8!"
	> var wat = (Func<string>)(() => $"I Love C# {((Func<int>)(() => { six++; return six; }))()}!")
	. ;
	> wat()
	"I Love C# 9!"
	> wat()
	"I Love C# 10!"
	> var wat = (Func<string>)(() => $"I Love C# {((Func<int>)(() => { six++; System.Console.WriteLine(six); return six; }))()}!");
	> wat()
	11
	"I Love C# 11!"
	> var message = "They actual used it! HAHAHA! WAT!";
	> var wat = (Func<string>)(() => $"I Love C# {((Func<int>)(() => { six++; System.Console.WriteLine(message); return six; }))()}!");
	> wat()
	They actual used it! HAHAHA! WAT!
	"I Love C# 12!"
	> wat()
	They actual used it! HAHAHA! WAT!
	"I Love C# 13!"
	>

view raw repl.txt hosted with ❤ by GitHub

In the above C# REPL we see that we can we can have all kinds of fun as long as we have an expression in our interpolated string.

Example:

var intValue = 0;
var stringValue = $"{((Func)(() => { intValue++; return intValue; }))()}"

As long as the expression has a ToString value it will work.  Note, stringValue will only increment intValue once and after that it will always give the same result, but it is fun nonetheless.

Remember, never under estimate the power to abuse mutable languages!

Item and Slice F#

"Slice, I say. Pauca, pauca. Slice! That's my humour."
-- Shakespeare, The Merry Wives of Windsor
Act I, Scene I, Line 125

I've been working my way through Dave Fancher's excellent Book of F# and found an interesting example of indexing and slicing arrays in F#.  Since programming is a full contact sport, here is my take on indexing and slicing in F#.

	namespace OO
	type Words(sentence : string) =
	let words = sentence.Split ' '
	member x.Item(i) = words.[i]
	member x.GetSlice(s : int option, e : int option) =
	match s, e with
	| Some(s), Some(e) -> if e > words.Length then words.[s..] else words.[s..e]
	| Some(s), None -> words.[s..]
	| None, Some(e) -> if e > words.Length then words else words.[..e]
	| _ -> Array.empty<string>
	module Tests =
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData("quick brown fox")>]
	[<InlineData("1 2 3")>]
	[<InlineData("one two")>]
	let ``given a sentence it must be able to get the 2nd word`` (sentence : string) =
	let ``2nd`` = 1
	Words(sentence).[``2nd``] |> should equal <| sentence.Split(' ').[``2nd``]
	[<Theory>]
	[<InlineData("nope yep yep nope")>]
	[<InlineData("1 2 3")>]
	let ``given a sentence it must be able to get the 2nd and 3rd words`` (sentence : string) =
	let ``2nd`` = 1
	let ``3rd`` = 2
	Words(sentence).[``2nd``..``3rd``] |> should equal <| sentence.Split(' ').[``2nd``..``3rd``]
	[<Theory>]
	[<InlineData("nope yep yep yep")>]
	[<InlineData("1 2 3 4 5 6 7")>]
	[<InlineData("one two")>]
	let ``given a sentence it must be able to cutoff the 1st word`` (sentence : string) =
	let ``2nd`` = 1
	Words(sentence).[``2nd``..] |> should equal <| sentence.Split(' ').[``2nd``..]
	[<Theory>]
	[<InlineData("yep yep nope")>]
	[<InlineData("1 2 3 4 5 6 7")>]
	[<InlineData("one two three")>]
	let ``given a sentence it must be able to get the 1st and 2nd words`` (sentence : string) =
	let ``2nd`` = 1
	Words(sentence).[..``2nd``] |> should equal <| sentence.Split(' ').[..``2nd``]
	[<Theory>]
	[<InlineData("it is not size")>]
	[<InlineData("that matters")>]
	let ``given a sentence it must be able to slice if length is longer than number of words`` (sentence : string) =
	let longer = 100
	Words(sentence).[0..longer] |> should equal <| sentence.Split ' '
	Words(sentence).[..longer] |> should equal <| sentence.Split ' '
	[<Theory>]
	[<InlineData("a b c")>]
	[<InlineData("1 2 3 4 5 6 7 8")>]
	let ``given a sentence it must be able to slice if length is 1 beyond the end`` (sentence : string) =
	Words(sentence).[..sentence.Length] |> should equal <| sentence.Split ' '

view raw IndexExamples.fs hosted with ❤ by GitHub

We have a constructor for a type called Word which takes a string and separates it into words.

type Words(sentence : string)

We implement an index with the Item member.

member x.Item(i) = words.[i]

This allows us to access the words of the string given.

Words(sentence).[1]

We also implement an array slice with the GetSlice member.

member x.GetSlice(s : int option, e : int option)

This allows us to slice the array (substring it) of words in the string given.

Words(sentence).[1..2]

We can go one better than built in slice by allow for range in the slice to be bigger than the number of words.

let longer = 100
Words(sentence).[0..longer]

In order to allow for this we have to check to see if the end is greater than the number of words.

if e > words.Length then words.[s..] else words.[s..e]

and

if e > words.Length then words else words.[..e]

I hope I have shown that F# has some very nice support for objects.