How to define a function type which accepts any number of arguments in Go?

I try to write a function which takes any other function and wraps a new function around it. This is what I have tried so far:

package main

import (
	"fmt"
)

func protect (unprotected func (...interface{})) (func (...interface{})) {
	return func (args ...interface{}) {
		fmt.Println ("protected");
		unprotected (args...);
	};
}

func main () {
	a := func () {
		fmt.Println ("unprotected");
	};
	b := protect (a);
	b ();
}

When I compile this I get the error:

cannot use a (type func()) as type func(...interface { }) in function argument

Why is a function without arguments not compatible to a function with a variable number of arguments? What can I do to make them compatible?

Update:
The protected function should be compatible with the original:

func take_func_int_int (f func (x int) (y int)) (int) {
	return f (1)
}

func main () {

	a := func (x int) (y int) {
		return 2 * x
	}
	b := protect (a)

	take_func_int_int (a)
	take_func_int_int (b)
}

Types are pretty concrete in Go. You could try

a := func(_ ...interface{}) {
    fmt.Println("unprotected")
}

func (...interface{}) does not mean "any function that takes any number of any kind of arguments", it means "only a function which takes a variable number of interface{} arguments"

Alternatively rather than func(...interface{}) you can just use interface{} and the reflect package. See http://github.com/hoisie/web.go for an example.

EDIT: Specifically, this:

package main

import (
	"fmt"
	"reflect"
)

func protect(oldfunc interface{}) (func (...interface{})) {
	if reflect.TypeOf(oldfunc).Kind() != reflect.Func {
		panic("protected item is not a function")
	}
	return func (args ...interface{}) {
		fmt.Println("Protected")
		vargs := make([]reflect.Value, len(args))
		for n, v := range args {
			vargs[n] = reflect.ValueOf(v)
		}
		reflect.ValueOf(oldfunc).Call(vargs)
	}
}

func main() {
	a := func() {
		fmt.Println("unprotected")
	}
	b := func(s string) {
		fmt.Println(s)
	}
	c := protect(a)
	d := protect(b)
	c()
	d("hello")
}

Ouput is

Protected
unprotected
Protected
hello

EDIT: To answer the update

Like I said above, types are pretty concrete in Go. The protect function returns a type func(...interface{}) which will never be assignable to func(int)int. I think you're probably either over-engineering your problem or misunderstanding it. However, here's a highly discouraged code snippet that would make it work.

First change protect to also return values:

func protect(oldfunc interface{}) (func (...interface{}) []interface{}) {
	if reflect.TypeOf(oldfunc).Kind() != reflect.Func {
		panic("protected item is not a function")
	}
	return func (args ...interface{}) []interface{} {
		fmt.Println("Protected")
		vargs := make([]reflect.Value, len(args))
		for n, v := range args {
			vargs[n] = reflect.ValueOf(v)
		}
		ret_vals := reflect.ValueOf(oldfunc).Call(vargs)
        to_return := make([]interface{}, len(ret_vals))
        for n, v := range ret_vals {
                to_return[n] = v.Interface()
        }
        return to_return
	}
}

Then make a convert function:

func convert(f func(...interface{}) (func(int) int) {
    return func(x int) int {
        r := f(x)
        return r[0].(int)
    }
}

Then your call would look like

take_func_int_int(convert(b))

##But I promise this isn't what you actually want to do.
Step back and try to rework the problem. I've completely killed type-safety in these examples. What are you trying to accomplish?

package main

import "fmt"

// Here's a function that will take an arbitrary number
// of `int`s as arguments.
func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

func main() {

    // Variadic functions can be called in the usual way
    // with individual arguments.
    sum(1, 2)
    sum(1, 2, 3)

    // If you already have multiple args in a slice,
    // apply them to a variadic function using
    // `func(slice...)` like this.
    nums := []int{1, 2, 3, 4}
    sum(nums...)
}