How to change the frequency of commands depending on which underlying SUT implementation we are testing?

[jasagredo]

I have experience with q-s-m, and I'm just starting with q-d. Let's say I have different frequency distributions for a couple of tests on the same state machine, depending on whether the SUT will be an on-disk implementation or an in-memory implementation.

inMemoryFreqs, onDiskFreqs :: Freqs
inMemoryFreqs = { freqFoo = 1,  freqBar = 1 }
onDiskFreqs   = { freqFoo = 10, freqBar = 1 }

In q-s-m, as generator is a function field of the state machine, we can provide arguments to it. This allows us to use the same test definition for different distributions of commands.

sm :: Freqs -> StateMachine ...
sm freqs = StateMachine ... (generator freqs) ...

generator :: Freqs -> Model r -> Maybe (Gen (Command r))
generator freqs _ = Just $
    frequency 
        [ (freqFoo freqs, genFoo)
        , (freqBar freqs, genBar)
        ]

In q-d, as arbitraryAction is a method of StateModel, it doesn't seem to be a way of providing this depending on what test we want to run. Is one forced now to define two StateModel instances with different generators on each? This is not ideal as we would have to replicate all the rest of the machinery. Maybe using a newtype wrapper over the Model such that we forward all methods in the class to the ones of the real Model except the generator? This looks like a lot of code, but perhaps it is the only way to do it? Notice one would have to replicate RunModel too.

instance StateModel Model where
  data Action Model a where
    Foo :: Action Model ()
    Bar :: Action Model ()

  arbitraryAction = undefined
  ...

class EmbedAction m n where
  embedAction :: Action m a -> Action n a

genAction:: EmbedAction Model (m Model) => Freqs -> m Model -> Gen (Any (Action m))
genAction freqs _ =
    frequency 
        [ (freqFoo freqs, Some . embedAction <$> genFoo)
        , (freqBar freqs, Some . embedAction <$> genBar)
        ]

newtype InMemory m = InMemory m

instance StateModel (InMemory Model) where
  data Action (InMemory Model) a where
    ActA :: Action Model a -> Action (InMemory Model) a
  
  arbitraryAction = genAction inMemoryFreqs
  ...

instance EmbedAction Model (InMemory Model) where
  embedAction = ActA

newtype OnDisk m = OnDisk m

instance StateModel (OnDisk Model) where
  data Action (OnDisk Model) a where
    ActB :: Action Model a -> Action (OnDisk Model) a
  
  arbitraryAction = genAction onDiskFreqs
  ...

instance EmbedAction Model (OnDisk Model) where
  embedAction = ActB

[ghost]

It's possible that what you are trying to do could be better expressed using DL expression as it provides a way to generate arbitrary values as part of the property tested, eg. forAllQ.

You could also perhaps keep a single model and have your StateModel instance take a parameterised type, eg.

instance Arbitrary a=> StateModel (Model a) where
    data Action (Model a) r where 
   ...
   arbitraryAction = ...

Also, I don't understand why you would need different RunModel