trackler 2.2.1.22 → 2.2.1.23

data/tracks/fsharp/exercises/accumulate/Accumulate.fs

@@ -0,0 +1,3 @@
+module Accumulate
+
+let accumulate<'a, 'b> (func: 'a -> 'b) (input: 'a list): 'b list = failwith "You need to implement this function."

data/tracks/fsharp/exercises/accumulate/Accumulate.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Accumulate.fs" />
+    <Compile Include="AccumulateTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/accumulate/AccumulateTest.fs

@@ -1,39 +1,35 @@
-module AccumulateTest
+module AccumulateTest
 
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Accumulate
 
 let reverse (str:string) = new string(str.ToCharArray() |> Array.rev)
 
-[<Test>]
+[<Fact>]
 let ``Empty accumulation produces empty accumulation`` () =
-    Assert.That(accumulate (fun x -> x + 1) List.empty, Is.EqualTo(List.empty))
+    accumulate (fun x -> x + 1) List.empty |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Identity accumulation returns unmodified list`` () =
-    Assert.That(accumulate id [1; 2; 3], Is.EqualTo([1; 2; 3]))
+    accumulate id [1; 2; 3] |> should equal [1; 2; 3]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Accumulate squares`` () =
-    Assert.That(accumulate (fun x -> x * x) [1; 2; 3], Is.EqualTo([1; 4; 9]))
+    accumulate (fun x -> x * x) [1; 2; 3] |> should equal [1; 4; 9]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Accumulate upcases`` () =
-    Assert.That(accumulate (fun (x:string) -> x.ToUpper()) ["hello"; "world"],
-        Is.EqualTo(["HELLO"; "WORLD"]))
+    accumulate (fun (x:string) -> x.ToUpper()) ["hello"; "world"]
+    |> should equal ["HELLO"; "WORLD"]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Accumulate reversed strings`` () =
-    Assert.That(accumulate reverse (List.ofArray ("the quick brown fox etc".Split(' '))),
-        Is.EqualTo(List.ofArray ("eht kciuq nworb xof cte".Split(' '))))
+    accumulate reverse (List.ofArray ("the quick brown fox etc".Split(' ')))
+    |> should equal (List.ofArray("eht kciuq nworb xof cte".Split(' ')))
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Accumulate within accumulate`` () =
-    Assert.That(accumulate (fun (x:string) -> String.Join(" ", accumulate (fun y -> x + y) ["1"; "2"; "3"])) ["a"; "b"; "c"],
-        Is.EqualTo(["a1 a2 a3"; "b1 b2 b3"; "c1 c2 c3"]))
+    accumulate (fun (x:string) -> String.concat " " (accumulate (fun y -> x + y) ["1"; "2"; "3"])) ["a"; "b"; "c"]
+    |> should equal ["a1 a2 a3"; "b1 b2 b3"; "c1 c2 c3"]

data/tracks/fsharp/exercises/accumulate/HINTS.md

@@ -1,3 +1,4 @@
 ## Hints
 For this exercise the following F# feature comes in handy:
 - [Tail recursion](https://blogs.msdn.microsoft.com/fsharpteam/2011/07/08/tail-calls-in-f/) Prevent stack overflows with large input by using tail recursion. While there are no test cases checking explicitly for this, using tail recursion leads to a more performant solution. Another good resource on tail recursion is [this blog post](http://blog.ploeh.dk/2015/12/22/tail-recurse/).
+- [Type inference](https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/generics/#implicitly-generic-constructs) The F# compiler can automatically infer types, which means you often don't have to add any types at all. For more information on how this works and its advantages, see [this page](https://fsharpforfunandprofit.com/posts/type-inference/).

data/tracks/fsharp/exercises/accumulate/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/acronym/Acronym.fs

@@ -0,0 +1,3 @@
+module Acronym
+
+let acronym phrase = failwith "You need to implement this function."

data/tracks/fsharp/exercises/acronym/Acronym.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Acronym.fs" />
+    <Compile Include="AcronymTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/acronym/AcronymTest.fs

@@ -1,64 +1,58 @@
 module AcronymTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Acronym
 
-[<Test>]
+[<Fact>]
 let ``Empty string abbreviated to empty string`` () =
-    Assert.That(acronym "", Is.EqualTo(""))
+    acronym "" |> should equal ""
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Basic`` () =
     let phrase = "Portable Network Graphics"
     let expected = "PNG"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Lowercase words`` () =
     let phrase = "Ruby on Rails"
     let expected = "ROR"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Camel case`` () =
     let phrase = "HyperText Markup Language"
     let expected = "HTML"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Punctuation`` () =
     let phrase = "First In, First Out"
     let expected = "FIFO"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``All-Caps words`` () =
     let phrase = "PHP: Hypertext Preprocessor"
     let expected = "PHP"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Non-acronym all-caps word`` () =
     let phrase = "GNU Image Manipulation Program"
     let expected = "GIMP"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Hyphenated`` () =
     let phrase = "Complementary metal-oxide semiconductor"
     let expected = "CMOS"
     let actual = acronym phrase
-    Assert.That(expected, Is.EqualTo(actual))
+    expected |> should equal actual

data/tracks/fsharp/exercises/acronym/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/all-your-base/AllYourBase.fs

@@ -0,0 +1,3 @@
+module AllYourBase
+
+let rebase inB inDigits outB = failwith "You need to implement this function."

data/tracks/fsharp/exercises/all-your-base/AllYourBase.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="AllYourBase.fs" />
+    <Compile Include="AllYourBaseTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/all-your-base/AllYourBaseTest.fs

@@ -1,193 +1,174 @@
-module AllYourBaseTest
+module AllYourBaseTest
 
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 
 open AllYourBase
 
-[<Test>]
+[<Fact>]
 let ``Single bit one to decimal`` () =
     let inputBase = 2
     let inputDigits = [1]
     let outputBase = 10
     let outputDigits = Some [1]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Binary to single decimal`` () =
     let inputBase = 2
     let inputDigits = [1; 0; 1]
     let outputBase = 10
     let outputDigits = Some [5]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Single decimal to binary`` () =
     let inputBase = 10
     let inputDigits = [5]
     let outputBase = 2
     let outputDigits = Some [1; 0; 1]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Binary to multiple decimal`` () =
     let inputBase = 2
     let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 10
     let outputDigits = Some [4; 2]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Decimal to binary`` () =
     let inputBase = 10
     let inputDigits = [4; 2]
     let outputBase = 2
     let outputDigits = Some [1; 0; 1; 0; 1; 0]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Trinary to hexadecimal`` () =
     let inputBase = 3
     let inputDigits = [1; 1; 2; 0]
     let outputBase = 16
     let outputDigits = Some [2; 10]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Hexadecimal to trinary`` () =
     let inputBase = 16
     let inputDigits = [2; 10]
     let outputBase = 3
     let outputDigits = Some [1; 1; 2; 0]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``15-bit integer`` () =
     let inputBase = 97
     let inputDigits = [3; 46; 60]
     let outputBase = 73
     let outputDigits = Some [6; 10; 45]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Empty list`` () =
     let inputBase = 2
     let inputDigits = []
     let outputBase = 10
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Single zero`` () =
     let inputBase = 10
     let inputDigits = [0]
     let outputBase = 2
     let outputDigits = Some [0]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Multiple zeros`` () =
     let inputBase = 10
     let inputDigits = [0; 0; 0]
     let outputBase = 2
     let outputDigits = Some [0]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Leading zeros`` () =
     let inputBase = 7
     let inputDigits = [0; 6; 0]
     let outputBase = 10
     let outputDigits = Some [4; 2]
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Negative digit`` () =
     let inputBase = 2
     let inputDigits = [1; -1; 1; 0; 1; 0]
     let outputBase = 10
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Invalid positive digit`` () =
     let inputBase = 2
     let inputDigits = [1; 2; 1; 0; 1; 0]
     let outputBase = 10
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``First base is one`` () =
     let inputBase = 1
     let inputDigits = []
     let outputBase = 10
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Second base is one`` () =
     let inputBase = 2
     let inputDigits = [1; 0; 1; 0; 1; 0]
     let outputBase = 1
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``First base is zero`` () =
     let inputBase = 0
     let inputDigits = []
     let outputBase = 10
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Second base is zero`` () =
     let inputBase = 10
     let inputDigits = [7]
     let outputBase = 0
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``First base is negative`` () =
     let inputBase = -2
     let inputDigits = [1]
     let outputBase = 10
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Second base is negative`` () =
     let inputBase = 2
     let inputDigits = [1]
     let outputBase = -7
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Both bases are negative`` () =
     let inputBase = -2
     let inputDigits = [1]
     let outputBase = -7
     let outputDigits = None
-    Assert.That(rebase inputBase inputDigits outputBase, Is.EqualTo(outputDigits))
+    rebase inputBase inputDigits outputBase |> should equal outputDigits

data/tracks/fsharp/exercises/all-your-base/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/allergies/Allergies.fs

@@ -0,0 +1,9 @@
+module Allergies
+
+open System
+
+// TODO: define the Allergen type
+
+let allergicTo allergen codedAllergies = failwith "You need to implement this function."
+
+let allergies codedAllergies = failwith "You need to implement this function."

data/tracks/fsharp/exercises/allergies/Allergies.fsproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Allergies.fs" />
+    <Compile Include="AllergiesTest.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+  </ItemGroup>
+
+</Project>

data/tracks/fsharp/exercises/allergies/AllergiesTest.fs

@@ -1,74 +1,70 @@
-module AllergiesTest
+module AllergiesTest
 
 open System
-open NUnit.Framework
+open Xunit
+open FsUnit.Xunit
 open Allergies
 
-[<Test>]
+[<Fact>]
 let ``No allergies means not allergic`` () =
-    Assert.That(allergicTo Allergen.Peanuts 0, Is.False)
-    Assert.That(allergicTo Allergen.Cats 0, Is.False)
-    Assert.That(allergicTo Allergen.Strawberries 0, Is.False)
+    allergicTo Allergen.Peanuts 0 |> should equal false
+    allergicTo Allergen.Cats 0 |> should equal false
+    allergicTo Allergen.Strawberries 0 |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to eggs`` () =
-    Assert.That(allergicTo Allergen.Eggs 1, Is.True)
+    allergicTo Allergen.Eggs 1 |> should equal true
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to eggs in addition to other stuff`` () =
-    Assert.That(allergicTo Allergen.Eggs 5, Is.True)
-    Assert.That(allergicTo Allergen.Shellfish 5, Is.True)
-    Assert.That(allergicTo Allergen.Strawberries 5, Is.False)
+    allergicTo Allergen.Eggs 5 |> should equal true
+    allergicTo Allergen.Shellfish 5 |> should equal true
+    allergicTo Allergen.Strawberries 5 |> should equal false
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``No allergies at all`` () =
-    Assert.That(allergies 0, Is.Empty)
+    allergies 0 |> should be Empty
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to just eggs`` () =
-    Assert.That(allergies 1, Is.EqualTo([Allergen.Eggs]))
+    allergies 1 |> should equal [Allergen.Eggs]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to just peanuts`` () =
-    Assert.That(allergies 2, Is.EqualTo([Allergen.Peanuts]))
+    allergies 2 |> should equal [Allergen.Peanuts]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to eggs and peanuts`` () =
-    Assert.That(allergies 3, Is.EqualTo([Allergen.Eggs; Allergen.Peanuts]))
+    allergies 3 |> should equal [Allergen.Eggs; Allergen.Peanuts]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to lots of stuff`` () =
-    Assert.That(allergies 248,
-        Is.EqualTo([Allergen.Strawberries; Allergen.Tomatoes; Allergen.Chocolate; Allergen.Pollen; Allergen.Cats]))
+    allergies 248 |> should equal 
+        [ Allergen.Strawberries; 
+          Allergen.Tomatoes;
+          Allergen.Chocolate;
+          Allergen.Pollen;
+          Allergen.Cats ]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Allergic to everything`` () =
-    Assert.That(allergies 255,
-        Is.EqualTo([Allergen.Eggs;
-                    Allergen.Peanuts;
-                    Allergen.Shellfish;
-                    Allergen.Strawberries;
-                    Allergen.Tomatoes;
-                    Allergen.Chocolate;
-                    Allergen.Pollen;
-                    Allergen.Cats]))
+    allergies 255 |> should equal 
+        [ Allergen.Eggs;
+          Allergen.Peanuts;
+          Allergen.Shellfish;
+          Allergen.Strawberries;
+          Allergen.Tomatoes;
+          Allergen.Chocolate;
+          Allergen.Pollen;
+          Allergen.Cats ]
 
-[<Test>]
-[<Ignore("Remove to run test")>]
+[<Fact(Skip = "Remove to run test")>]
 let ``Ignore non allergen score parts`` () =
-    Assert.That(allergies 509,
-        Is.EqualTo([Allergen.Eggs;
-                    Allergen.Shellfish;
-                    Allergen.Strawberries;
-                    Allergen.Tomatoes;
-                    Allergen.Chocolate;
-                    Allergen.Pollen;
-                    Allergen.Cats]))
+    allergies 509  |> should equal 
+        [ Allergen.Eggs;
+          Allergen.Shellfish;
+          Allergen.Strawberries;
+          Allergen.Tomatoes;
+          Allergen.Chocolate;
+          Allergen.Pollen;
+          Allergen.Cats ]

data/tracks/fsharp/exercises/allergies/Program.fs

@@ -0,0 +1 @@
+module Program = let [<EntryPoint>] main _ = 0

data/tracks/fsharp/exercises/alphametics/Alphametics.fs

@@ -0,0 +1,3 @@
+module Alphametics
+
+// TODO: implement this module