goscript 0.1.0 → 0.1.2

package/gs/io/io.ts

@@ -49,6 +49,9 @@ export interface Writer {
   Write(p: $.Bytes): [number, $.GoError]
 }
 
+type ReaderLike = Reader | { Reader: Reader | null } | null
+type WriterLike = Writer | { Writer: Writer | null } | null
+
 // Closer is the interface that wraps the basic Close method
 export interface Closer {
   Close(): $.GoError
@@ -68,6 +71,110 @@ export interface ReadSeeker extends Reader, Seeker {}
 export interface WriteSeeker extends Writer, Seeker {}
 export interface ReadWriteSeeker extends Reader, Writer, Seeker {}
 
+class pipeState {
+  private chunks: Uint8Array[] = []
+  private readOffset = 0
+  private readerClosed = false
+  private writerClosed = false
+  private readerErr: $.GoError = null
+  private writerErr: $.GoError = null
+
+  Read(p: $.Bytes): [number, $.GoError] {
+    if (this.readerClosed) {
+      return [0, this.readerErr ?? ErrClosedPipe]
+    }
+    if ($.len(p) === 0) {
+      return [0, null]
+    }
+    if (this.chunks.length === 0) {
+      if (this.writerClosed) {
+        return [0, this.writerErr ?? EOF]
+      }
+      return [0, EOF]
+    }
+
+    let copied = 0
+    while (copied < $.len(p) && this.chunks.length > 0) {
+      const chunk = this.chunks[0]
+      const available = chunk.length - this.readOffset
+      const want = Math.min($.len(p) - copied, available)
+      const target = $.goSlice(p, copied, copied + want)
+      $.copy(target, chunk.subarray(this.readOffset, this.readOffset + want))
+      copied += want
+      this.readOffset += want
+      if (this.readOffset === chunk.length) {
+        this.chunks.shift()
+        this.readOffset = 0
+      }
+    }
+    return [copied, null]
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    if (this.writerClosed || this.readerClosed) {
+      return [0, this.readerErr ?? ErrClosedPipe]
+    }
+    const data = new Uint8Array($.len(p))
+    $.copy(data, p)
+    this.chunks.push(data)
+    return [$.len(p), null]
+  }
+
+  CloseReader(err: $.GoError): $.GoError {
+    this.readerClosed = true
+    this.readerErr = err
+    this.chunks = []
+    this.readOffset = 0
+    return null
+  }
+
+  CloseWriter(err: $.GoError): $.GoError {
+    this.writerClosed = true
+    this.writerErr = err
+    return null
+  }
+}
+
+// PipeReader is the read half of a pipe.
+export class PipeReader implements Reader, Closer {
+  constructor(private pipe: pipeState) {}
+
+  Read(data: $.Bytes): [number, $.GoError] {
+    return this.pipe.Read(data)
+  }
+
+  Close(): $.GoError {
+    return this.CloseWithError(null)
+  }
+
+  CloseWithError(err: $.GoError): $.GoError {
+    return this.pipe.CloseReader(err ?? ErrClosedPipe)
+  }
+}
+
+// PipeWriter is the write half of a pipe.
+export class PipeWriter implements Writer, Closer {
+  constructor(private pipe: pipeState) {}
+
+  Write(data: $.Bytes): [number, $.GoError] {
+    return this.pipe.Write(data)
+  }
+
+  Close(): $.GoError {
+    return this.CloseWithError(null)
+  }
+
+  CloseWithError(err: $.GoError): $.GoError {
+    return this.pipe.CloseWriter(err ?? EOF)
+  }
+}
+
+// Pipe creates a synchronous in-memory pipe.
+export function Pipe(): [PipeReader, PipeWriter] {
+  const pipe = new pipeState()
+  return [new PipeReader(pipe), new PipeWriter(pipe)]
+}
+
 // ReaderAt is the interface that wraps the basic ReadAt method
 export interface ReaderAt {
   ReadAt(p: $.Bytes, off: number): [number, $.GoError]
@@ -150,18 +257,20 @@ export class LimitedReader implements Reader {
   }
 
   Read(p: $.Bytes): [number, $.GoError] {
-    if (this.N <= 0) {
-      return [0, EOF]
-    }
+    return (async (): Promise<[number, $.GoError]> => {
+      if (this.N <= 0) {
+        return [0, EOF]
+      }
 
-    let readBuf = p
-    if ($.len(p) > this.N) {
-      readBuf = $.goSlice(p, 0, this.N)
-    }
+      let readBuf = p
+      if ($.len(p) > this.N) {
+        readBuf = $.goSlice(p, 0, this.N)
+      }
 
-    const [n, err] = this.R.Read(readBuf)
-    this.N -= n
-    return [n, err]
+      const [n, err] = await (this.R.Read(readBuf) as any)
+      this.N -= n
+      return [n, err]
+    })() as any
   }
 }
 
@@ -308,24 +417,33 @@ export function NewOffsetWriter(w: WriterAt, off: number): OffsetWriter {
 }
 
 // Copy copies from src to dst until either EOF is reached on src or an error occurs
-export function Copy(dst: Writer, src: Reader): [number, $.GoError] {
-  return CopyBuffer(dst, src, null)
+export async function Copy(
+  dst: WriterLike,
+  src: ReaderLike,
+): Promise<[number, $.GoError]> {
+  return await CopyBuffer(dst, src, null)
 }
 
 // CopyBuffer is identical to Copy except that it stages through the provided buffer
-export function CopyBuffer(
-  dst: Writer,
-  src: Reader,
+export async function CopyBuffer(
+  dst: WriterLike,
+  src: ReaderLike,
   buf: $.Bytes | null,
-): [number, $.GoError] {
+): Promise<[number, $.GoError]> {
+  dst = unwrapWriter(dst)
+  src = unwrapReader(src)
+  if (dst === null || src === null) {
+    return [0, newError('io: copy with nil reader or writer')]
+  }
+
   // If src implements WriterTo, use it
   if ('WriteTo' in src && typeof (src as any).WriteTo === 'function') {
-    return (src as WriterTo).WriteTo(dst)
+    return await ((src as WriterTo).WriteTo(dst) as any)
   }
 
   // If dst implements ReaderFrom, use it
   if ('ReadFrom' in dst && typeof (dst as any).ReadFrom === 'function') {
-    return (dst as ReaderFrom).ReadFrom(src)
+    return await ((dst as ReaderFrom).ReadFrom(src) as any)
   }
 
   if (buf === null) {
@@ -334,9 +452,9 @@ export function CopyBuffer(
 
   let written = 0
   while (true) {
-    const [nr, er] = src.Read(buf)
+    const [nr, er] = await (src.Read(buf) as any)
     if (nr > 0) {
-      const [nw, ew] = dst.Write($.goSlice(buf, 0, nr))
+      const [nw, ew] = await (dst.Write($.goSlice(buf, 0, nr)) as any)
       if (nw < 0 || nr < nw) {
         if (ew === null) {
           return [written, ErrShortWrite]
@@ -361,13 +479,33 @@ export function CopyBuffer(
   return [written, null]
 }
 
+function unwrapReader(src: ReaderLike): Reader | null {
+  if (src == null) {
+    return null
+  }
+  if ('Read' in src && typeof (src as any).Read === 'function') {
+    return src as Reader
+  }
+  return (src as { Reader: Reader | null }).Reader
+}
+
+function unwrapWriter(dst: WriterLike): Writer | null {
+  if (dst == null) {
+    return null
+  }
+  if ('Write' in dst && typeof (dst as any).Write === 'function') {
+    return dst as Writer
+  }
+  return (dst as { Writer: Writer | null }).Writer
+}
+
 // CopyN copies n bytes (or until an error) from src to dst
-export function CopyN(
+export async function CopyN(
   dst: Writer,
   src: Reader,
   n: number,
-): [number, $.GoError] {
-  const [written, err] = Copy(dst, LimitReader(src, n))
+): Promise<[number, $.GoError]> {
+  const [written, err] = await Copy(dst, LimitReader(src, n))
   if (written === n) {
     return [written, null]
   }
@@ -379,23 +517,26 @@ export function CopyN(
 }
 
 // ReadAtLeast reads from r into buf until it has read at least min bytes
-export function ReadAtLeast(
+export async function ReadAtLeast(
   r: Reader,
   buf: $.Bytes,
   min: number,
-): [number, $.GoError] {
+): Promise<[number, $.GoError]> {
   if ($.len(buf) < min) {
     return [0, ErrShortBuffer]
   }
 
   let n = 0
   while (n < min) {
-    const [nn, err] = r.Read($.goSlice(buf, n))
+    const [nn, err] = await (r.Read($.goSlice(buf, n)) as any)
     n += nn
     if (err !== null) {
       if (err === EOF && n >= min) {
         return [n, null]
       }
+      if (err === EOF && n === 0) {
+        return [n, EOF]
+      }
       if (err === EOF && n < min) {
         return [n, ErrUnexpectedEOF]
       }
@@ -406,20 +547,25 @@ export function ReadAtLeast(
 }
 
 // ReadFull reads exactly len(buf) bytes from r into buf
-export function ReadFull(r: Reader, buf: $.Bytes): [number, $.GoError] {
-  return ReadAtLeast(r, buf, $.len(buf))
+export async function ReadFull(
+  r: Reader,
+  buf: $.Bytes,
+): Promise<[number, $.GoError]> {
+  return await ReadAtLeast(r, buf, $.len(buf))
 }
 
 // ReadAll reads from r until an error or EOF and returns the data it read
-export function ReadAll(r: Reader): [$.Bytes, $.GoError] {
+export async function ReadAll(r: Reader): Promise<[$.Bytes, $.GoError]> {
   const chunks: $.Bytes[] = []
   let totalLength = 0
   const buf = $.makeSlice<number>(512, undefined, 'byte')
 
   while (true) {
-    const [n, err] = r.Read(buf)
+    const [n, err] = await (r.Read(buf) as any)
     if (n > 0) {
-      chunks.push($.goSlice(buf, 0, n))
+      const chunk = $.makeSlice<number>(n, undefined, 'byte')
+      $.copy(chunk, $.goSlice(buf, 0, n))
+      chunks.push(chunk)
       totalLength += n
     }
     if (err !== null) {

package/gs/io/meta.json

@@ -5,5 +5,13 @@
     "path",
     "time",
     "unicode/utf8"
-  ]
-} 
+  ],
+  "asyncFunctions": {
+    "Copy": true,
+    "CopyBuffer": true,
+    "CopyN": true,
+    "ReadAtLeast": true,
+    "ReadFull": true,
+    "ReadAll": true
+  }
+}

package/gs/iter/iter.ts

@@ -1,11 +1,17 @@
 // TypeScript implementation of Go's iter package
 // This provides iterator types and functions
 
+export type YieldResult = boolean | globalThis.Promise<boolean>
+
 // Seq is an iterator over sequences of individual values
-export type Seq<V> = (_yield: (value: V) => boolean) => void
+export type Seq<V> = (
+  _yield: ((value: V) => YieldResult) | null,
+) => void | globalThis.Promise<void>
 
 // Seq2 is an iterator over sequences of pairs of values
-export type Seq2<K, V> = (_yield: (key: K, value: V) => boolean) => void
+export type Seq2<K, V> = (
+  _yield: ((key: K, value: V) => YieldResult) | null,
+) => void | globalThis.Promise<void>
 
 // Pull converts the "push-style" iterator sequence seq into a "pull-style" iterator
 // Returns a function that returns the next value and a boolean indicating if iteration should continue

package/gs/maps/iter.ts

@@ -5,45 +5,39 @@ import * as iter from '@goscript/iter/index.js'
 // 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.
-export function All<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq2<K, V> {
-  return (_yield: ((p0: K, p1: V) => boolean) | null): void => {
-    for (const [k, v] of m.entries()) {
-      if (!_yield!(k, v)) {
-        return
-      }
-    }
-  }
+export function All<K extends $.Comparable | null, V>(
+  m: Map<K, V> | null,
+): iter.Seq2<K, V> {
+  return (_yield: ((p0: K, p1: V) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iteratePairs(m?.entries() ?? [], _yield)
 }
 
 // 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.
-export function Keys<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<K> {
-  return (_yield: ((p0: K) => boolean) | null): void => {
-    for (const [k, _v] of m.entries()) {
-      if (!_yield!(k)) {
-        return
-      }
-    }
-  }
+export function Keys<K extends $.Comparable | null, V>(
+  m: Map<K, V> | null,
+): iter.Seq<K> {
+  return (_yield: ((p0: K) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iterateValues(mapKeys(m), _yield)
 }
 
 // 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.
-export function Values<K extends $.Comparable, V>(m: Map<K, V>): iter.Seq<V> {
-  return (_yield: ((p0: V) => boolean) | null): void => {
-    for (const [_k, v] of m.entries()) {
-      if (!_yield!(v)) {
-        return
-      }
-    }
-  }
+export function Values<K extends $.Comparable | null, V>(
+  m: Map<K, V> | null,
+): iter.Seq<V> {
+  return (_yield: ((p0: V) => iter.YieldResult) | null):
+    | void
+    | globalThis.Promise<void> => iterateValues(mapValues(m), _yield)
 }
 
 // Insert adds the key-value pairs from seq to m.
 // If a key in seq already exists in m, its value will be overwritten.
-export function Insert<K extends $.Comparable, V>(
+export function Insert<K extends $.Comparable | null, V>(
   m: Map<K, V>,
   seq: iter.Seq2<K, V>,
 ): void {
@@ -58,10 +52,65 @@ export function Insert<K extends $.Comparable, V>(
 
 // Collect collects key-value pairs from seq into a new map
 // and returns it.
-export function Collect<K extends $.Comparable, V>(
+export function Collect<K extends $.Comparable | null, V>(
   seq: iter.Seq2<K, V>,
 ): Map<K, V> {
   let m = $.makeMap<K, V>()
   Insert(m, seq)
   return m
 }
+
+function mapKeys<K extends $.Comparable | null, V>(m: Map<K, V> | null): K[] {
+  return Array.from(m?.keys() ?? [])
+}
+
+function mapValues<K extends $.Comparable | null, V>(m: Map<K, V> | null): V[] {
+  return Array.from(m?.values() ?? [])
+}
+
+function iterateValues<T>(
+  values: Iterable<T>,
+  yieldValue: ((value: T) => iter.YieldResult) | null,
+): void | globalThis.Promise<void> {
+  const items = Array.from(values)
+  const walk = (idx: number): void | globalThis.Promise<void> => {
+    for (; idx < items.length; idx++) {
+      const keepGoing = yieldValue!(items[idx])
+      if (keepGoing instanceof Promise) {
+        return keepGoing.then((next) => {
+          if (next) {
+            return walk(idx + 1)
+          }
+        })
+      }
+      if (!keepGoing) {
+        return
+      }
+    }
+  }
+  return walk(0)
+}
+
+function iteratePairs<K, V>(
+  entries: Iterable<[K, V]>,
+  yieldValue: ((key: K, value: V) => iter.YieldResult) | null,
+): void | globalThis.Promise<void> {
+  const items = Array.from(entries)
+  const walk = (idx: number): void | globalThis.Promise<void> => {
+    for (; idx < items.length; idx++) {
+      const [key, value] = items[idx]
+      const keepGoing = yieldValue!(key, value)
+      if (keepGoing instanceof Promise) {
+        return keepGoing.then((next) => {
+          if (next) {
+            return walk(idx + 1)
+          }
+        })
+      }
+      if (!keepGoing) {
+        return
+      }
+    }
+  }
+  return walk(0)
+}

package/gs/maps/maps.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { Clone, Values } from './index.js'
+
+describe('maps overrides', () => {
+  it('accept nilable comparable keys', () => {
+    const source = new Map<object | null, number>()
+    const key = { name: 'type' }
+    source.set(null, 1)
+    source.set(key, 2)
+
+    const cloned = Clone(source)
+    expect(cloned?.get(null)).toBe(1)
+    expect(cloned?.get(key)).toBe(2)
+
+    const values: number[] = []
+    Values(cloned)((value) => {
+      values.push(value)
+      return true
+    })
+    expect(values.sort()).toEqual([1, 2])
+  })
+})

package/gs/maps/maps.ts

@@ -4,7 +4,7 @@ import * as _ from '@goscript/unsafe/index.js'
 
 // Equal reports whether two maps contain the same key/value pairs.
 // Values are compared using ==.
-export function Equal<K extends $.Comparable, V extends $.Comparable>(
+export function Equal<K extends $.Comparable | null, V extends $.Comparable | null>(
   m1: Map<K, V>,
   m2: Map<K, V>,
 ): boolean {
@@ -22,7 +22,7 @@ export function Equal<K extends $.Comparable, V extends $.Comparable>(
 
 // EqualFunc is like Equal, but compares values using eq.
 // Keys are still compared with ==.
-export function EqualFunc<K extends $.Comparable, V1, V2>(
+export function EqualFunc<K extends $.Comparable | null, V1, V2>(
   m1: Map<K, V1>,
   m2: Map<K, V2>,
   eq: ((p0: V1, p1: V2) => boolean) | null,
@@ -40,7 +40,7 @@ export function EqualFunc<K extends $.Comparable, V1, V2>(
 }
 
 // clone returns a shallow copy of the map.
-export function clone<K extends $.Comparable, V>(
+export function clone<K extends $.Comparable | null, V>(
   m: Map<K, V> | null,
 ): Map<K, V> | null {
   if (m == null) {
@@ -55,29 +55,31 @@ export function clone<K extends $.Comparable, V>(
 
 // Clone returns a copy of m.  This is a shallow clone:
 // the new keys and values are set using ordinary assignment.
-export function Clone<K extends $.Comparable, V>(m: Map<K, V>): Map<K, V> {
+export function Clone<K extends $.Comparable | null, V>(
+  m: Map<K, V> | null,
+): Map<K, V> | null {
   // Preserve nil in case it matters.
   if (m == null) {
-    return null as unknown as Map<K, V>
+    return null
   }
-  return clone(m)!
+  return clone(m)
 }
 
 // Copy copies all key/value pairs in src adding them to dst.
 // When a key in src is already present in dst,
 // the value in dst will be overwritten by the value associated
 // with the key in src.
-export function Copy<K extends $.Comparable, V>(
-  dst: Map<K, V>,
-  src: Map<K, V>,
+export function Copy<K extends $.Comparable | null, V>(
+  dst: Map<K, V> | null,
+  src: Map<K, V> | null,
 ): void {
-  for (const [k, v] of src.entries()) {
+  for (const [k, v] of src?.entries() ?? []) {
     $.mapSet(dst, k, v)
   }
 }
 
 // DeleteFunc deletes any key/value pairs from m for which del returns true.
-export function DeleteFunc<K extends $.Comparable, V>(
+export function DeleteFunc<K extends $.Comparable | null, V>(
   m: Map<K, V>,
   del: ((p0: K, p1: V) => boolean) | null,
 ): void {

package/gs/math/bits/index.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+
+import { Mul64 } from './index.js'
+
+describe('math/bits override', () => {
+  it('returns the full 128-bit product from Mul64', () => {
+    expect(Mul64(0xffffffffffffffffn, 0xffffffffffffffffn)).toEqual([
+      0xfffffffffffffffen,
+      1n,
+    ])
+    expect(Mul64(0x1fffffffffffffn, 0x1fffffffffffffn)).toEqual([
+      0x3ffffffffffn,
+      0xffc0000000000001n,
+    ])
+    expect(Mul64(0x1fffffffffffff, 0x1fffffffffffff)).toEqual([
+      0x3ffffffffff,
+      0xffc0000000000001n,
+    ])
+  })
+})