Is there a way to match all interfaces?

When a struct implements multiple interfaces what is the simplest way to match all of them in a function?

The way go's switch works the following function is not an option.

func f(i interface{}) {
	switch i.(type) {
	case A:
		fmt.Println("A")
	case B:
		fmt.Println("B")
	}
}

Even if i implements both interfaces f(i) outputs only A. Adding fallthrough won't help either. So is there a way to check for multiple interfaces?

You can use a type assertion instead of a switch statement to check whether an interface variable matches a specific interface. If you want to check multiple interfaces, you can use a sequence of multiple type assertions:

func f(i interface{}) {
	if _, ok := i.(Aer); ok {
		fmt.Println("A")
	}
	if _, ok := i.(Ber); ok {
		fmt.Println("B")
	}
}

(https://play.golang.org/p/6aJxV_j9oqy)

It's not at all clear what your purpose is here; as Adrian notes in comments, this isn't something you would normally find in code.

You might find something like this in some sort of debug system, where you want to print information about a variable of some interface type to see what interface(s) it implements. Debuggers generally have direct access to the internal types. In Go specifically, a debugger could use the reflect system here. reflect is deliberately a little bit weaker than debuggers tend to need, but for this particular case, it provides what you might want: you could have a loop that runs through different interface types and invokes reflect.Type.Implements on them.

The type assertion in bcmills' answer is more efficient but less generalizable: if you're doing your own mini-debugger, you might want to provide a table of potential interface types to a function that prints an interface value. (If you were building a real debugger, you would not want anything this inefficient, you'd want to reach directly into the type system's guts and read out the raw tables....)