Returning a list and getting to the items in Hedgehog state machine

Question

I have a model for a state machine that is

newtype State (v :: * -> *) = State (M.Map (Var UUID v) DataPerItem)
    deriving (Eq, Show)

I then have a Command gen exec [Update update] with exec returning a list of UUID, i.e. it has type

exec :: action -> m [UUID]

which in turns mean that update needs a type like this

update :: State v -> action -> Var [UUID] v -> State V

AFAICS I need to, in order to actually update my model, turn that Var [UUID] v into [Var UUID v]. I've been staring at the functions in Hedgehog for a while now but nothing jumps out... or am I, once again, thinking about it all wrong? :)

`Var` is documented [here](https://hackage.haskell.org/package/hedgehog-1.0.1/docs/Hedgehog.html#t:Var). — Magnus, Oct 01 '19 at 20:59
Ouch, seems to be a known, and unfixed, issue: https://github.com/hedgehogqa/haskell-hedgehog/issues/113 — Magnus, Oct 02 '19 at 13:23

score 1 · Answer 1 · answered Jun 02 '20 at 01:31

This can't work, but there's a good reason why.

Think of state machine testing as automatic writing a test programs, where each Var a Symbolic as a binding in the program.

So imagine I was testing a little buffer, with operations create :: Size -> Buf, put :: Buf -> Int -> IO () and get :: Buf -> IO Int.

I could hand roll a unit test.

test :: TestT IO ()
test = do
  buf <- create 3
  put buf 5
  put buf 10
  put buf 20
  retrieved <- get buf
  retrieved === Just 5

with appropriate commands, hedgehog could also generate this exact test as

test :: TestT IO ()
test = do
  Var 1 = create 3
  Var 2 = put (Var 1) 5
  Var 3 = put (Var 1) 10
  Var 4 = put (Var 1) 20
  Var 5 = get (Var 1)
  Var 5 === Just 5

So each execution is given a variable name.

When you way you want something like this:

splitNames :: Var [UUID] v -> [Var UUID v]

What you're asking for is essentially each return from the execution list to be given its own variable name. The rest of the program could then use those variable names. The best way I can think to show this is:

test :: TestT IO ()
test = do
  Var 1 = returnSomeNumberOfItems
  Var 2 = Var 1 ! 0
  Var 3 = Var 1 ! 1

Now the issue here is that we just don't know how long the list returned by returnSomeNumberOfItems is; we haven't run it yet; there's no way to do this safely.

The `action` _does_ specify exactly how many items will be in the list, so that's not a problem in this case. In any case, I managed to work around this by switching to `quickcheck-state-machine`. — Magnus, Jun 15 '20 at 14:24

Returning a list and getting to the items in Hedgehog state machine

1 Answers1