Firstly, thank you for this awesome module! It's really helpful and has both reduced the amount of test code that I have to write and increased my test coverage :)

I have a sum type switched on a field:

type T struct {
	IsIntsNotStrings bool
	Ints             []int
	Strings          []string
}

Depending on the value of IsIntsNotStrings, either Ints or Strings will be filled, but never both.

I can use muesli/combinator to generate a bunch of combinations like this:

var ts []T
combinator.Generate(&ts, struct {
	IsIntsNotStrings []bool
	Ints             []int
	Strings          []string
}, {
	IsIntsNotStrings: []bool{true},
	Ints:             []int{1, 2, 3},
})
combinator.Generate(&ts, struct {
	IsIntsNotStrings []bool
	Ints             []int
	Strings          []string
}, {
	IsIntsNotBools: []bool{false},
	Strings:        []string{"a", "b", "c"},
})

Thanks to combinator's appending of options, I end up with a nice test suite, but I have to use arrays with one element for IsIntsNotStrings and add fields to my struct that always take the zero value in my test data.

What I would like to write is this:

var ts []T
combinator.Generate(&ts, struct {
	IsIntsNotStrings bool
	Ints             []int
}, {
	IsIntNotStrings: true,
	Ints:            []int{1, 2, 3},
})
combinator.Generate(&ts, struct {
	IsIntsNotStrings bool
	Strings          []string
}, {
	IsIntsNotStrings: false,
	Strings:          []string{"a", "b", "c"},
})

What changed:

• There is less code.
• IsIntsNotBool changed from a slice of []bool to a single-valued bool, with only that single value used to generate combinations.
• Ints and Strings are only specified if their values change, otherwise the zero value is used.

(apologies for any errors in the above code - it was a manually simplified example and may contain errors, but I hope the intent is clear)