Using [`recursive`](https://hypothesis.readthedocs.io/en/latest/data.html#hypothesis.strategies.recursive), I can generate simple ASTs, e.g.

```
from hypothesis import *
from hypothesis.strategies import *

def trees():
    base = integers(min_value=1, max_value=10).map(lambda n: 'x' + str(n))

    @composite
    def extend(draw, children):
        op = draw(sampled_from(['+', '-', '*', '/']))
        return (op, draw(children), draw(children))

    return recursive(base, draw)

```

Now I want to change it so I can generate boolean operations in addition to the arithmetical ones. My initial idea is to add a parameter to `trees`:

```
def trees(tpe):
    base = integers(min_value=1, max_value=10).map(lambda n: 'x' + str(n) + ': ' + tpe)

    @composite
    def extend(draw, children):
        if tpe == 'bool':
            op = draw(sampled_from(['&&', '||']))
            return (op, draw(children), draw(children))
        elif tpe == 'num':
            op = draw(sampled_from(['+', '-', '*', '/']))
            return (op, draw(children), draw(children))

    return recursive(base, draw)

```

Ok so far. But how do I mix them? That is, I also want comparison operators and the ternary operator, which would require "calling `children` with a different parameter", so to say.

The trees need to be well-typed: if the operation is `'||'` or `'&&'`, both arguments need to be boolean, arguments to `'+'` or `'<'` need to be numbers, etc. If I only had two types, I could just use `filter` (given a `type_of` function):

```
if op in ('&&', '||'):
    bool_trees = children.filter(lambda x: type_of(x) == 'bool')
    return (op, draw(bool_trees), draw(bool_trees))

```

but in the real case it wouldn't be acceptable.

Does `recursive` support this? Or is there another way? Obviously, I can directly define `trees` recursively, but that runs into [the standard problems](https://hypothesis.works/articles/recursive-data/).