trackler 2.2.1.88 → 2.2.1.89

data/tracks/fsharp/exercises/bracket-push/BracketPushTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module BracketPushTest
 

data/tracks/fsharp/exercises/change/ChangeTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module ChangeTest
 

data/tracks/fsharp/exercises/collatz-conjecture/CollatzConjectureTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.1 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module CollatzConjectureTest
 

data/tracks/fsharp/exercises/connect/ConnectTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module ConnectTest
 

data/tracks/fsharp/exercises/crypto-square/CryptoSquareTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 3.1.0 of the canonical data.
+// This file was auto-generated based on version 3.2.0 of the canonical data.
 
 module CryptoSquareTest
 

data/tracks/fsharp/exercises/difference-of-squares/DifferenceOfSquaresTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 module DifferenceOfSquaresTest
 

data/tracks/fsharp/exercises/dominoes/DominoesTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 2.0.0 of the canonical data.
+// This file was auto-generated based on version 2.1.0 of the canonical data.
 
 module DominoesTest
 
@@ -9,61 +9,61 @@ open Dominoes
 
 [<Fact>]
 let ``Empty input = empty output`` () =
-    let input = []
-    canChain input |> should equal true
+    let dominoes = []
+    canChain dominoes |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Singleton input = singleton output`` () =
-    let input = [(1, 1)]
-    canChain input |> should equal true
+    let dominoes = [(1, 1)]
+    canChain dominoes |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Singleton that can't be chained`` () =
-    let input = [(1, 2)]
-    canChain input |> should equal false
+    let dominoes = [(1, 2)]
+    canChain dominoes |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Three elements`` () =
-    let input = [(1, 2); (3, 1); (2, 3)]
-    canChain input |> should equal true
+    let dominoes = [(1, 2); (3, 1); (2, 3)]
+    canChain dominoes |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can reverse dominoes`` () =
-    let input = [(1, 2); (1, 3); (2, 3)]
-    canChain input |> should equal true
+    let dominoes = [(1, 2); (1, 3); (2, 3)]
+    canChain dominoes |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Can't be chained`` () =
-    let input = [(1, 2); (4, 1); (2, 3)]
-    canChain input |> should equal false
+    let dominoes = [(1, 2); (4, 1); (2, 3)]
+    canChain dominoes |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - simple`` () =
-    let input = [(1, 1); (2, 2)]
-    canChain input |> should equal false
+    let dominoes = [(1, 1); (2, 2)]
+    canChain dominoes |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - double loop`` () =
-    let input = [(1, 2); (2, 1); (3, 4); (4, 3)]
-    canChain input |> should equal false
+    let dominoes = [(1, 2); (2, 1); (3, 4); (4, 3)]
+    canChain dominoes |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Disconnected - single isolated`` () =
-    let input = [(1, 2); (2, 3); (3, 1); (4, 4)]
-    canChain input |> should equal false
+    let dominoes = [(1, 2); (2, 3); (3, 1); (4, 4)]
+    canChain dominoes |> should equal false
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Need backtrack`` () =
-    let input = [(1, 2); (2, 3); (3, 1); (2, 4); (2, 4)]
-    canChain input |> should equal true
+    let dominoes = [(1, 2); (2, 3); (3, 1); (2, 4); (2, 4)]
+    canChain dominoes |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Separate loops`` () =
-    let input = [(1, 2); (2, 3); (3, 1); (1, 1); (2, 2); (3, 3)]
-    canChain input |> should equal true
+    let dominoes = [(1, 2); (2, 3); (3, 1); (1, 1); (2, 2); (3, 3)]
+    canChain dominoes |> should equal true
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Nine elements`` () =
-    let input = [(1, 2); (5, 3); (3, 1); (1, 2); (2, 4); (1, 6); (2, 3); (3, 4); (5, 6)]
-    canChain input |> should equal true
+    let dominoes = [(1, 2); (5, 3); (3, 1); (1, 2); (2, 4); (1, 6); (2, 3); (3, 4); (5, 6)]
+    canChain dominoes |> should equal true
 

data/tracks/fsharp/exercises/etl/EtlTest.fs

@@ -9,13 +9,13 @@ open Etl
 
 [<Fact>]
 let ``A single letter`` () =
-    let input = [(1, ['A'])] |> Map.ofList
+    let lettersByScore = [(1, ['A'])] |> Map.ofList
     let expected = [('a', 1)] |> Map.ofList
-    transform input |> should equal expected
+    transform lettersByScore |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Single score with multiple letters`` () =
-    let input = [(1, ['A'; 'E'; 'I'; 'O'; 'U'])] |> Map.ofList
+    let lettersByScore = [(1, ['A'; 'E'; 'I'; 'O'; 'U'])] |> Map.ofList
     let expected = 
         [ ('a', 1);
           ('e', 1);
@@ -23,11 +23,11 @@ let ``Single score with multiple letters`` () =
           ('o', 1);
           ('u', 1) ]
         |> Map.ofList
-    transform input |> should equal expected
+    transform lettersByScore |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Multiple scores with multiple letters`` () =
-    let input = 
+    let lettersByScore = 
         [ (1, ['A'; 'E']);
           (2, ['D'; 'G']) ]
         |> Map.ofList
@@ -37,11 +37,11 @@ let ``Multiple scores with multiple letters`` () =
           ('e', 1);
           ('g', 2) ]
         |> Map.ofList
-    transform input |> should equal expected
+    transform lettersByScore |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Multiple scores with differing numbers of letters`` () =
-    let input = 
+    let lettersByScore = 
         [ (1, ['A'; 'E'; 'I'; 'O'; 'U'; 'L'; 'N'; 'R'; 'S'; 'T']);
           (2, ['D'; 'G']);
           (3, ['B'; 'C'; 'M'; 'P']);
@@ -78,5 +78,5 @@ let ``Multiple scores with differing numbers of letters`` () =
           ('y', 4);
           ('z', 10) ]
         |> Map.ofList
-    transform input |> should equal expected
+    transform lettersByScore |> should equal expected
 

data/tracks/fsharp/exercises/isbn-verifier/IsbnVerifierTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 2.0.0 of the canonical data.
+// This file was auto-generated based on version 2.2.0 of the canonical data.
 
 module IsbnVerifierTest
 
@@ -59,3 +59,7 @@ let ``Too long isbn`` () =
 let ``Check digit of X should not be used for 0`` () =
     isValid "3-598-21515-X" |> should equal false
 
+[<Fact(Skip = "Remove to run test")>]
+let ``Empty isbn`` () =
+    isValid "" |> should equal false
+

data/tracks/fsharp/exercises/luhn/LuhnTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module LuhnTest
 

data/tracks/fsharp/exercises/meetup/Example.fs

@@ -2,18 +2,18 @@
 
 open System
 
-type Schedule = First | Second | Third | Fourth | Last | Teenth
+type Week = First | Second | Third | Fourth | Last | Teenth
 
-let meetup year month dayOfWeek schedule = 
+let meetup year month week dayOfWeek = 
     let daysOfWeek = 
-        [1..DateTime.DaysInMonth(year, month)]
-        |> List.map (fun day -> new DateTime(year, month, day))
+        [1 .. DateTime.DaysInMonth(year, month)]
+        |> List.map (fun day -> DateTime(year, month, day))
         |> List.filter (fun date -> date.DayOfWeek = dayOfWeek)
                
-    match schedule with
-    | Schedule.First  -> daysOfWeek |> List.item 0
-    | Schedule.Second -> daysOfWeek |> List.item 1
-    | Schedule.Third  -> daysOfWeek |> List.item 2
-    | Schedule.Fourth -> daysOfWeek |> List.item 3
-    | Schedule.Last   -> daysOfWeek |> List.last 
-    | Schedule.Teenth -> daysOfWeek |> List.find (fun date -> date.Day >= 13)
+    match week with
+    | Week.First  -> daysOfWeek |> List.item 0
+    | Week.Second -> daysOfWeek |> List.item 1
+    | Week.Third  -> daysOfWeek |> List.item 2
+    | Week.Fourth -> daysOfWeek |> List.item 3
+    | Week.Last   -> daysOfWeek |> List.last 
+    | Week.Teenth -> daysOfWeek |> List.find (fun date -> date.Day >= 13)

data/tracks/fsharp/exercises/meetup/Meetup.fs

@@ -2,6 +2,6 @@
 
 open System
 
-type Schedule = First | Second | Third | Fourth | Last | Teenth
+type Week = First | Second | Third | Fourth | Last | Teenth
 
-let meetup year month dayOfWeek schedule: DateTime = failwith "You need to implement this function."
+let meetup year month week dayOfWeek: DateTime = failwith "You need to implement this function."

data/tracks/fsharp/exercises/meetup/MeetupTest.fs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 module MeetupTest
 
@@ -10,381 +10,381 @@ open Meetup
 
 [<Fact>]
 let ``Monteenth of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Monday Schedule.Teenth |> should equal (DateTime(2013, 5, 13))
+    meetup 2013 5 Week.Teenth DayOfWeek.Monday |> should equal (DateTime(2013, 5, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Monteenth of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Monday Schedule.Teenth |> should equal (DateTime(2013, 8, 19))
+    meetup 2013 8 Week.Teenth DayOfWeek.Monday |> should equal (DateTime(2013, 8, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Monteenth of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Monday Schedule.Teenth |> should equal (DateTime(2013, 9, 16))
+    meetup 2013 9 Week.Teenth DayOfWeek.Monday |> should equal (DateTime(2013, 9, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Tuesteenth of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Tuesday Schedule.Teenth |> should equal (DateTime(2013, 3, 19))
+    meetup 2013 3 Week.Teenth DayOfWeek.Tuesday |> should equal (DateTime(2013, 3, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Tuesteenth of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Tuesday Schedule.Teenth |> should equal (DateTime(2013, 4, 16))
+    meetup 2013 4 Week.Teenth DayOfWeek.Tuesday |> should equal (DateTime(2013, 4, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Tuesteenth of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Tuesday Schedule.Teenth |> should equal (DateTime(2013, 8, 13))
+    meetup 2013 8 Week.Teenth DayOfWeek.Tuesday |> should equal (DateTime(2013, 8, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Wednesteenth of January 2013`` () =
-    meetup 2013 1 DayOfWeek.Wednesday Schedule.Teenth |> should equal (DateTime(2013, 1, 16))
+    meetup 2013 1 Week.Teenth DayOfWeek.Wednesday |> should equal (DateTime(2013, 1, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Wednesteenth of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Wednesday Schedule.Teenth |> should equal (DateTime(2013, 2, 13))
+    meetup 2013 2 Week.Teenth DayOfWeek.Wednesday |> should equal (DateTime(2013, 2, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Wednesteenth of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Wednesday Schedule.Teenth |> should equal (DateTime(2013, 6, 19))
+    meetup 2013 6 Week.Teenth DayOfWeek.Wednesday |> should equal (DateTime(2013, 6, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Thursteenth of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Thursday Schedule.Teenth |> should equal (DateTime(2013, 5, 16))
+    meetup 2013 5 Week.Teenth DayOfWeek.Thursday |> should equal (DateTime(2013, 5, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Thursteenth of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Thursday Schedule.Teenth |> should equal (DateTime(2013, 6, 13))
+    meetup 2013 6 Week.Teenth DayOfWeek.Thursday |> should equal (DateTime(2013, 6, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Thursteenth of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Thursday Schedule.Teenth |> should equal (DateTime(2013, 9, 19))
+    meetup 2013 9 Week.Teenth DayOfWeek.Thursday |> should equal (DateTime(2013, 9, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Friteenth of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Friday Schedule.Teenth |> should equal (DateTime(2013, 4, 19))
+    meetup 2013 4 Week.Teenth DayOfWeek.Friday |> should equal (DateTime(2013, 4, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Friteenth of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Friday Schedule.Teenth |> should equal (DateTime(2013, 8, 16))
+    meetup 2013 8 Week.Teenth DayOfWeek.Friday |> should equal (DateTime(2013, 8, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Friteenth of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Friday Schedule.Teenth |> should equal (DateTime(2013, 9, 13))
+    meetup 2013 9 Week.Teenth DayOfWeek.Friday |> should equal (DateTime(2013, 9, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Saturteenth of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Saturday Schedule.Teenth |> should equal (DateTime(2013, 2, 16))
+    meetup 2013 2 Week.Teenth DayOfWeek.Saturday |> should equal (DateTime(2013, 2, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Saturteenth of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Saturday Schedule.Teenth |> should equal (DateTime(2013, 4, 13))
+    meetup 2013 4 Week.Teenth DayOfWeek.Saturday |> should equal (DateTime(2013, 4, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Saturteenth of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Saturday Schedule.Teenth |> should equal (DateTime(2013, 10, 19))
+    meetup 2013 10 Week.Teenth DayOfWeek.Saturday |> should equal (DateTime(2013, 10, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sunteenth of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Sunday Schedule.Teenth |> should equal (DateTime(2013, 5, 19))
+    meetup 2013 5 Week.Teenth DayOfWeek.Sunday |> should equal (DateTime(2013, 5, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sunteenth of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Sunday Schedule.Teenth |> should equal (DateTime(2013, 6, 16))
+    meetup 2013 6 Week.Teenth DayOfWeek.Sunday |> should equal (DateTime(2013, 6, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Sunteenth of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Sunday Schedule.Teenth |> should equal (DateTime(2013, 10, 13))
+    meetup 2013 10 Week.Teenth DayOfWeek.Sunday |> should equal (DateTime(2013, 10, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Monday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Monday Schedule.First |> should equal (DateTime(2013, 3, 4))
+    meetup 2013 3 Week.First DayOfWeek.Monday |> should equal (DateTime(2013, 3, 4))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Monday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Monday Schedule.First |> should equal (DateTime(2013, 4, 1))
+    meetup 2013 4 Week.First DayOfWeek.Monday |> should equal (DateTime(2013, 4, 1))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Tuesday of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Tuesday Schedule.First |> should equal (DateTime(2013, 5, 7))
+    meetup 2013 5 Week.First DayOfWeek.Tuesday |> should equal (DateTime(2013, 5, 7))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Tuesday of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Tuesday Schedule.First |> should equal (DateTime(2013, 6, 4))
+    meetup 2013 6 Week.First DayOfWeek.Tuesday |> should equal (DateTime(2013, 6, 4))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Wednesday of July 2013`` () =
-    meetup 2013 7 DayOfWeek.Wednesday Schedule.First |> should equal (DateTime(2013, 7, 3))
+    meetup 2013 7 Week.First DayOfWeek.Wednesday |> should equal (DateTime(2013, 7, 3))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Wednesday of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Wednesday Schedule.First |> should equal (DateTime(2013, 8, 7))
+    meetup 2013 8 Week.First DayOfWeek.Wednesday |> should equal (DateTime(2013, 8, 7))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Thursday of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Thursday Schedule.First |> should equal (DateTime(2013, 9, 5))
+    meetup 2013 9 Week.First DayOfWeek.Thursday |> should equal (DateTime(2013, 9, 5))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Thursday of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Thursday Schedule.First |> should equal (DateTime(2013, 10, 3))
+    meetup 2013 10 Week.First DayOfWeek.Thursday |> should equal (DateTime(2013, 10, 3))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Friday of November 2013`` () =
-    meetup 2013 11 DayOfWeek.Friday Schedule.First |> should equal (DateTime(2013, 11, 1))
+    meetup 2013 11 Week.First DayOfWeek.Friday |> should equal (DateTime(2013, 11, 1))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Friday of December 2013`` () =
-    meetup 2013 12 DayOfWeek.Friday Schedule.First |> should equal (DateTime(2013, 12, 6))
+    meetup 2013 12 Week.First DayOfWeek.Friday |> should equal (DateTime(2013, 12, 6))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Saturday of January 2013`` () =
-    meetup 2013 1 DayOfWeek.Saturday Schedule.First |> should equal (DateTime(2013, 1, 5))
+    meetup 2013 1 Week.First DayOfWeek.Saturday |> should equal (DateTime(2013, 1, 5))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Saturday of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Saturday Schedule.First |> should equal (DateTime(2013, 2, 2))
+    meetup 2013 2 Week.First DayOfWeek.Saturday |> should equal (DateTime(2013, 2, 2))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Sunday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Sunday Schedule.First |> should equal (DateTime(2013, 3, 3))
+    meetup 2013 3 Week.First DayOfWeek.Sunday |> should equal (DateTime(2013, 3, 3))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Sunday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Sunday Schedule.First |> should equal (DateTime(2013, 4, 7))
+    meetup 2013 4 Week.First DayOfWeek.Sunday |> should equal (DateTime(2013, 4, 7))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Monday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Monday Schedule.Second |> should equal (DateTime(2013, 3, 11))
+    meetup 2013 3 Week.Second DayOfWeek.Monday |> should equal (DateTime(2013, 3, 11))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Monday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Monday Schedule.Second |> should equal (DateTime(2013, 4, 8))
+    meetup 2013 4 Week.Second DayOfWeek.Monday |> should equal (DateTime(2013, 4, 8))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Tuesday of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Tuesday Schedule.Second |> should equal (DateTime(2013, 5, 14))
+    meetup 2013 5 Week.Second DayOfWeek.Tuesday |> should equal (DateTime(2013, 5, 14))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Tuesday of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Tuesday Schedule.Second |> should equal (DateTime(2013, 6, 11))
+    meetup 2013 6 Week.Second DayOfWeek.Tuesday |> should equal (DateTime(2013, 6, 11))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Wednesday of July 2013`` () =
-    meetup 2013 7 DayOfWeek.Wednesday Schedule.Second |> should equal (DateTime(2013, 7, 10))
+    meetup 2013 7 Week.Second DayOfWeek.Wednesday |> should equal (DateTime(2013, 7, 10))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Wednesday of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Wednesday Schedule.Second |> should equal (DateTime(2013, 8, 14))
+    meetup 2013 8 Week.Second DayOfWeek.Wednesday |> should equal (DateTime(2013, 8, 14))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Thursday of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Thursday Schedule.Second |> should equal (DateTime(2013, 9, 12))
+    meetup 2013 9 Week.Second DayOfWeek.Thursday |> should equal (DateTime(2013, 9, 12))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Thursday of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Thursday Schedule.Second |> should equal (DateTime(2013, 10, 10))
+    meetup 2013 10 Week.Second DayOfWeek.Thursday |> should equal (DateTime(2013, 10, 10))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Friday of November 2013`` () =
-    meetup 2013 11 DayOfWeek.Friday Schedule.Second |> should equal (DateTime(2013, 11, 8))
+    meetup 2013 11 Week.Second DayOfWeek.Friday |> should equal (DateTime(2013, 11, 8))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Friday of December 2013`` () =
-    meetup 2013 12 DayOfWeek.Friday Schedule.Second |> should equal (DateTime(2013, 12, 13))
+    meetup 2013 12 Week.Second DayOfWeek.Friday |> should equal (DateTime(2013, 12, 13))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Saturday of January 2013`` () =
-    meetup 2013 1 DayOfWeek.Saturday Schedule.Second |> should equal (DateTime(2013, 1, 12))
+    meetup 2013 1 Week.Second DayOfWeek.Saturday |> should equal (DateTime(2013, 1, 12))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Saturday of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Saturday Schedule.Second |> should equal (DateTime(2013, 2, 9))
+    meetup 2013 2 Week.Second DayOfWeek.Saturday |> should equal (DateTime(2013, 2, 9))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Sunday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Sunday Schedule.Second |> should equal (DateTime(2013, 3, 10))
+    meetup 2013 3 Week.Second DayOfWeek.Sunday |> should equal (DateTime(2013, 3, 10))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Second Sunday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Sunday Schedule.Second |> should equal (DateTime(2013, 4, 14))
+    meetup 2013 4 Week.Second DayOfWeek.Sunday |> should equal (DateTime(2013, 4, 14))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Monday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Monday Schedule.Third |> should equal (DateTime(2013, 3, 18))
+    meetup 2013 3 Week.Third DayOfWeek.Monday |> should equal (DateTime(2013, 3, 18))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Monday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Monday Schedule.Third |> should equal (DateTime(2013, 4, 15))
+    meetup 2013 4 Week.Third DayOfWeek.Monday |> should equal (DateTime(2013, 4, 15))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Tuesday of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Tuesday Schedule.Third |> should equal (DateTime(2013, 5, 21))
+    meetup 2013 5 Week.Third DayOfWeek.Tuesday |> should equal (DateTime(2013, 5, 21))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Tuesday of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Tuesday Schedule.Third |> should equal (DateTime(2013, 6, 18))
+    meetup 2013 6 Week.Third DayOfWeek.Tuesday |> should equal (DateTime(2013, 6, 18))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Wednesday of July 2013`` () =
-    meetup 2013 7 DayOfWeek.Wednesday Schedule.Third |> should equal (DateTime(2013, 7, 17))
+    meetup 2013 7 Week.Third DayOfWeek.Wednesday |> should equal (DateTime(2013, 7, 17))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Wednesday of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Wednesday Schedule.Third |> should equal (DateTime(2013, 8, 21))
+    meetup 2013 8 Week.Third DayOfWeek.Wednesday |> should equal (DateTime(2013, 8, 21))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Thursday of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Thursday Schedule.Third |> should equal (DateTime(2013, 9, 19))
+    meetup 2013 9 Week.Third DayOfWeek.Thursday |> should equal (DateTime(2013, 9, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Thursday of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Thursday Schedule.Third |> should equal (DateTime(2013, 10, 17))
+    meetup 2013 10 Week.Third DayOfWeek.Thursday |> should equal (DateTime(2013, 10, 17))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Friday of November 2013`` () =
-    meetup 2013 11 DayOfWeek.Friday Schedule.Third |> should equal (DateTime(2013, 11, 15))
+    meetup 2013 11 Week.Third DayOfWeek.Friday |> should equal (DateTime(2013, 11, 15))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Friday of December 2013`` () =
-    meetup 2013 12 DayOfWeek.Friday Schedule.Third |> should equal (DateTime(2013, 12, 20))
+    meetup 2013 12 Week.Third DayOfWeek.Friday |> should equal (DateTime(2013, 12, 20))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Saturday of January 2013`` () =
-    meetup 2013 1 DayOfWeek.Saturday Schedule.Third |> should equal (DateTime(2013, 1, 19))
+    meetup 2013 1 Week.Third DayOfWeek.Saturday |> should equal (DateTime(2013, 1, 19))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Saturday of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Saturday Schedule.Third |> should equal (DateTime(2013, 2, 16))
+    meetup 2013 2 Week.Third DayOfWeek.Saturday |> should equal (DateTime(2013, 2, 16))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Sunday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Sunday Schedule.Third |> should equal (DateTime(2013, 3, 17))
+    meetup 2013 3 Week.Third DayOfWeek.Sunday |> should equal (DateTime(2013, 3, 17))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Third Sunday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Sunday Schedule.Third |> should equal (DateTime(2013, 4, 21))
+    meetup 2013 4 Week.Third DayOfWeek.Sunday |> should equal (DateTime(2013, 4, 21))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Monday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Monday Schedule.Fourth |> should equal (DateTime(2013, 3, 25))
+    meetup 2013 3 Week.Fourth DayOfWeek.Monday |> should equal (DateTime(2013, 3, 25))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Monday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Monday Schedule.Fourth |> should equal (DateTime(2013, 4, 22))
+    meetup 2013 4 Week.Fourth DayOfWeek.Monday |> should equal (DateTime(2013, 4, 22))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Tuesday of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Tuesday Schedule.Fourth |> should equal (DateTime(2013, 5, 28))
+    meetup 2013 5 Week.Fourth DayOfWeek.Tuesday |> should equal (DateTime(2013, 5, 28))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Tuesday of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Tuesday Schedule.Fourth |> should equal (DateTime(2013, 6, 25))
+    meetup 2013 6 Week.Fourth DayOfWeek.Tuesday |> should equal (DateTime(2013, 6, 25))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Wednesday of July 2013`` () =
-    meetup 2013 7 DayOfWeek.Wednesday Schedule.Fourth |> should equal (DateTime(2013, 7, 24))
+    meetup 2013 7 Week.Fourth DayOfWeek.Wednesday |> should equal (DateTime(2013, 7, 24))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Wednesday of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Wednesday Schedule.Fourth |> should equal (DateTime(2013, 8, 28))
+    meetup 2013 8 Week.Fourth DayOfWeek.Wednesday |> should equal (DateTime(2013, 8, 28))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Thursday of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Thursday Schedule.Fourth |> should equal (DateTime(2013, 9, 26))
+    meetup 2013 9 Week.Fourth DayOfWeek.Thursday |> should equal (DateTime(2013, 9, 26))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Thursday of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Thursday Schedule.Fourth |> should equal (DateTime(2013, 10, 24))
+    meetup 2013 10 Week.Fourth DayOfWeek.Thursday |> should equal (DateTime(2013, 10, 24))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Friday of November 2013`` () =
-    meetup 2013 11 DayOfWeek.Friday Schedule.Fourth |> should equal (DateTime(2013, 11, 22))
+    meetup 2013 11 Week.Fourth DayOfWeek.Friday |> should equal (DateTime(2013, 11, 22))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Friday of December 2013`` () =
-    meetup 2013 12 DayOfWeek.Friday Schedule.Fourth |> should equal (DateTime(2013, 12, 27))
+    meetup 2013 12 Week.Fourth DayOfWeek.Friday |> should equal (DateTime(2013, 12, 27))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Saturday of January 2013`` () =
-    meetup 2013 1 DayOfWeek.Saturday Schedule.Fourth |> should equal (DateTime(2013, 1, 26))
+    meetup 2013 1 Week.Fourth DayOfWeek.Saturday |> should equal (DateTime(2013, 1, 26))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Saturday of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Saturday Schedule.Fourth |> should equal (DateTime(2013, 2, 23))
+    meetup 2013 2 Week.Fourth DayOfWeek.Saturday |> should equal (DateTime(2013, 2, 23))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Sunday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Sunday Schedule.Fourth |> should equal (DateTime(2013, 3, 24))
+    meetup 2013 3 Week.Fourth DayOfWeek.Sunday |> should equal (DateTime(2013, 3, 24))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Fourth Sunday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Sunday Schedule.Fourth |> should equal (DateTime(2013, 4, 28))
+    meetup 2013 4 Week.Fourth DayOfWeek.Sunday |> should equal (DateTime(2013, 4, 28))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Monday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Monday Schedule.Last |> should equal (DateTime(2013, 3, 25))
+    meetup 2013 3 Week.Last DayOfWeek.Monday |> should equal (DateTime(2013, 3, 25))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Monday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Monday Schedule.Last |> should equal (DateTime(2013, 4, 29))
+    meetup 2013 4 Week.Last DayOfWeek.Monday |> should equal (DateTime(2013, 4, 29))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Tuesday of May 2013`` () =
-    meetup 2013 5 DayOfWeek.Tuesday Schedule.Last |> should equal (DateTime(2013, 5, 28))
+    meetup 2013 5 Week.Last DayOfWeek.Tuesday |> should equal (DateTime(2013, 5, 28))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Tuesday of June 2013`` () =
-    meetup 2013 6 DayOfWeek.Tuesday Schedule.Last |> should equal (DateTime(2013, 6, 25))
+    meetup 2013 6 Week.Last DayOfWeek.Tuesday |> should equal (DateTime(2013, 6, 25))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Wednesday of July 2013`` () =
-    meetup 2013 7 DayOfWeek.Wednesday Schedule.Last |> should equal (DateTime(2013, 7, 31))
+    meetup 2013 7 Week.Last DayOfWeek.Wednesday |> should equal (DateTime(2013, 7, 31))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Wednesday of August 2013`` () =
-    meetup 2013 8 DayOfWeek.Wednesday Schedule.Last |> should equal (DateTime(2013, 8, 28))
+    meetup 2013 8 Week.Last DayOfWeek.Wednesday |> should equal (DateTime(2013, 8, 28))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Thursday of September 2013`` () =
-    meetup 2013 9 DayOfWeek.Thursday Schedule.Last |> should equal (DateTime(2013, 9, 26))
+    meetup 2013 9 Week.Last DayOfWeek.Thursday |> should equal (DateTime(2013, 9, 26))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Thursday of October 2013`` () =
-    meetup 2013 10 DayOfWeek.Thursday Schedule.Last |> should equal (DateTime(2013, 10, 31))
+    meetup 2013 10 Week.Last DayOfWeek.Thursday |> should equal (DateTime(2013, 10, 31))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Friday of November 2013`` () =
-    meetup 2013 11 DayOfWeek.Friday Schedule.Last |> should equal (DateTime(2013, 11, 29))
+    meetup 2013 11 Week.Last DayOfWeek.Friday |> should equal (DateTime(2013, 11, 29))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Friday of December 2013`` () =
-    meetup 2013 12 DayOfWeek.Friday Schedule.Last |> should equal (DateTime(2013, 12, 27))
+    meetup 2013 12 Week.Last DayOfWeek.Friday |> should equal (DateTime(2013, 12, 27))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Saturday of January 2013`` () =
-    meetup 2013 1 DayOfWeek.Saturday Schedule.Last |> should equal (DateTime(2013, 1, 26))
+    meetup 2013 1 Week.Last DayOfWeek.Saturday |> should equal (DateTime(2013, 1, 26))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Saturday of February 2013`` () =
-    meetup 2013 2 DayOfWeek.Saturday Schedule.Last |> should equal (DateTime(2013, 2, 23))
+    meetup 2013 2 Week.Last DayOfWeek.Saturday |> should equal (DateTime(2013, 2, 23))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Sunday of March 2013`` () =
-    meetup 2013 3 DayOfWeek.Sunday Schedule.Last |> should equal (DateTime(2013, 3, 31))
+    meetup 2013 3 Week.Last DayOfWeek.Sunday |> should equal (DateTime(2013, 3, 31))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Sunday of April 2013`` () =
-    meetup 2013 4 DayOfWeek.Sunday Schedule.Last |> should equal (DateTime(2013, 4, 28))
+    meetup 2013 4 Week.Last DayOfWeek.Sunday |> should equal (DateTime(2013, 4, 28))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Wednesday of February 2012`` () =
-    meetup 2012 2 DayOfWeek.Wednesday Schedule.Last |> should equal (DateTime(2012, 2, 29))
+    meetup 2012 2 Week.Last DayOfWeek.Wednesday |> should equal (DateTime(2012, 2, 29))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Wednesday of December 2014`` () =
-    meetup 2014 12 DayOfWeek.Wednesday Schedule.Last |> should equal (DateTime(2014, 12, 31))
+    meetup 2014 12 Week.Last DayOfWeek.Wednesday |> should equal (DateTime(2014, 12, 31))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Last Sunday of February 2015`` () =
-    meetup 2015 2 DayOfWeek.Sunday Schedule.Last |> should equal (DateTime(2015, 2, 22))
+    meetup 2015 2 Week.Last DayOfWeek.Sunday |> should equal (DateTime(2015, 2, 22))
 
 [<Fact(Skip = "Remove to run test")>]
 let ``First Friday of December 2012`` () =
-    meetup 2012 12 DayOfWeek.Friday Schedule.First |> should equal (DateTime(2012, 12, 7))
+    meetup 2012 12 Week.First DayOfWeek.Friday |> should equal (DateTime(2012, 12, 7))