InterfaceSlice.md

---
title: InterfaceSlice
---

## Introduction

Given that you can assign a variable of any type to an ` interface{} `, often people will try code like the following.
```go
var dataSlice []int = foo()
var interfaceSlice []interface{} = dataSlice
```
This gets the error
```
cannot use dataSlice (type []int) as type []interface { } in assignment
```

The question then, "Why can't I assign any slice to an ` []interface{} `, when I can assign any type to an ` interface{} `?"

### Why?

There are two main reasons for this.

The first is that a variable with type ` []interface{} ` is not an interface! It is a slice whose element type happens to be ` interface{} `. But even given this, one might say that the meaning is clear.

Well, is it? A variable with type ` []interface{} ` has a specific memory layout, known at compile time.

Each ` interface{} ` takes up two words (one word for the type of what is contained, the other word for either the contained data or a pointer to it). As a consequence, a slice with length N and with type ` []interface{} ` is backed by a chunk of data that is N\*2 words long.

This is different than the chunk of data backing a slice with type ` []MyType ` and the same length. Its chunk of data will be N\*sizeof(MyType) words long.

The result is that you cannot quickly assign something of type ` []MyType ` to something of type ` []interface{} `; the data behind them just look different.

### What can I do instead?

It depends on what you wanted to do in the first place.

If you want a container for an arbitrary array type, and you plan on changing back to the original type before doing any indexing operations, you can just use an ` interface{} `. The code will be generic (if not compile-time type-safe) and fast.

If you really want a ` []interface{} ` because you'll be doing indexing before converting back, or you are using a particular interface type and you want to use its methods, you will have to make a copy of the slice.
```go
var dataSlice []int = foo()
var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))
for i, d := range dataSlice {
	interfaceSlice[i] = d
}
```