Idiomatic Splice in Go

I checked an existing answer but it's not similar to my case.

I need to pluck an element at the index and break out of the for loop at runtime based on Compare function.

Issues:
If element to pluck is found at 0 index, index-1 will throw slice bounds of range error and similarly if index+1 is greater than len(elements).

Question: What's the best concise way to achieve the above?

for index, element := range elements {
	if element.Compare() == true {
		elements = append(elements[:index-1], elements[index+1:]...)
        break
	}
}

Attempt

for index, element := range elements {
	if element.Compare() == true {
		if len(elements) > 1 {
			elements = append(elements[:index-1], elements[index+1:]...)
		} else if len(elements) == 1 {
			delete(elements, 0)
		}
		break
	}
}

Attempt 2 Playground any improvements/suggestions?

The idea is to copy the remaining elements from beginning to index and then any elements after.

var elements = []string {"a", "b", "c", "d"}
fmt.Println(elements)
for index, element := range elements {
	if element == "c" {
		var temp = elements[:index]
		for i := index + 1; i<len(elements); i++ {
			temp = append(temp, elements[i])
		}
		elements = temp
		break
	}
}
fmt.Println(elements)

The high index in a slice expression is exclusive.

This means your example is flawed, and also that no special treatment is required.

The correct slicing expression is:

elements = append(elements[:index], elements[index+1:]...)

If index is the first element (0), then elements[:0] will be an empty slice.

If index is the last element (len-1), then elements[index+1:] will also be an empty slice, as index+1 will be equal to the lenght of the slice. So the solution is simply:

for index, element := range elements {
    if element.Compare() {
        elements = append(elements[:index], elements[index+1:]...)
        break
    }
}

To demonstrate it on the Go Playground, let's substitute the Compare() method with a simple index check:

for _, idxToRemove := range []int{0, 2, 4} {
	s := []int{0, 1, 2, 3, 4}
	for i := range s {
		if i == idxToRemove {
			s = append(s[:i], s[i+1:]...)
			break
		}
	}
	fmt.Println(idxToRemove, ":", s)
}

Output (try it on the Go Playground):

0 : [1 2 3 4]
2 : [0 1 3 4]
4 : [0 1 2 3]

If the slice s is sorted and len(s) is large, find x using a binary search. For example,

package main

import (
	"fmt"
	"sort"
)

func pluck(s []string, x string) []string {
	i := sort.SearchStrings(s, x)
	if i >= 0 && i < len(s) && s[i] == x {
		s = append(s[:i], s[i+1:]...)
	}
	return s
}

func main() {
	s := []string{"a", "b", "c", "d"}
	fmt.Println(s)
	s = pluck(s, "b")
	fmt.Println(s)
}

Output:

[a b c d]
[a c d]

If the order of slice s does not need to be preserved, switch elements. For example,

package main

import "fmt"

func pluck(s []string, x string) []string {
	for i, v := range s {
		if v == x {
			s[i] = s[len(s)-1]
			s = s[:len(s)-1]
			break
		}
	}
	return s
}

func main() {
	s := []string{"a", "b", "c", "d"}
	fmt.Println(s)
	s = pluck(s, "b")
	fmt.Println(s)
}

Output:

[a b c d]
[a d c]

Otherwise, splice slice s elements. For example,

package main

import "fmt"

func pluck(s []string, x string) []string {
	for i, v := range s {
		if v == x {
			s = append(s[:i], s[i+1:]...)
			break
		}
	}
	return s
}

func main() {
	s := []string{"a", "b", "c", "d"}
	fmt.Println(s)
	s = pluck(s, "b")
	fmt.Println(s)
}

Output:

[a b c d]
[a c d]

I'm not sure if this is idiomatic, but this works quite well:

package main

import "fmt"

func splice(start, count int, items []string) (ret []string) {
	ret = make([]string, len(items)-count)
	copy(ret, items[:start])
	copy(ret[start:], items[start+count:])
    return
}

func main() {
    s := []string{"a", "b", "c", "d"}
    fmt.Println(s)
    s = splice(1, 2, s)
    fmt.Println(s)
}

Go Playground: https://play.golang.org/p/UNtdtw77sEQ