Trying to use a concrete generator to fill an interface variable panics

[philandstuff]

The following test panics:

package main_test

import (
	"reflect"
	"testing"

	"github.com/leanovate/gopter"
	"github.com/leanovate/gopter/gen"
	"github.com/leanovate/gopter/prop"
)

type Box struct {
	Content interface{}
}

func BoxOf(inner gopter.Gen) gopter.Gen {
	return gen.Struct(reflect.TypeOf(Box{}), map[string]gopter.Gen{
		"Content": inner,
	})
}

func TestPanics(t *testing.T) {
	properties := gopter.NewProperties(nil)

	properties.Property("Should not panic",
		prop.ForAll(
			func(e Box) bool {
				return reflect.DeepEqual(e, Box{0})
			},
			BoxOf(gen.Int()),
		))

	properties.TestingRun(t)
}

What seems to be happening is that I can't use a generator of int to fill a variable of type interface{} in Box. What I expected to happen is for this to be fine. After all, there's nothing wrong with var i interface{} = 3 so why is there a problem with BoxOf(gen.Int())?

I can work around by using an explicit Map() to change the type of the Int() generator to interface{}:

			func(e Box) bool {
				return reflect.DeepEqual(e, Box{0})
			},
-			BoxOf(gen.Int()),
+			BoxOf(
+				gen.Int().Map(func(in *gopter.GenResult) *gopter.GenResult {
+					in.ResultType = reflect.TypeOf((*interface{})(nil)).Elem()
+					return in
+				}),
+			),
		))

	properties.TestingRun(t)

but this feels pretty heavyweight. Is it possible to get structs to accept concrete generators for interface types?