CODEWITHSUNDEEP
go
Ben Guild
Ben Guild

Reputation: 5126

Restore type information after passing through function as "interface {}"?

I'm running into a slight architectural problem with Golang right now that's causing me to copy/paste a bit more code than I'd prefer. I feel like there must be a solution, so please let me know if this is perhaps possible:

When I pass things through an interface {}-typed function parameter, I start getting errors such as "expected struct or slice", etc. ... even though what I passed was previously a struct or a slice. I realize that I could manually convert these to another type after receiving them in that function, but then that become tedious in instances such as this:

local interface type *interface {} can only be decoded from remote interface type; received concrete type

... In this case, the receiving function seems like it'd need to be hard-coded to convert all interface {} items back to their respective original types in order to work properly, because the receiving function needs to know the exact type in order to process the item correctly.

Is there a way to dynamically re-type Golang interface {} typed variables back to their original type? Something like this, How to I convert reflect.New's return value back to the original type ... maybe?

EDIT: To clarify, basically, I'm passing &out to a function and it needs to be its original type by the time it reaches another inner function call.

Example code:

// NOTE: This is sort of pseudo-Golang code, not meant to be compiled or taken too seriously.

func PrepareTwoDifferentThings(keyA string, keyB string) {
    var somethingA TypeA;
    var somethingB TypeB;

    loadFromCache(keyA, &somethingA, nil);
    loadFromCache(keyB, &somethingB, nil);

    fmt.Printf("Somethings: %v, %v", somethingA, somethingB);

}

func loadFromCache(key string, isNew, out interface {}, saveNewData interface {}) {
    if err := cache.load(key, &out); err!=nil { // NOTE: Current issue is that this expects "&out" to be `TypeA`/`TypeB` not "interface {}", but I don't want to copy and paste this whole function's worth of code or whatever.
        panic("oh no!");

    }

    if (saveNewData!=nil) {
        cache.save(key, saveNewData); // This doesn't seem to care if "saveNewData" is "interface {}" when saving, but later cache fetches above using the "load()" method to an "interface {}"-typed `&out` parameter throw an exception that the "interface {}" type on `&out` does not match the original when it was saved here (`TypeA`/`TypeB`).

    }

}

Upvotes: 1

Views: 1315

Answers (2)

Ben Guild
Ben Guild

Reputation: 5126

It turns out that using JSON instead of Gob for serialization avoids the error that I was encountering entirely. Other functions can handle passing into interfaces, etc.

Upvotes: 0

T. Claverie
T. Claverie

Reputation: 12256

To change the type of an interface into its rightful type, you can use type assertions:

package main

import r "reflect"

type A struct {
    Name string
}

func main() {
    // No pointer
    aa := A{"name"}
    var ii interface{} = aa

    bb := ii.(A)
    // main.A

    // Pointer
    a := &A{"name"}
    var i interface{} = a

    b := *i.(*A)
    // main.A

    c := i.(*A)
    // *main.A

    d := r.Indirect(r.ValueOf(i)).Interface().(A)
    // main.A
}

Playground 1

When using type assertions, you have to know the underlying type of your interface. In Go, there is no way to use type assertion with a dynamic type. reflect.Type is not a type, it's an interface representing a type. So no, you can't use it this way.

If you have several type possibilities, the solution is the type switch:

package main

import "fmt"

type TypeA struct {
    A string
}

type TypeB struct {
    B string
}

func doSomethingA(t TypeA) {
    fmt.Println(t.A)
}

func doSomethingB(t TypeB) {
    fmt.Println(t.B)
}

func doSomething(t interface{}) {
    switch t := t.(type) {
    case TypeA:
        doSomethingA(t)
    case TypeB:
        doSomethingB(t)
    default:
        panic("Unrecognized type")
    }
}

func main() {
    a := TypeA{"I am A"}
    b := TypeB{"I am B"}

    doSomething(a)
    // I am A
    doSomething(b)
    // I am B
}

Playground 2

Upvotes: 5

Related Questions