Fall back on reflection to select from slices

Turns out to be more straightforward than I expected to support
selecting values not just from `[]any`, but from any type of slice,
thanks to the `reflect` package. Leave the branches for `[]any` in place
to avoid the overhead of reflection, but then use reflection if the
value is any other type of slice. Resolves #26.

Author: theory

CHANGELOG.md

@@ -9,6 +9,14 @@ All notable changes to this project will be documented in this file. It uses the
 
 ## [v0.11.1] — Unreleased
 
+### ⚡ Improvements
+
+*   Added support for selecting values from any type of slice, not just
+    `[]any`. Internally it still prefers `[]any`, in the expectation that it's
+    optimized for a data structure decoded by `json.Unmarshal`, but it now
+    falls back on reflection to detect any other kind of slice. Thanks to
+    @ndsboy for the prompt (#26).
+
 ### ⬆️ Dependency Updates
 
 *   Upgraded to `golangci-lint` v2.11.1 and made suggested slice allocation

spec/query_test.go

@@ -631,6 +631,22 @@ func TestQueryArray(t *testing.T) {
 				{Path: Normalized(Index(0), Name("x"), Index(1)), Node: 2},
 			},
 		},
+		{
+			test:    "string_slice_index",
+			resType: FuncValue,
+			segs:    []*Segment{Child(Index(0))},
+			input:   []string{"x", "y"},
+			exp:     []any{"x"},
+			loc:     []*LocatedNode{{Path: Normalized(Index(0)), Node: "x"}},
+		},
+		{
+			test:    "int_slice_index",
+			resType: FuncValue,
+			segs:    []*Segment{Child(Index(1))},
+			input:   []int{0, 42},
+			exp:     []any{42},
+			loc:     []*LocatedNode{{Path: Normalized(Index(1)), Node: 42}},
+		},
 	} {
 		t.Run(tc.test, func(t *testing.T) {
 			t.Parallel()
@@ -1101,6 +1117,26 @@ func TestQuerySlice(t *testing.T) {
 				{Path: Normalized(Index(0), Index(1)), Node: 42},
 			},
 		},
+		{
+			test:  "string_slice",
+			segs:  []*Segment{Child(Slice())},
+			input: []string{"x", "y"},
+			exp:   []any{"x", "y"},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: "x"},
+				{Path: Normalized(Index(1)), Node: "y"},
+			},
+		},
+		{
+			test:  "int_slice",
+			segs:  []*Segment{Child(Slice())},
+			input: []int{42, 99},
+			exp:   []any{42, 99},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: 42},
+				{Path: Normalized(Index(1)), Node: 99},
+			},
+		},
 	} {
 		t.Run(tc.test, func(t *testing.T) {
 			t.Parallel()

spec/selector.go

@@ -3,6 +3,7 @@ package spec
 import (
 	"fmt"
 	"math"
+	"reflect"
 	"strconv"
 	"strings"
 )
@@ -223,7 +224,23 @@ func (i Index) Select(input, _ any) []any {
 		} else if idx < len(val) {
 			return []any{val[idx]}
 		}
+		return make([]any, 0)
 	}
+
+	// Select from any kind of slice.
+	val := reflect.ValueOf(input)
+	if val.Kind() == reflect.Slice {
+		idx := int(i)
+		if idx < 0 {
+			if idx = val.Len() + idx; idx >= 0 {
+				return []any{val.Index(idx).Interface()}
+			}
+		} else if idx < val.Len() {
+			return []any{val.Index(idx).Interface()}
+		}
+		return make([]any, 0)
+	}
+
 	return make([]any, 0)
 }
 
@@ -241,7 +258,26 @@ func (i Index) SelectLocated(input, _ any, parent NormalizedPath) []*LocatedNode
 		} else if idx < len(val) {
 			return []*LocatedNode{newLocatedNode(append(parent, Index(idx)), val[idx])}
 		}
+		return make([]*LocatedNode, 0)
 	}
+
+	// Select from any kind of slice.
+	val := reflect.ValueOf(input)
+	if val.Kind() == reflect.Slice {
+		idx := int(i)
+		if idx < 0 {
+			if idx = val.Len() + idx; idx >= 0 {
+				return []*LocatedNode{newLocatedNode(
+					append(parent, Index(idx)), val.Index(idx).Interface(),
+				)}
+			}
+		} else if idx < val.Len() {
+			return []*LocatedNode{newLocatedNode(
+				append(parent, Index(idx)), val.Index(idx).Interface(),
+			)}
+		}
+	}
+
 	return make([]*LocatedNode, 0)
 }
 
@@ -377,6 +413,25 @@ func (s SliceSelector) Select(input, _ any) []any {
 		}
 		return res
 	}
+
+	// Select from any kind of slice.
+	val := reflect.ValueOf(input)
+	if val.Kind() == reflect.Slice {
+		lower, upper := s.Bounds(val.Len())
+		res := make([]any, 0, val.Len())
+		switch {
+		case s.step > 0:
+			for i := lower; i < upper; i += s.step {
+				res = append(res, val.Index(i).Interface())
+			}
+		case s.step < 0:
+			for i := upper; lower < i; i += s.step {
+				res = append(res, val.Index(i).Interface())
+			}
+		}
+		return res
+	}
+
 	return make([]any, 0)
 }
 
@@ -401,6 +456,28 @@ func (s SliceSelector) SelectLocated(input, _ any, parent NormalizedPath) []*Loc
 		}
 		return res
 	}
+
+	// Select from any kind of slice.
+	val := reflect.ValueOf(input)
+	if val.Kind() == reflect.Slice {
+		lower, upper := s.Bounds(val.Len())
+		res := make([]*LocatedNode, 0, val.Len())
+		switch {
+		case s.step > 0:
+			for i := lower; i < upper; i += s.step {
+				res = append(res, newLocatedNode(
+					append(parent, Index(i)), val.Index(i).Interface(),
+				))
+			}
+		case s.step < 0:
+			for i := upper; lower < i; i += s.step {
+				res = append(res, newLocatedNode(
+					append(parent, Index(i)), val.Index(i).Interface(),
+				))
+			}
+		}
+		return res
+	}
 	return make([]*LocatedNode, 0)
 }
 

spec/selector_test.go

@@ -655,6 +655,36 @@ func TestSliceSelect(t *testing.T) {
 			exp:  []any{},
 			loc:  []*LocatedNode{},
 		},
+		{
+			test: "src_string_slice",
+			sel:  Slice(0, 2),
+			src:  []string{"hi", "bye", "x"},
+			exp:  []any{"hi", "bye"},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: "hi"},
+				{Path: Normalized(Index(1)), Node: "bye"},
+			},
+		},
+		{
+			test: "src_int_slice",
+			sel:  Slice(),
+			src:  []int{42, 1024},
+			exp:  []any{42, 1024},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: 42},
+				{Path: Normalized(Index(1)), Node: 1024},
+			},
+		},
+		{
+			test: "src_object_slice",
+			sel:  Slice(),
+			src:  []map[string]any{{"x": 1}, {"y": true}},
+			exp:  []any{map[string]any{"x": 1}, map[string]any{"y": true}},
+			loc: []*LocatedNode{
+				{Path: Normalized(Index(0)), Node: map[string]any{"x": 1}},
+				{Path: Normalized(Index(1)), Node: map[string]any{"y": true}},
+			},
+		},
 	} {
 		t.Run(tc.test, func(t *testing.T) {
 			t.Parallel()