Q: How to construct a generator whose types are generated via `gopter/gen`

struct_generator.go

func genStruct() gopter.Gen {
	return genStrucType().FlatMap(
		func(arg interface{}) gopter.Gen {
			// typ := arg.(reflect.Type)
			// Q: How to construct a generator?
			return nil
		},
		reflect.TypeOf((interface{})(nil)),
	)
}

// genStructType generates a Go's structure type.
func genStrucType() gopter.Gen {
	return gen.SliceOf(genStructField()).Map(
		func(arg interface{}) reflect.Type {
			av := arg.([]interface{})
			slots := make([]reflect.StructField, 0, len(av))
			for _, v := range av {
				slots = append(slots, v.(reflect.StructField))
			}
			return reflect.StructOf(slots)
		},
	)
}

// genStructField is a generator for StructField
func genStructField() gopter.Gen {
	g := gopter.CombineGens(gen.Identifier(), genSimpleType()).Map(
		func(arg interface{}) reflect.StructField {
			av := arg.([]interface{})
			return reflect.StructField{
				Name: av[0].(string),
				Type: av[1].(reflect.Type),
			}
		},
	)
	return g
}

// genSimpleType is a generator for simple types.
func genSimpleType() gopter.Gen {
	simpleTypes := make([]interface{}, 0)
	for _, v := range []reflect.Type{
		reflect.TypeOf(int8(0)),
		reflect.TypeOf(uint8(0)),
		reflect.TypeOf(int16(0)),
		reflect.TypeOf(uint16(0)),
		reflect.TypeOf(int32(0)),
		reflect.TypeOf(uint32(0)),
		reflect.TypeOf(float32(0)),
		reflect.TypeOf(int64(0)),
		reflect.TypeOf(uint64(0)),
		reflect.TypeOf(float64(0)),
		reflect.TypeOf("")} {
		simpleTypes = append(simpleTypes, v)
	}
	return gen.OneConstOf(simpleTypes...)
}