gofront 1.7.0 → 1.8.0

package/stdlib/io/io.go

@@ -0,0 +1,346 @@
+//go:build gofront
+
+//gofront:target both
+
+// Overlay on the emitter-backed io package.
+package io
+
+import (
+	"errors"
+)
+
+// Seek whence values.
+const (
+	SeekStart   = 0 // seek relative to the origin of the file
+	SeekCurrent = 1 // seek relative to the current offset
+	SeekEnd     = 2 // seek relative to the end
+)
+
+// ErrShortWrite means that a write accepted fewer bytes than requested
+// but failed to return an explicit error.
+var ErrShortWrite = errors.New("short write")
+
+// ErrShortBuffer means that a read required a longer buffer than was provided.
+var ErrShortBuffer = errors.New("short buffer")
+
+// ErrUnexpectedEOF means that EOF was encountered in the
+// middle of reading a fixed-size block or data structure.
+var ErrUnexpectedEOF = errors.New("unexpected EOF")
+
+// ErrNoProgress is returned by some clients of a Reader when
+// many calls to Read have failed to return any data or error.
+var ErrNoProgress = errors.New("multiple Read calls return no data or error")
+
+// ReadCloser is the interface that groups the basic Read and Close methods.
+type ReadCloser interface {
+	Reader
+	Closer
+}
+
+// WriteCloser is the interface that groups the basic Write and Close methods.
+type WriteCloser interface {
+	Writer
+	Closer
+}
+
+// ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
+type ReadWriteCloser interface {
+	Reader
+	Writer
+	Closer
+}
+
+// ReadSeeker is the interface that groups the basic Read and Seek methods.
+type ReadSeeker interface {
+	Reader
+	Seeker
+}
+
+// ReadSeekCloser is the interface that groups the basic Read, Seek and Close methods.
+type ReadSeekCloser interface {
+	Reader
+	Seeker
+	Closer
+}
+
+// WriteSeeker is the interface that groups the basic Write and Seek methods.
+type WriteSeeker interface {
+	Writer
+	Seeker
+}
+
+// ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.
+type ReadWriteSeeker interface {
+	Reader
+	Writer
+	Seeker
+}
+
+// Seeker is the interface that wraps the basic Seek method.
+type Seeker interface {
+	Seek(offset int64, whence int) (int64, error)
+}
+
+// ReaderAt is the interface that wraps the basic ReadAt method.
+type ReaderAt interface {
+	ReadAt(p []byte, off int64) (n int, err error)
+}
+
+// WriterAt is the interface that wraps the basic WriteAt method.
+type WriterAt interface {
+	WriteAt(p []byte, off int64) (n int, err error)
+}
+
+// ByteReader is the interface that wraps the ReadByte method.
+type ByteReader interface {
+	ReadByte() (byte, error)
+}
+
+// ByteScanner is the interface that adds the UnreadByte method to ByteReader.
+type ByteScanner interface {
+	ByteReader
+	UnreadByte() error
+}
+
+// ByteWriter is the interface that wraps the WriteByte method.
+type ByteWriter interface {
+	WriteByte(c byte) error
+}
+
+// RuneReader is the interface that wraps the ReadRune method.
+type RuneReader interface {
+	ReadRune() (r rune, size int, err error)
+}
+
+// RuneScanner is the interface that adds the UnreadRune method to RuneReader.
+type RuneScanner interface {
+	RuneReader
+	UnreadRune() error
+}
+
+// StringWriter is the interface that wraps the WriteString method.
+type StringWriter interface {
+	WriteString(s string) (n int, err error)
+}
+
+// ReaderFrom is the interface that wraps the ReadFrom method.
+type ReaderFrom interface {
+	ReadFrom(r Reader) (n int64, err error)
+}
+
+// WriterTo is the interface that wraps the WriteTo method.
+type WriterTo interface {
+	WriteTo(w Writer) (n int64, err error)
+}
+
+// ReadAtLeast reads from r into buf until it has read at least min bytes.
+func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
+	if len(buf) < min {
+		return 0, ErrShortBuffer
+	}
+	for n < min && err == nil {
+		var nn int
+		nn, err = r.Read(buf[n:])
+		n += nn
+	}
+	if n >= min {
+		err = nil
+	} else if n > 0 && err == EOF {
+		err = ErrUnexpectedEOF
+	}
+	return
+}
+
+// ReadFull reads exactly len(buf) bytes from r into buf.
+func ReadFull(r Reader, buf []byte) (n int, err error) {
+	n, err = ReadAtLeast(r, buf, len(buf))
+	return
+}
+
+type nopCloser struct {
+	r Reader
+}
+
+func (n nopCloser) Read(p []byte) (int, error) {
+	rn, err := n.r.Read(p)
+	return rn, err
+}
+
+func (nopCloser) Close() error {
+	return nil
+}
+
+// NopCloser returns a ReadCloser with a no-op Close method wrapping r.
+func NopCloser(r Reader) ReadCloser {
+	return nopCloser{r: r}
+}
+
+type teeReader struct {
+	r Reader
+	w Writer
+}
+
+func (t *teeReader) Read(p []byte) (n int, err error) {
+	n, err = t.r.Read(p)
+	if n > 0 {
+		if _, werr := t.w.Write(p[:n]); werr != nil {
+			return n, werr
+		}
+	}
+	return
+}
+
+// TeeReader returns a Reader that writes to w what it reads from r.
+func TeeReader(r Reader, w Writer) Reader {
+	return &teeReader{r: r, w: w}
+}
+
+type multiReader struct {
+	readers []Reader
+}
+
+func (mr *multiReader) Read(p []byte) (n int, err error) {
+	for len(mr.readers) > 0 {
+		n, err = mr.readers[0].Read(p)
+		if err == EOF {
+			mr.readers = mr.readers[1:]
+		}
+		if n > 0 || err != EOF {
+			if err == EOF && len(mr.readers) > 0 {
+				err = nil
+			}
+			return
+		}
+	}
+	return 0, EOF
+}
+
+// MultiReader returns a Reader that's the logical concatenation of readers.
+func MultiReader(readers ...Reader) Reader {
+	r := make([]Reader, len(readers))
+	copy(r, readers)
+	return &multiReader{readers: r}
+}
+
+type multiWriter struct {
+	writers []Writer
+}
+
+func (t *multiWriter) Write(p []byte) (n int, err error) {
+	for _, w := range t.writers {
+		n, err = w.Write(p)
+		if err != nil {
+			return
+		}
+		if n != len(p) {
+			err = ErrShortWrite
+			return
+		}
+	}
+	return len(p), nil
+}
+
+func (t *multiWriter) WriteString(s string) (n int, err error) {
+	p := []byte(s)
+	for _, w := range t.writers {
+		n, err = w.Write(p)
+		if err != nil {
+			return
+		}
+		if n != len(p) {
+			err = ErrShortWrite
+			return
+		}
+	}
+	return len(p), nil
+}
+
+// MultiWriter creates a writer that duplicates its writes to all writers.
+func MultiWriter(writers ...Writer) Writer {
+	allWriters := make([]Writer, 0, len(writers))
+	for _, w := range writers {
+		if mw, ok := w.(*multiWriter); ok {
+			allWriters = append(allWriters, mw.writers...)
+		} else {
+			allWriters = append(allWriters, w)
+		}
+	}
+	return &multiWriter{writers: allWriters}
+}
+
+// SectionReader implements Read, Seek, and ReadAt on a section of an underlying ReaderAt.
+type SectionReader struct {
+	r     ReaderAt
+	base  int64
+	off   int64
+	limit int64
+	n     int64
+}
+
+// NewSectionReader returns a SectionReader that reads from r
+// starting at offset off and stops with EOF after n bytes.
+func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader {
+	var remaining int64 = 1<<63 - 1 - off
+	if n <= remaining {
+		remaining = n
+	}
+	return &SectionReader{r: r, base: off, off: off, limit: off + remaining, n: n}
+}
+
+func (s *SectionReader) Read(p []byte) (n int, err error) {
+	if s.off >= s.limit {
+		return 0, EOF
+	}
+	if max := s.limit - s.off; int64(len(p)) > max {
+		p = p[0:max]
+	}
+	n, err = s.r.ReadAt(p, s.off)
+	s.off += int64(n)
+	return
+}
+
+var errWhence = errors.New("Seek: invalid whence")
+var errOffset = errors.New("Seek: invalid offset")
+
+func (s *SectionReader) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	default:
+		return 0, errWhence
+	case SeekStart:
+		offset += s.base
+	case SeekCurrent:
+		offset += s.off
+	case SeekEnd:
+		offset += s.limit
+	}
+	if offset < s.base {
+		return 0, errOffset
+	}
+	s.off = offset
+	return offset - s.base, nil
+}
+
+func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error) {
+	if off < 0 || off >= s.Size() {
+		return 0, EOF
+	}
+	off += s.base
+	if max := s.limit - off; int64(len(p)) > max {
+		p = p[0:max]
+		n, err = s.r.ReadAt(p, off)
+		if err == nil {
+			err = EOF
+		}
+		return n, err
+	}
+	n, err = s.r.ReadAt(p, off)
+	return n, err
+}
+
+// Size returns the size of the section in bytes.
+func (s *SectionReader) Size() int64 { return s.limit - s.base }
+
+// Outer returns the underlying ReaderAt and offsets for the section.
+func (s *SectionReader) Outer() (r ReaderAt, off int64, n int64) {
+	return s.r, s.base, s.n
+}

package/stdlib/iter/iter.go

@@ -0,0 +1,18 @@
+//go:build gofront
+
+//gofront:target both
+
+// Package iter provides basic definitions related to iterators over
+// sequences. Same API as Go's iter package; Pull and Pull2 need coroutines
+// and are not available.
+package iter
+
+// Seq is an iterator over sequences of individual values. When called as
+// seq(yield), seq calls yield(v) for each value v in the sequence, stopping
+// early if yield returns false.
+type Seq[V any] func(yield func(V) bool)
+
+// Seq2 is an iterator over sequences of pairs of values, most commonly
+// key-value pairs. When called as seq(yield), seq calls yield(k, v) for each
+// pair (k, v) in the sequence, stopping early if yield returns false.
+type Seq2[K, V any] func(yield func(K, V) bool)

package/stdlib/maps/iter.go

@@ -0,0 +1,65 @@
+//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/math/extra.go

@@ -0,0 +1,270 @@
+package math
+
+import "math/bits"
+
+const (
+	mask           = 0x7FF
+	shift          = 52
+	bias           = 1023
+	signMask       uint64 = 1 << 63
+	fracMask       uint64 = 1<<52 - 1
+	maskShift      uint64 = 0x7FF0000000000000
+	biasShift      uint64 = 0x3FE0000000000000
+	SmallestNormal        = 2.2250738585072014e-308
+	halfMinusULP   uint64 = (1 << (52 - 1)) - 1
+	uvinf          uint64 = 0x7FF0000000000000
+)
+
+func normalize(x float64) (y float64, exp int) {
+	if Abs(x) < SmallestNormal {
+		return x * (1 << 52), -52
+	}
+	return x, 0
+}
+
+func Frexp(f float64) (frac float64, exp int) {
+	switch {
+	case f == 0:
+		return f, 0
+	case IsInf(f, 0) || IsNaN(f):
+		return f, 0
+	}
+	f, exp = normalize(f)
+	x := Float64bits(f)
+	exp += int((x>>shift)&mask) - bias + 1
+	x = x &^ maskShift
+	x |= biasShift
+	frac = Float64frombits(x)
+	return
+}
+
+func Ldexp(frac float64, exp int) float64 {
+	switch {
+	case frac == 0:
+		return frac
+	case IsInf(frac, 0) || IsNaN(frac):
+		return frac
+	}
+	f, e := normalize(frac)
+	exp += e
+	x := Float64bits(f)
+	exp += int(x>>shift)&mask - bias
+	if exp < -1075 {
+		return Copysign(0, f)
+	}
+	if exp > 1023 {
+		if f < 0 {
+			return Inf(-1)
+		}
+		return Inf(1)
+	}
+	var m float64 = 1
+	if exp < -1022 {
+		exp += 53
+		m = 1.0 / (1 << 53)
+	}
+	x = x &^ maskShift
+	x |= uint64(exp+bias) << 52
+	return m * Float64frombits(x)
+}
+
+func Modf(f float64) (int float64, frac float64) {
+	if IsInf(f, 0) {
+		return f, NaN()
+	}
+	if IsNaN(f) {
+		return NaN(), NaN()
+	}
+	int = Trunc(f)
+	frac = Copysign(f-int, f)
+	return
+}
+
+func RoundToEven(x float64) float64 {
+	b := Float64bits(x)
+	e := uint(b>>shift) & mask
+	if e >= bias {
+		e -= bias
+		b += (halfMinusULP + (b>>(shift-e))&1) >> e
+		b = b &^ (fracMask >> e)
+	} else if e == bias-1 && b&fracMask != 0 {
+		b = b&signMask | 0x3FF0000000000000
+	} else {
+		b &= signMask
+	}
+	return Float64frombits(b)
+}
+
+func Nextafter32(x, y float32) (r float32) {
+	switch {
+	case IsNaN(float64(x)) || IsNaN(float64(y)):
+		r = float32(NaN())
+	case x == y:
+		r = x
+	case x == 0:
+		r = float32(Copysign(float64(Float32frombits(1)), float64(y)))
+	case (y > x) == (x > 0):
+		r = Float32frombits(Float32bits(x) + 1)
+	default:
+		r = Float32frombits(Float32bits(x) - 1)
+	}
+	return
+}
+
+func Nextafter(x, y float64) (r float64) {
+	switch {
+	case IsNaN(x) || IsNaN(y):
+		r = NaN()
+	case x == y:
+		r = x
+	case x == 0:
+		r = Copysign(Float64frombits(1), y)
+	case (y > x) == (x > 0):
+		r = Float64frombits(Float64bits(x) + 1)
+	default:
+		r = Float64frombits(Float64bits(x) - 1)
+	}
+	return
+}
+
+// --- FMA ---
+
+func fmaZero(x uint64) uint64 {
+	if x == 0 {
+		return 1
+	}
+	return 0
+}
+
+func fmaNonzero(x uint64) uint64 {
+	if x != 0 {
+		return 1
+	}
+	return 0
+}
+
+func fmaShl(u1, u2 uint64, n uint) (r1 uint64, r2 uint64) {
+	r1 = u1<<n | u2>>(64-n) | u2<<(n-64)
+	r2 = u2 << n
+	return
+}
+
+func fmaShr(u1, u2 uint64, n uint) (r1 uint64, r2 uint64) {
+	r2 = u2>>n | u1<<(64-n) | u1>>(n-64)
+	r1 = u1 >> n
+	return
+}
+
+func fmaShrcompress(u1, u2 uint64, n uint) (r1 uint64, r2 uint64) {
+	switch {
+	case n == 0:
+		return u1, u2
+	case n == 64:
+		return 0, u1 | fmaNonzero(u2)
+	case n >= 128:
+		return 0, fmaNonzero(u1 | u2)
+	case n < 64:
+		r1, r2 = fmaShr(u1, u2, n)
+		r2 |= fmaNonzero(u2 & (1<<n - 1))
+	case n < 128:
+		r1, r2 = fmaShr(u1, u2, n)
+		r2 |= fmaNonzero(u1&(1<<(n-64)-1) | u2)
+	}
+	return
+}
+
+func fmaLz(u1, u2 uint64) (l int32) {
+	l = int32(bits.LeadingZeros64(u1))
+	if l == 64 {
+		l += int32(bits.LeadingZeros64(u2))
+	}
+	return l
+}
+
+func fmaSplit(b uint64) (sign uint32, exp int32, mantissa uint64) {
+	sign = uint32(b >> 63)
+	exp = int32(b>>52) & mask
+	mantissa = b & fracMask
+	if exp == 0 {
+		shift := uint(bits.LeadingZeros64(mantissa) - 11)
+		mantissa <<= shift
+		exp = 1 - int32(shift)
+	} else {
+		mantissa |= 1 << 52
+	}
+	return
+}
+
+func fmaSpecial(x, y, z float64, bx, by, bz uint64) (float64, bool) {
+	if x == 0.0 || y == 0.0 || bx&uvinf == uvinf || by&uvinf == uvinf {
+		return x*y + z, true
+	}
+	if z == 0.0 {
+		return x * y, true
+	}
+	if bz&uvinf == uvinf {
+		return z, true
+	}
+	return 0, false
+}
+
+func fmaRound(ps uint32, pe int32, m uint64) float64 {
+	if pe > 1022+bias || pe == 1022+bias && (m+1<<9)>>63 == 1 {
+		return Float64frombits(uint64(ps)<<63 | uvinf)
+	}
+	if pe < 0 {
+		n := uint(-pe)
+		m = m>>n | fmaNonzero(m&(1<<n-1))
+		pe = 0
+	}
+	m = ((m + 1<<9) >> 10) & ^fmaZero((m&(1<<10-1))^1<<9)
+	pe &= -int32(fmaNonzero(m))
+	return Float64frombits(uint64(ps)<<63 + uint64(pe)<<52 + m)
+}
+
+func FMA(x, y, z float64) float64 {
+	bx, by, bz := Float64bits(x), Float64bits(y), Float64bits(z)
+	if val, ok := fmaSpecial(x, y, z, bx, by, bz); ok {
+		return val
+	}
+
+	xs, xe, xm := fmaSplit(bx)
+	ys, ye, ym := fmaSplit(by)
+	zs, ze, zm := fmaSplit(bz)
+
+	pe := xe + ye - bias + 1
+	pm1, pm2 := bits.Mul64(xm<<10, ym<<11)
+	zm1, zm2 := zm<<10, uint64(0)
+	ps := xs ^ ys
+
+	is62zero := uint((^pm1 >> 62) & 1)
+	pm1, pm2 = fmaShl(pm1, pm2, is62zero)
+	pe -= int32(is62zero)
+
+	if pe < ze || pe == ze && pm1 < zm1 {
+		ps, pe, pm1, pm2, zs, ze, zm1, zm2 = zs, ze, zm1, zm2, ps, pe, pm1, pm2
+	}
+
+	if ps != zs && pe == ze && pm1 == zm1 && pm2 == zm2 {
+		return 0
+	}
+
+	zm1, zm2 = fmaShrcompress(zm1, zm2, uint(pe-ze))
+
+	var m, c uint64
+	if ps == zs {
+		pm2, c = bits.Add64(pm2, zm2, 0)
+		pm1, _ = bits.Add64(pm1, zm1, c)
+		pe -= int32(^pm1 >> 63)
+		pm1, m = fmaShrcompress(pm1, pm2, uint(64+pm1>>63))
+	} else {
+		pm2, c = bits.Sub64(pm2, zm2, 0)
+		pm1, _ = bits.Sub64(pm1, zm1, c)
+		nz := fmaLz(pm1, pm2)
+		pe -= nz
+		m, pm2 = fmaShl(pm1, pm2, uint(nz-1))
+		m |= fmaNonzero(pm2)
+	}
+
+	return fmaRound(ps, pe, m)
+}