Simplify vars and envs

[AlexeyRaga]

Simplifying Vars and Envs

Instead of storing values in Env, Vars now store concrete values:

type Var<'T> =
    internal
    | Symbolic of 'T option
    | Concrete of 'T

This allows simplifying Var itself, but also removes the need of reflective state traversal for reporting the state.

Justification

In .NET we don't have HKT, so we don't HTraverse between symbolic and concrete state anyway. Instead, state always holds Var<'T>, so there is no need in runtime correlation between Env and Var.

This means that during execution stage we can simply create a concrete Var (with value) and pass it to Update.
Update will still not be able to distinguish between symbolic and concrete variables, as expected.

Env is still being received by execution-stage methods (Require, Execute, Ensure) and is still required by Var.Resolve because it serves the role of the capability and provides some compile-time safety: if you don't have Env you can't have access to concrete state.

Results

With this approach we:

• Have much simple Var (win for maintenance)
• Can print state naturally (win for devex debugging)
• Don't need heavy reflection traversal of state in order to print in into the report (win from any angle)
• Have less code lines :)

Report example

[moodmosaic]

Looking forward porting my hello-world example into Hedgehog.Stateful 👀 🥳

[AlexeyRaga]

@moodmosaic kind of have it in tests: https://github.com/hedgehogqa/fsharp-hedgehog/blob/master/tests/Hedgehog.Stateful.Tests.FSharp/SequentialCounterSpec.fs ;)

[moodmosaic]

What Resolve means in oldState.CurrentCount.Resolve(env)?

[AlexeyRaga]

Resolve is the way to obtain Var's value.
In particular, oldState.CurrentCount.Resolve(env) means "give me the value from the old (before update) state".

[moodmosaic]

Do you have a use case for it?

[AlexeyRaga]

Anything to assess that the state has changed in an expected way (or not changed).
For example, if you want to assert that the counter has been incremented by an expected value (from the input).
Or that if, when you change the door lock code, the door remains locked...

Similarly how Haskell version defines.

Ensure (state Concrete -> state Concrete -> input Concrete -> output -> Test ())