Variables in generators

[beloglazov]

Hi Karol,

I'd like to generate two lists of the same length, which I thought might look something like this:

    @qc
    def test(
        length=int_(min=0, max=10),
        list1=list_(
            of=int_(min=0),
            min_length=length, max_length=length),
        list2=list_(
            of=str_(of='abc123-', min_length=36, max_length=36),
            min_length=length, max_length=length)
    ):
        pass

However, currently it doesn't work. Would it be possible to implement such a feature?

Thanks,
Anton

[Xion]

This is the issue that I have actually faced myself and found quite cumbersome indeed. I'd probably like something similar to how py.test handles its funcargs:

def pytest_funcarg__foo(request):
    return something

def pytest_funcarg__bar(request):
    bar = request.getfuncargvalue('bar')
    return other_thing(using=bar)


def test(foo, bar):
   # ...

Of course, pyqcy has no equivalent of request object, but it could probably be done in some more implicit way, like:

@qc
def test(
        length=int_(min=0, max=10),
        list1=list_(
            of=int_(min=0),
            min_length=var('length'), max_length=var('length')),
        list2=list_(
            of=str_(of='abc123-', min_length=36, max_length=36),
            min_length=var('length'), max_length=var('length'))
    ):
        pass

There are few challenges with this approach, though, mostly in resolving the inter-variable dependencies correctly (possibly detecting circular ones). It's nothing really impossible, however :)

[beloglazov]

I think the approach you suggested in sufficient. Although it's challenging, as you mentioned, it would be nice to see it implemented.

BTW, what do you think about adding another parameter to the sequence generators called 'length', which could be used for fixed length sequences instead of using a pair of min and max?

[Xion]

It could work. But length is important parameter when it comes to implementing the all-too-awesome "shrink" operation, so I need to consider how any change here would affect that future implementation of shrink. Actually, though, it might make it easier, for length is essentially an equivalent of size from original Haskell's Arbitrary typeclass.