Idiomatic slice splice in Go?

I have the following code for implementing a splice (that is, given a byte slice full, another byte slice part, and an int pos representing the position in full that I want to overwrite with part):

package main

import (
    "fmt"
    "bytes"
)

func main() {
    full := []byte{0,0,0,0,0,0,0}
    part := []byte{1,1,1}

    newFull1 := splice(full, part, 2)
    fmt.Println(newFull1)
    // [0 0 1 1 1 0 0]

    newFull2 := splice(full, part, 3)
    fmt.Println(newFull2)
    // [0 0 0 1 1 1 0]
}

func splice(full []byte, part []byte, pos int) []byte {
    return bytes.Join([][]byte{full[:pos], part, full[len(full[:pos])+len(part):]}, []byte{})
}

Basically, my method does a join of 3 byte slices: the first part of full that doesn't get overwritten by part, all of part, and then the remaining part of full. Is there a better/more idiomatic way of doing this? I wasn't able to find a method that implemented this in the standard library.

If you know part is completely within the bounds of full, you can use the copy function.

func main() {
	full := []byte{0, 0, 0, 0, 0, 0, 0}
	part := []byte{1, 1, 1}

	copy(full[2:], part)
	fmt.Println(full)
}

playground

That overwrites full though. If you wanted to preserve the original, you could make a copy first with the append function.

func main() {
	full := []byte{0, 0, 0, 0, 0, 0, 0}
	part := []byte{1, 1, 1}

	newFull := append([]byte{}, full...)
	copy(newFull[2:], part)
	fmt.Println("newFull:      ", newFull)
	fmt.Println("original full:", full)
}

playground

Note that this still has the limitation of your original code that part must fit within the bounds of full.

Why not use the append built-in?

func splice(full, part []byte, pos int) (ret []byte) {
    ret = append(full[:pos], part...)
    return append(ret, full[pos:]...)
}

This may not be very fast (lots of copying), but it's pretty readable.

Here is another variant for splicing byte slices. The algorithm is similar to Anton Litvinov's stringSplice(). Because the append function shares the same slice as the input, a copy of the same length as the input must be used. This was not done by 'beatgammit' in the previous answer, which does not work correctly.

package main
import "fmt"
func sliceSplice(input []byte, start, deleteCount int, item []byte) ([]byte) {
fmt.Printf("input:      %v start = %d deleteCount = %d item: %v\n", input, start, deleteCount, item)
cpy := make([]byte, len(input))
copy(cpy, input)
fmt.Println("cpy:       ", cpy)
if start > len(cpy) {
return append(cpy, item...)
}
ret := append(cpy[:start], item...)
fmt.Println("ret:       ", ret)
if start+deleteCount > len(cpy) {
return ret
}
fmt.Println("cpy:       ", cpy, "       modified by shared slice 'ret'")
fmt.Println("input[s+d] ", input[start+deleteCount:], "         not modified")
return append(ret, input[start+deleteCount:]...)
}
func main() {
oldFull := []byte{0, 0, 1, 1, 1, 0, 0}
fmt.Println("oldFull:      ", oldFull, "\n")
myFull := sliceSplice(oldFull, 3, 0, []byte{2, 2})
fmt.Println("myFull:       ", myFull, "\n")
myFull = sliceSplice(oldFull, 3, 1, []byte{2, 2})
fmt.Println("myFull:       ", myFull, "\n")
myFull = sliceSplice(oldFull, 3, 4, []byte{2, 2})
fmt.Println("myFull:       ", myFull, "\n")
myFull = sliceSplice(oldFull, 3, 6, []byte{2, 2})
fmt.Println("myFull:       ", myFull, "\n")
myFull = sliceSplice(oldFull, 7, 0, []byte{2, 2})
fmt.Println("myFull:       ", myFull, "\n")
myFull = sliceSplice(oldFull, 9, 6, []byte{2, 2})
fmt.Println("myFull:       ", myFull, "\n")
}

I have also included a group of test cases

A variant for string (split / splice / join).

func stringSplice(full string, start, deleteCount int, item string) (ret string) {
if start > len(full) {
return full + item
}
ret = full[:start] + item
if start+deleteCount > len(full) {
return ret
}
return ret + full[start+deleteCount:]
}