How do you make a function accept multiple types?

Question

I am having a function like this:

package main
import "flag"
import "fmt"

func print_out_type(x anything) string {
    switch v := x.(type) {
        case string:
             return "A string"
        case int32:
             return "An Integer"
        default:
             return "A default"
    }
}

func main() {
    wordPtr := flag.String("argument1", "foo", "a String")
    numPtr := flag.Int("argument2", 42, "an Integer")
    flag.Parse()
    fmt.Println("word: ", *wordPtr)
    fmt.Println("number: ", *numPtr)
}

I am trying to return different types of strings based on the type. I am just stuck at the point of how do I write a function that accepts arguments of different types.

Use `interface{}` as the type. This is an empty interface; any type implements it. Be sure to complete any decent tutorial on Go as this is a pretty basic thing. — kostix, Oct 20 '16 at 04:41

score 58 · Accepted Answer · edited Jun 20 '20 at 09:12

You can use interface types as arguments, in which case you can call the function with any type that implements the given interface. In Go types automatically implement any interfaces if they have the interface's methods. So if you want to accept all possible types, you can use empty interface (interface{}) since all types implement that. No other modification needs to be done to your function.

func print_out_type(x interface{}) string {
    switch v := x.(type) {
        case string:
             return "A string"
        case int32:
             return "An Integer"
        default:
             return "A default"
    }
}

You can also use the reflect package to study the type of an interface variable. For Example:

func print_out_type(x interface{}) string {
    return reflect.TypeOf(x).String()
}

func main() {
    fmt.Println(print_out_type(42))
    fmt.Println(print_out_type("foo"))
}

Will print

int

string

How can get the value that was sent to the variable and use it in the function? I am using data := x.(ConcreteType) but this will have the scope of switch statement and I can't use it outside that scope — Sharad, Aug 12 '19 at 17:18

score 7 · Answer 2 · edited Jul 21 '22 at 08:40

7

Starting with Go 1.18. you can use generics to specify which types can be used in a function.

func print_out_type[T any](x T) string {
    return fmt.Sprintf("%T", x)
}

https://go.dev/doc/tutorial/generics

edited Jul 21 '22 at 08:40

blackgreen

34,072
23
111
129

answered Feb 24 '22 at 20:23

Damir Luketic

71
1
2

score -5 · Answer 3 · edited Oct 20 '16 at 07:51

-5

First, if you are using a type assertion, you need to check that this operation is successful. eg: value, ok := temp.(int)
Second, you can use the interface{} type variable as a parameter to the function. In the Function, you can use type assertion to check the parameter's real type and print out.

edited Oct 20 '16 at 07:51

Manigandan Arjunan

2,260
1
25
42

answered Oct 20 '16 at 06:43

fengzixu

9
1

1

You don't need a type assertion with a type switch. – Kaedys Oct 20 '16 at 14:29
1

OP isn't using type assertion and neither should he. – jussius Oct 20 '16 at 14:35

How do you make a function accept multiple types?

3 Answers3

Linked