gofront 1.8.0 → 1.9.0

package/stdlib/maps/iter.go

@@ -1,65 +0,0 @@
-//go:build gofront
-
-//gofront:target both
-
-// Overlay on the emitter-backed maps package: the iterator members are
-// written in Go over iter.Seq and iter.Seq2 and merged into the maps
-// namespace. Keys and Values return iterators, as in Go 1.23.
-package maps
-
-import "iter"
-
-// All returns an iterator over key-value pairs from m.
-// The iteration order is not specified and is not guaranteed
-// to be the same from one call to the next.
-func All[K comparable, V any](m map[K]V) iter.Seq2[K, V] {
-	return func(yield func(K, V) bool) {
-		for k, v := range m {
-			if !yield(k, v) {
-				return
-			}
-		}
-	}
-}
-
-// Keys returns an iterator over keys in m.
-// The iteration order is not specified and is not guaranteed
-// to be the same from one call to the next.
-func Keys[K comparable, V any](m map[K]V) iter.Seq[K] {
-	return func(yield func(K) bool) {
-		for k := range m {
-			if !yield(k) {
-				return
-			}
-		}
-	}
-}
-
-// Values returns an iterator over values in m.
-// The iteration order is not specified and is not guaranteed
-// to be the same from one call to the next.
-func Values[K comparable, V any](m map[K]V) iter.Seq[V] {
-	return func(yield func(V) bool) {
-		for _, v := range m {
-			if !yield(v) {
-				return
-			}
-		}
-	}
-}
-
-// Insert adds the key-value pairs from seq to m.
-// If a key in seq already exists in m, its value will be overwritten.
-func Insert[K comparable, V any](m map[K]V, seq iter.Seq2[K, V]) {
-	for k, v := range seq {
-		m[k] = v
-	}
-}
-
-// Collect collects key-value pairs from seq into a new map
-// and returns it.
-func Collect[K comparable, V any](seq iter.Seq2[K, V]) map[K]V {
-	m := make(map[K]V)
-	Insert(m, seq)
-	return m
-}

package/stdlib/slices/extra.go

@@ -1,73 +0,0 @@
-//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

@@ -1,113 +0,0 @@
-//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
-			}
-		}
-	}
-}

package/stdlib/strings/extra.go

@@ -1,35 +0,0 @@
-//go:build gofront
-
-//gofront:target both
-
-// Overlay on the emitter-backed strings package: small members written in Go
-// and merged into the strings namespace.
-package strings
-
-// Clone returns a fresh copy of s.  Strings are immutable values here, so
-// the copy is s itself.
-func Clone(s string) string {
-	return s
-}
-
-// Compare returns an integer comparing two strings lexicographically.
-// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
-func Compare(a, b string) int {
-	if a == b {
-		return 0
-	}
-	if a < b {
-		return -1
-	}
-	return +1
-}
-
-// ContainsFunc reports whether any Unicode code points in s satisfy f(c).
-func ContainsFunc(s string, f func(rune) bool) bool {
-	for _, r := range s {
-		if f(r) {
-			return true
-		}
-	}
-	return false
-}

package/stdlib/strings/iter.go

@@ -1,122 +0,0 @@
-//go:build gofront
-
-//gofront:target both
-
-// Overlay on the emitter-backed strings package: the sequence members of
-// Go 1.24 are written in Go over iter.Seq and merged into the strings
-// namespace.  Strings are JavaScript strings, so Index and slicing count the
-// same units and splitting at a substring is always consistent; the places
-// that need code points (an empty separator, Fields) go through []rune.
-package strings
-
-import (
-	"iter"
-	"unicode"
-)
-
-// Lines returns an iterator over the newline-terminated lines in the string s.
-// The lines yielded by the iterator include their terminating newlines.
-// If s is empty, the iterator yields no lines at all.
-// If s does not end in a newline, the final yielded line will not end in a newline.
-func Lines(s string) iter.Seq[string] {
-	return func(yield func(string) bool) {
-		for len(s) > 0 {
-			var line string
-			if i := IndexByte(s, '\n'); i >= 0 {
-				line, s = s[:i+1], s[i+1:]
-			} else {
-				line, s = s, ""
-			}
-			if !yield(line) {
-				return
-			}
-		}
-	}
-}
-
-// explodeSeq returns an iterator over the runes in s.
-func explodeSeq(s string) iter.Seq[string] {
-	return func(yield func(string) bool) {
-		for _, r := range []rune(s) {
-			if !yield(string(r)) {
-				return
-			}
-		}
-	}
-}
-
-// splitSeq is SplitSeq or SplitAfterSeq, configured by how many
-// bytes of sep to include in the results (none or all).
-func splitSeq(s, sep string, sepSave int) iter.Seq[string] {
-	if len(sep) == 0 {
-		return explodeSeq(s)
-	}
-	return func(yield func(string) bool) {
-		for {
-			i := Index(s, sep)
-			if i < 0 {
-				break
-			}
-			frag := s[:i+sepSave]
-			if !yield(frag) {
-				return
-			}
-			s = s[i+len(sep):]
-		}
-		yield(s)
-	}
-}
-
-// SplitSeq returns an iterator over substrings of s split by sep.
-// The iterator yields the same strings that would be returned by Split(s, sep),
-// but without constructing the slice.
-func SplitSeq(s, sep string) iter.Seq[string] {
-	return splitSeq(s, sep, 0)
-}
-
-// SplitAfterSeq returns an iterator over substrings of s split after each instance of sep.
-// The iterator yields the same strings that would be returned by SplitAfter(s, sep),
-// but without constructing the slice.
-func SplitAfterSeq(s, sep string) iter.Seq[string] {
-	return splitSeq(s, sep, len(sep))
-}
-
-// isSpace is unicode.IsSpace as a func(rune) bool (the checker types the
-// unicode predicates over int).
-func isSpace(r rune) bool {
-	return unicode.IsSpace(int(r))
-}
-
-// FieldsSeq returns an iterator over substrings of s split around runs of
-// whitespace characters, as defined by unicode.IsSpace.
-// The iterator yields the same strings that would be returned by Fields(s),
-// but without constructing the slice.
-func FieldsSeq(s string) iter.Seq[string] {
-	return FieldsFuncSeq(s, isSpace)
-}
-
-// FieldsFuncSeq returns an iterator over substrings of s split around runs of
-// Unicode code points satisfying f(c).
-// The iterator yields the same strings that would be returned by FieldsFunc(s),
-// but without constructing the slice.
-func FieldsFuncSeq(s string, f func(rune) bool) iter.Seq[string] {
-	return func(yield func(string) bool) {
-		runes := []rune(s)
-		start := -1
-		for i, r := range runes {
-			if f(r) {
-				if start >= 0 {
-					if !yield(string(runes[start:i])) {
-						return
-					}
-					start = -1
-				}
-			} else if start < 0 {
-				start = i
-			}
-		}
-		if start >= 0 {
-			yield(string(runes[start:]))
-		}
-	}
-}

package/stdlib/sync/extra.go

@@ -1,105 +0,0 @@
-//go:build gofront
-
-//gofront:target both
-
-// Overlay on the emitter-backed sync package: OnceFunc/OnceValue/OnceValues
-// and RWMutex.RLocker.
-package sync
-
-// OnceFunc returns a function that invokes f only once. The returned function
-// may be called concurrently.
-//
-// If f panics, the returned function will panic with the same value on every call.
-func OnceFunc(f func()) func() {
-	var (
-		once  Once
-		valid bool
-		p     any
-	)
-	return func() {
-		once.Do(func() {
-			defer func() {
-				p = recover()
-				if !valid {
-					panic(p)
-				}
-			}()
-			f()
-			valid = true
-		})
-		if !valid {
-			panic(p)
-		}
-	}
-}
-
-// OnceValue returns a function that invokes f only once and returns the value
-// returned by f. The returned function may be called concurrently.
-//
-// If f panics, the returned function will panic with the same value on every call.
-func OnceValue[T any](f func() T) func() T {
-	var (
-		once   Once
-		valid  bool
-		p      any
-		result T
-	)
-	return func() T {
-		once.Do(func() {
-			defer func() {
-				p = recover()
-				if !valid {
-					panic(p)
-				}
-			}()
-			result = f()
-			valid = true
-		})
-		if !valid {
-			panic(p)
-		}
-		return result
-	}
-}
-
-// OnceValues returns a function that invokes f only once and returns the values
-// returned by f. The returned function may be called concurrently.
-//
-// If f panics, the returned function will panic with the same value on every call.
-func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {
-	var (
-		once  Once
-		valid bool
-		p     any
-		r1    T1
-		r2    T2
-	)
-	return func() (T1, T2) {
-		once.Do(func() {
-			defer func() {
-				p = recover()
-				if !valid {
-					panic(p)
-				}
-			}()
-			r1, r2 = f()
-			valid = true
-		})
-		if !valid {
-			panic(p)
-		}
-		return r1, r2
-	}
-}
-
-type rlocker struct {
-	rw *RWMutex
-}
-
-func (r *rlocker) Lock() {}
-
-func (r *rlocker) Unlock() {}
-
-func (rw *RWMutex) RLocker() Locker {
-	return &rlocker{rw: rw}
-}