gofront 1.7.0 → 1.8.0

package/stdlib/slices/extra.go

@@ -0,0 +1,73 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed slices package: comparison and repetition
+// members written in Go and merged into the slices namespace.  The
+// checker has no core types for type parameters, so these take []E rather
+// than Go's S ~[]E and Repeat returns []E.
+package slices
+
+// EqualFunc reports whether two slices are equal using an equality
+// function on each pair of elements. If the lengths are different,
+// EqualFunc returns false. Otherwise, the elements are compared in
+// increasing index order, and the comparison stops at the first index
+// for which eq returns false.
+func EqualFunc[E1, E2 any](s1 []E1, s2 []E2, eq func(E1, E2) bool) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+	for i, v1 := range s1 {
+		v2 := s2[i]
+		if !eq(v1, v2) {
+			return false
+		}
+	}
+	return true
+}
+
+// CompareFunc is like Compare but uses a custom comparison function on each
+// pair of elements.
+// The result is the first non-zero result of cmp; if cmp always
+// returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
+// and +1 if len(s1) > len(s2).
+func CompareFunc[E1, E2 any](s1 []E1, s2 []E2, cmp func(E1, E2) int) int {
+	for i, v1 := range s1 {
+		if i >= len(s2) {
+			return +1
+		}
+		v2 := s2[i]
+		if c := cmp(v1, v2); c != 0 {
+			return c
+		}
+	}
+	if len(s1) < len(s2) {
+		return -1
+	}
+	return 0
+}
+
+// repeatMaxInt is the largest int, as the overflow bound of Repeat.
+const repeatMaxInt = 1<<63 - 1
+
+// Repeat returns a new slice that repeats the provided slice the given number of times.
+// The result has length and capacity (len(x) * count).
+// The result is never nil.
+// Repeat panics if count is negative or if the result of (len(x) * count)
+// overflows.
+func Repeat[E any](x []E, count int) []E {
+	if count < 0 {
+		panic("cannot be negative")
+	}
+
+	if len(x) > 0 && count > repeatMaxInt/len(x) {
+		panic("the result of (len(x) * count) overflows")
+	}
+
+	newslice := make([]E, len(x)*count)
+	n := copy(newslice, x)
+	for n < len(newslice) {
+		n += copy(newslice[n:], newslice[:n])
+	}
+	return newslice
+}

package/stdlib/slices/iter.go

@@ -0,0 +1,113 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed slices package: the iterator members are
+// written in Go over iter.Seq and iter.Seq2 and merged into the slices
+// namespace. Unqualified references to emitter members (Sort, SortFunc,
+// SortStableFunc) resolve to the emitter implementation.
+package slices
+
+import (
+	"cmp"
+	"iter"
+)
+
+// All returns an iterator over index-value pairs in the slice
+// in the usual order.
+func All[E any](s []E) iter.Seq2[int, E] {
+	return func(yield func(int, E) bool) {
+		for i, v := range s {
+			if !yield(i, v) {
+				return
+			}
+		}
+	}
+}
+
+// Backward returns an iterator over index-value pairs in the slice,
+// traversing it backward with descending indices.
+func Backward[E any](s []E) iter.Seq2[int, E] {
+	return func(yield func(int, E) bool) {
+		for i := len(s) - 1; i >= 0; i-- {
+			if !yield(i, s[i]) {
+				return
+			}
+		}
+	}
+}
+
+// Values returns an iterator that yields the slice elements in order.
+func Values[E any](s []E) iter.Seq[E] {
+	return func(yield func(E) bool) {
+		for _, v := range s {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// AppendSeq appends the values from seq to the slice and
+// returns the extended slice.
+func AppendSeq[E any](s []E, seq iter.Seq[E]) []E {
+	for v := range seq {
+		s = append(s, v)
+	}
+	return s
+}
+
+// Collect collects values from seq into a new slice and returns it.
+func Collect[E any](seq iter.Seq[E]) []E {
+	var s []E
+	return AppendSeq(s, seq)
+}
+
+// Sorted collects values from seq into a new slice, sorts the slice,
+// and returns it.
+func Sorted[E cmp.Ordered](seq iter.Seq[E]) []E {
+	s := Collect(seq)
+	Sort(s)
+	return s
+}
+
+// SortedFunc collects values from seq into a new slice, sorts the slice
+// using the comparison function, and returns it.
+func SortedFunc[E any](seq iter.Seq[E], cmp func(E, E) int) []E {
+	s := Collect(seq)
+	SortFunc(s, cmp)
+	return s
+}
+
+// SortedStableFunc collects values from seq into a new slice.
+// It then sorts the slice while keeping the original order of equal elements,
+// using the comparison function to compare elements.
+// It returns the new slice.
+func SortedStableFunc[E any](seq iter.Seq[E], cmp func(E, E) int) []E {
+	s := Collect(seq)
+	SortStableFunc(s, cmp)
+	return s
+}
+
+// Chunk returns an iterator over consecutive sub-slices of up to n elements
+// of s. All but the last sub-slice will have size n. All sub-slices are
+// clipped to have no capacity beyond the length. If s is empty, the sequence
+// is empty: there is no empty slice in the sequence. Chunk panics if n is
+// less than 1.
+func Chunk[E any](s []E, n int) iter.Seq[[]E] {
+	if n < 1 {
+		panic("cannot be less than 1")
+	}
+	return func(yield func([]E) bool) {
+		for i := 0; i < len(s); i += n {
+			// Clamp the last chunk to the slice bound as necessary.
+			end := min(n, len(s[i:]))
+
+			// Set the capacity of each chunk so that appending to a chunk does
+			// not modify the original slice.
+			if !yield(s[i : i+end : i+end]) {
+				return
+			}
+		}
+	}
+}