Appending items to a variadic function wrapper without reallocating a new slice

Ok I need a small wrapper of fmt.Printf() for debugging conveniance :

1/ "too many arguments in call to fmt.Fprintln" :

func Debug (a ... interface{}) {
    if debug {
	    fmt.Fprintln(out, prefix, sep, a...)
    }
}

2/ "name list not allowed in interface type" :

func Debug (a ... interface{}) {
    if debug {
	    fmt.Fprintln(out, []interface{prefix, sep, a...}...)
    }
}

3/ Works, but feels wrong :

func Debug (a ... interface{}) {
    if debug {
	    sl := make ([]interface{}, len(a) + 2)
	    sl[0] = prefix
	    sl[1] = sep
	    for i, v := range a {
		    sl[2+i] = v
	    }
	
        fmt.Fprintln(out, sl...)
    }
}

Any ideas to avoid allocating extra memory ?

You can also use append for a one-liner:

func Debug (a ...interface{}) {
    if debug {
        fmt.Fprintln(out, append([]interface{}{prefix, sep}, a...)...)
    }
}

I would just do two prints:

func Debug(a ...interface{}) {
    if debug {
        fmt.Fprint(out, prefix, sep)
        fmt.Fprintln(out, a...)
    }
}

If you believed you needed to make a single call to Fprint, you could do,

func Debug(a ...interface{}) {
    if debug {
        fmt.Fprint(out, prefix, sep, fmt.Sprintln(a...))
    }
}

Either way seems simpler that building a new slice.

I would write:

func Debug(a ...interface{}) {
	if debug {
		aa := make([]interface{}, 0, 2+len(a))
		aa = append(append(aa, prefix, sep), a...)
		fmt.Fprintln(out, aa...)
	}
}

The allocation is only made in debug mode, so why is the number of Debug function allocations significant?

The Go fmt package is expensive because of its generality; it uses reflection, it allocates, and it does I/O. Why are the Debug function allocations relatively significant?

Have you considered using the Go log package?

Variadic arguments can be used as slices, so no need to allocate a new one:

func Debug(a ...interface{}) {
    if debug {
        a = append(a, 0)
        copy(a[1:], a[0:])
        a[0] = prefix + sep
        fmt.Fprintln(out, a...)
    }
}

See http://play.golang.org/p/xXEO58BJoA for a working example

There is no way to avoid allocating extra memory.

The shortest and most efficient Go code seems to be:

func Debug (a ...interface{}) {
    if debug {
        b := make([]interface{}, 0, 2+len(a))
        b = append(b, prefix, sep)
        b = append(b, a...)
        fmt.Fprintln(out, b...)
    }
}

Minor note: In your 2nd example, you are missing a {}:

fmt.Fprintln(out, []interface{}{prefix, sep}...)