Extend the use of the KoanAttribute to work on classes and provide a …

…facility to specify the sort order.

FSharpKoans.Core/KoanAttribute.fs

@@ -2,6 +2,10 @@
 
 open System
 
-[<AttributeUsage(AttributeTargets.Method, AllowMultiple = false)>]
+[<AttributeUsage(AttributeTargets.Class ||| AttributeTargets.Method, AllowMultiple = false)>]
 type KoanAttribute () =
     inherit Attribute()
+    let mutable sortOrder = 0
+    member x.Sort
+        with get() = sortOrder
+        and set(v) = sortOrder <- v

FSharpKoans.Core/KoanRunner.fs

@@ -32,7 +32,10 @@ type KoanRunner(containers) =
     new () =
         let containers =
             Assembly.GetCallingAssembly().GetTypes()
-            |> Array.filter (not << Seq.isEmpty << KoanContainer.findKoanMethods)
+            |> Array.map (fun t -> t, t.GetCustomAttributes(typeof<KoanAttribute>, true))
+            |> Array.filter (not << Seq.isEmpty << snd)
+            |> Array.sortBy (fun (t, attrs) -> (attrs.[0] :?> KoanAttribute).Sort)
+            |> Array.map fst
         KoanRunner(containers)
 
     member this.ExecuteKoans() =

FSharpKoans/AboutArrays.fs

@@ -7,6 +7,7 @@ open System.Collections.Generic
 //
 // Like lists, arrays are another basic container type in F#.
 //---------------------------------------------------------------
+[<Koan(Sort = 11)>]
 module ``about arrays`` =
     [<Koan>]
     let CreatingArrays() =

FSharpKoans/AboutAsserts.fs

@@ -1,6 +1,7 @@
 namespace FSharpKoans
 open FSharpKoans.Core
 
+[<Koan(Sort = 1)>]
 module ``about asserts`` =
 
     // We shall contemplate truth by testing reality, via asserts.

FSharpKoans/AboutBranching.fs

@@ -7,6 +7,7 @@ open FSharpKoans.Core
 // Branching is used to tell a program to conditionally perform
 // an operation. It's another fundamental part of F#.
 //---------------------------------------------------------------
+[<Koan(Sort = 8)>]
 module ``about branching`` =
 
     [<Koan>]

FSharpKoans/AboutClasses.fs

@@ -36,6 +36,7 @@ type Person2(name:string) =
     member this.Speak() =
         "Hi my name is " + this.Name
 
+[<Koan(Sort = 20)>]
 module ``about classes`` =
 
     [<Koan>]

FSharpKoans/AboutDiscriminatedUnions.fs

@@ -19,6 +19,7 @@ type Favorite =
 // of them like a much more powerful version of enums in other
 // languages.
 //---------------------------------------------------------------
+[<Koan(Sort = 18)>]
 module ``about discriminated unions`` =
     [<Koan>]
     let DiscriminatedUnionsCaptureASetOfOptions() =

FSharpKoans/AboutDotNetCollections.fs

@@ -9,6 +9,7 @@ open System.Collections.Generic
 // languages, you can use all of the basic .NET collections types
 // you're already familiar with if you're a C# or VB programmer.
 //---------------------------------------------------------------
+[<Koan(Sort = 12)>]
 module ``about dot net collections`` =
 
     [<Koan>]

FSharpKoans/AboutFunctions.fs

@@ -7,6 +7,7 @@ open FSharpKoans.Core
 // Now that you've seen how to bind a name to a value with let,
 // you'll learn to use the let keyword to create functions.
 //---------------------------------------------------------------
+[<Koan(Sort = 3)>]
 module ``about functions`` =
 
     (* By default, F# is whitespace sensitive.

FSharpKoans/AboutLet.fs

@@ -8,6 +8,7 @@ open FSharpKoans.Core
 // You'll use it in almost every line of F# code you write, so
 // let's get to know it well! (no pun intended)
 //---------------------------------------------------------------
+[<Koan(Sort = 2)>]
 module ``about let`` =
 
     [<Koan>]

FSharpKoans/AboutLists.fs

@@ -11,6 +11,7 @@ open System.Collections.Generic
 // list and perform operations across each value in the 
 // list.
 //---------------------------------------------------------------
+[<Koan(Sort = 9)>]
 module ``about lists`` =
 
     [<Koan>]

FSharpKoans/AboutLooping.fs

@@ -9,6 +9,7 @@ open FSharpKoans.Core
 // back on traditional imperative looping techniques that you may 
 // be more familiar with.
 //---------------------------------------------------------------
+[<Koan(Sort = 13)>]
 module ``about looping`` =
     [<Koan>]
     let LoopingOverAList() =

FSharpKoans/AboutModules.fs

@@ -25,6 +25,7 @@ module MushroomKingdom =
 // They're similar to .NET namespaces, but they have slightly 
 // different semantics as you'll see below.
 //---------------------------------------------------------------
+[<Koan(Sort = 19)>]
 module ``about modules`` =
 
     [<Koan>]

FSharpKoans/AboutOptionTypes.fs

@@ -15,6 +15,7 @@ type Game = {
 // in other languages. However, using option types instead of nulls
 // has subtle but far reaching benefits.
 //---------------------------------------------------------------
+[<Koan(Sort = 17)>]
 module ``about option types`` =
 
     [<Koan>]

FSharpKoans/AboutPipelining.fs

@@ -8,6 +8,7 @@ open FSharpKoans.Core
 // symbols in F# programming. You can use it combine operations
 // on lists and other data structures in a readable way.
 //---------------------------------------------------------------
+[<Koan(Sort = 10)>]
 module ``about pipelining`` =
 
     let square x =

FSharpKoans/AboutRecordTypes.fs

@@ -13,6 +13,7 @@ type Character = {
 // You can use them to group data in a more structured way than
 // tuples.
 //---------------------------------------------------------------
+[<Koan(Sort = 16)>]
 module ``about record types`` =
 
     [<Koan>]

FSharpKoans/AboutStrings.fs

@@ -7,6 +7,7 @@ open FSharpKoans.Core
 // Most languages have a set of utilities for manipulating 
 // strings. F# is no different.
 //---------------------------------------------------------------
+[<Koan(Sort = 7)>]
 module ``about strings`` =
 
     [<Koan>]

FSharpKoans/AboutTheOrderOfEvaluation.fs

@@ -8,6 +8,7 @@ open FSharpKoans.Core
 // functions are evaluated. F# offers a couple mechanisms for
 // doing this.
 //---------------------------------------------------------------
+[<Koan(Sort = 4)>]
 module ``about the order of evaluation`` =
 
     [<Koan>]

FSharpKoans/AboutTheStockExample.fs

@@ -22,6 +22,7 @@ open FSharpKoans.Core
 // let splitCommas (x:string) =
 //     x.Split([|','|])
 //---------------------------------------------------------------
+[<Koan(Sort = 15)>]
 module ``about the stock example`` =
 
     let stockData =

FSharpKoans/AboutTuples.fs

@@ -7,6 +7,7 @@ open FSharpKoans.Core
 // Tuples are used to easily group together values in F#. They're 
 // another fundamental construct of the language.
 //---------------------------------------------------------------
+[<Koan(Sort = 6)>]
 module ``about tuples`` =
 
     [<Koan>]

FSharpKoans/AboutUnit.fs

@@ -9,6 +9,7 @@ open Microsoft.FSharp.Reflection
 // a value. It's similar to void in other languages, but unit
 // is actually considered to be a type in F#.
 //---------------------------------------------------------------
+[<Koan(Sort = 5)>]
 module ``about unit`` =
 
     [<Koan>]

FSharpKoans/MoreAboutFunctions.fs

@@ -8,6 +8,7 @@ open FSharpKoans.Core
 // since F# is a functional language, there are more tricks
 // to learn!
 //---------------------------------------------------------------
+[<Koan(Sort = 14)>]
 module ``more about functions`` =
 
     [<Koan>]