How to create a literal slice of an alias to a builtin type in Go

I have some golang code that manipulates slices of an interface type (Comparable). To test my code, I want to create some fake data and operate on it. However, I'm having trouble doing this in a way that is not incredibly tedious. The only thing I can think to do is create a new type for testing (in this case an alias of type int) that satisfies the Comparable interface, and then feed my tests literal slices of that type. I envision it looking something like the following:

type Comparable interface {
    LT(Comparable) bool
    AsFloat() float64
} 

type testInt int 
 
func (self testInt) LT(other Comparable) bool { 
    return float64(self) < other.AsFloat() 
} 
 
func (self testInt) AsFloat() float64 { 
    return float64(self) 
} 
 
func TestAFunction(t *testing.T) { 
    FunctionToTest([]Comparable{7, 4, 2, 1})
    ....
}

However, with this example, the compiler will complain that type int cannot be used as a Comparable. I understand why this is happening, but I'm not sure how to solve it. First, I don't know how to create a literal of type testInt. Second, I have to write a significant number of these functions. Working with literal ints is far more convenient for my purposes.

Is there a way to work with type aliases of builtin types such that the compiler can correctly infer the correct type of literals with a minimum of code?

Additionally, is there perhaps a better way to accomplish what I am trying to do, i.e., generate hard data that satisfies an interface for use in testing?

func NewWhatevers(a ...int) (r []Whatever) {
        r = make([]Whatever, len(a))
        for i, v := range a {
                r[i] = Whatever(v)
        }
        return
}

...

myWhatevers := NewWhatevers(7, 4, 2, 1)

There are a number of ways to accomplish this. The problem, as you correctly state, is that the Go compiler cannot automatically convert int to Comparable (since doing so would require finding all possible equivalent types, and figuring out which of those equivalent types satisfy the Comparable interface, and then if there are more than one... you get the idea). Thus, you'll have to do one of two things:

Write an explicit type conversion:

FunctionToTest([]Comparable{ testInt(7), testInt(4), testInt(2), testInt(1) })

However, if you need a lot of literals, this could get really annoying. Thus, you could also:

Write a function to convert []int to []Comparable:

func intToComparable(i []int) []Comparable {
    c := make([]Comparable, len(i))
    for i, v := range i {
        c[i] = testInt(v)
    }
    return c
}

and then you'd only have to do:

FunctionToTest(intToComparable([]int{ 7, 4, 2, 1 }))

> Additionally, is there perhaps a better way to accomplish what I am trying to do, i.e., generate hard data that satisfies an interface for use in testing?

Maybe. The problem you encountered is that []Comparable and []testInt are fundamentally different and cannot be exchanged as the underlying representation in memory is different.
If your code is less about individual item which are Comparable but more about slices of items which can be compared than you could refactor your code to work on whole Slices.

Have a look at how package sort does this: It doesn't operate on a slice of comparables but on a "comparable slice".

// FloatOrder is a slice with comparable and float-convertible elements 
type FloatOrder interface {
    Less(i, j int) bool  // Compare element i and j and return true first is less than the other
    Float(i int) float64 // Return element i as a float64
}

type testInts []int
func (n testInts) Less(i, j int) bool {return n[i] < n[j]}
func (n testInts) Float(i int) float64 { return float64(n[i]) }

func FunctionTotest(fo FloatOrder) { ... }

func TestAFunction(t *testing.T) { 
       FunctionToTest(testInts{1,2,3,4})
       ....
}

(Completely untested, illustration-only code)