Использование DU как гаранта последовательных шагов: module Steps =

Question

Использование DU как гаранта последовательных шагов: module Steps =

module Counter =
type T(start) =
let mutable _counter = start
member _.count = _counter
member _.next() = _counter <- _counter + 1

type T =
// тип string у этих "шагов" не более, чем условность (чисто для удобства)
| START
| S1 of string
| S2 of string
| S3 of string
// ...
// | S30 of string
| FINISH
static member Length = typeof<T>
|> FSharp.Reflection.FSharpType.GetUnionCases
|> fun x -> x.Length

let check (a: Counter.T) b =
if a.count <> b then
failwith
<| $"\n\n[ERROR] check a b | a.count=%i{a.count} b=%i{b}\n"
else
a.next ()

let step cnt arg =
let check = check cnt

match arg with
| START -> check 0; arg
| S1 _ -> check 1; arg
| S2 _ -> check 2; arg
| S3 _ -> check 3; arg
| FINISH -> check <| T.Length - 1; arg

let test () =
let step = step <| Counter.T(0)
let echo x = printfn $"%A{x}"

echo << step <| START

echo "----------------------"
echo << step <| S1 "step 1"
//echo << step <| S1 "step 1" // error
//echo << step <| FINISH // error

echo "----------------------"
echo << step <| S2 "step 2"
//echo << step <| S2 "step 2" // error
//echo << step <| S1 "step 1" // error
//echo << step <| FINISH // error

echo "----------------------"
echo << step <| S3 "step 3"
//echo << step <| S3 "step 3" // error
//echo << step <| S2 "step 2" // error
//echo << step <| S1 "step 1" // error
//echo << step <| FINISH // error

echo "----------------------"
echo << step <| FINISH

Steps.test ()

а как-то поизящнее можно того же самого добиться?