goscript 0.1.0 → 0.1.2

package/gs/sort/slice.gs.ts

@@ -8,44 +8,101 @@ interface SliceMetadata<T> {
   capacity: number
 }
 
-// Helper function to swap elements in a slice
-function swapInSlice<T>(slice: $.Slice<T>, i: number, j: number): void {
+type LessFunc = (
+  i: number,
+  j: number,
+) => boolean | globalThis.Promise<boolean>
+
+function setInSlice<T>(slice: $.Slice<T>, i: number, value: T): void {
   if (!slice) return
-  
-  const temp = $.index(slice, i)
-  if (Array.isArray(slice)) {
-    const val_j = $.index(slice, j)
-    const val_i = temp
-    slice[i] = val_j as T
-    slice[j] = val_i as T
+
+  if (Array.isArray(slice) || slice instanceof Uint8Array) {
+    ;(slice as any)[i] = value
   } else if (typeof slice === 'object' && '__meta__' in slice) {
     const meta = (slice as any).__meta__ as SliceMetadata<T>
-    const backing = meta.backing
-    backing[meta.offset + i] = $.index(slice, j) as T
-    backing[meta.offset + j] = temp as T
+    meta.backing[meta.offset + i] = value
+  }
+}
+
+async function sortedIndices(n: number, less: LessFunc): Promise<number[]> {
+  const indices = Array.from({ length: n }, (_, i) => i)
+  await sortIndexRange(indices, 0, indices.length, less)
+  return indices
+}
+
+async function sortIndexRange(
+  indices: number[],
+  lo: number,
+  hi: number,
+  less: LessFunc,
+): Promise<void> {
+  if (hi - lo <= 16) {
+    for (let i = lo + 1; i < hi; i++) {
+      const value = indices[i]
+      let j = i
+      while (j > lo && (await less(value, indices[j - 1]))) {
+        indices[j] = indices[j - 1]
+        j--
+      }
+      indices[j] = value
+    }
+    return
+  }
+
+  const mid = lo + Math.floor((hi - lo) / 2)
+  await sortIndexRange(indices, lo, mid, less)
+  await sortIndexRange(indices, mid, hi, less)
+
+  const merged: number[] = []
+  let left = lo
+  let right = mid
+  while (left < mid && right < hi) {
+    if (await less(indices[right], indices[left])) {
+      merged.push(indices[right])
+      right++
+    } else {
+      merged.push(indices[left])
+      left++
+    }
+  }
+  while (left < mid) {
+    merged.push(indices[left])
+    left++
+  }
+  while (right < hi) {
+    merged.push(indices[right])
+    right++
+  }
+  for (let i = 0; i < merged.length; i++) {
+    indices[lo + i] = merged[i]
   }
 }
 
 // Slice sorts the slice x given the provided less function
-export function Slice(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
+export async function Slice(
+  x: $.Slice<any>,
+  less: LessFunc,
+): globalThis.Promise<void> {
   if (!x) return
-  
-  // Simple insertion sort using the provided less function
+
   const n = $.len(x)
-  for (let i = 1; i < n; i++) {
-    for (let j = i; j > 0 && less(j, j - 1); j--) {
-      swapInSlice(x, j, j - 1)
-    }
+  const indices = await sortedIndices(n, less)
+  const sorted = indices.map((index) => $.index(x, index))
+  for (let i = 0; i < sorted.length; i++) {
+    setInSlice(x, i, sorted[i])
   }
 }
 
 // SliceIsSorted reports whether the slice x is sorted according to the provided less function
-export function SliceIsSorted(x: $.Slice<any>, less: (i: number, j: number) => boolean): boolean {
+export async function SliceIsSorted(
+  x: $.Slice<any>,
+  less: LessFunc,
+): globalThis.Promise<boolean> {
   if (!x) return true
-  
+
   const n = $.len(x)
   for (let i = n - 1; i > 0; i--) {
-    if (less(i, i - 1)) {
+    if (await less(i, i - 1)) {
       return false
     }
   }
@@ -53,7 +110,9 @@ export function SliceIsSorted(x: $.Slice<any>, less: (i: number, j: number) => b
 }
 
 // SliceStable sorts the slice x while keeping the original order of equal elements
-export function SliceStable(x: $.Slice<any>, less: (i: number, j: number) => boolean): void {
-  // For simplicity, use the same sort - can be improved later
-  Slice(x, less)
-} 
+export async function SliceStable(
+  x: $.Slice<any>,
+  less: LessFunc,
+): globalThis.Promise<void> {
+  await Slice(x, less)
+}

package/gs/sort/slice.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
+
+import { Slice, SliceIsSorted, SliceStable } from './slice.gs.js'
+
+describe('sort.Slice override', () => {
+  it('sorts slices with logarithmic comparator growth', async () => {
+    const values = $.arrayToSlice<number>(
+      Array.from({ length: 128 }, (_, i) => 128 - i),
+    )
+    let calls = 0
+
+    await Slice(values, (i, j) => {
+      calls++
+      return values![i] < values![j]
+    })
+
+    expect(values).toEqual(Array.from({ length: 128 }, (_, i) => i + 1))
+    expect(calls).toBeLessThan(1200)
+  })
+
+  it('keeps equal values stable for SliceStable', async () => {
+    const values = $.arrayToSlice([
+      { group: 1, name: 'a' },
+      { group: 0, name: 'b' },
+      { group: 1, name: 'c' },
+      { group: 0, name: 'd' },
+    ])
+
+    await SliceStable(values, (i, j) => values![i].group < values![j].group)
+
+    expect(values?.map((value) => value.name)).toEqual(['b', 'd', 'a', 'c'])
+    expect(
+      await SliceIsSorted(
+        values,
+        (i, j) => values![i].group < values![j].group,
+      ),
+    ).toBe(true)
+  })
+})

package/gs/sort/sort.gs.ts

@@ -94,27 +94,29 @@ export class StringSlice {
 }
 
 // Sort sorts data in ascending order as determined by the Less method
-export function Sort(data: Interface): void {
+export function Sort(data: Interface | null): void {
+  const sortData = $.pointerValue(data)
   // Use a simple insertion sort for now - can be optimized later
-  const n = data.Len()
+  const n = sortData.Len()
   for (let i = 1; i < n; i++) {
-    for (let j = i; j > 0 && data.Less(j, j - 1); j--) {
-      data.Swap(j, j - 1)
+    for (let j = i; j > 0 && sortData.Less(j, j - 1); j--) {
+      sortData.Swap(j, j - 1)
     }
   }
 }
 
 // Stable sorts data while keeping the original order of equal elements
-export function Stable(data: Interface): void {
+export function Stable(data: Interface | null): void {
   // For simplicity, use the same sort - can be improved later
   Sort(data)
 }
 
 // IsSorted reports whether data is sorted
-export function IsSorted(data: Interface): boolean {
-  const n = data.Len()
+export function IsSorted(data: Interface | null): boolean {
+  const sortData = $.pointerValue(data)
+  const n = sortData.Len()
   for (let i = n - 1; i > 0; i--) {
-    if (data.Less(i, i - 1)) {
+    if (sortData.Less(i, i - 1)) {
       return false
     }
   }
@@ -122,11 +124,12 @@ export function IsSorted(data: Interface): boolean {
 }
 
 // Reverse returns the reverse order for data
-export function Reverse(data: Interface): Interface {
+export function Reverse(data: Interface | null): Interface {
+  const sortData = $.pointerValue(data)
   return {
-    Len: () => data.Len(),
-    Less: (i: number, j: number) => data.Less(j, i),
-    Swap: (i: number, j: number) => data.Swap(i, j)
+    Len: () => sortData.Len(),
+    Less: (i: number, j: number) => sortData.Less(j, i),
+    Swap: (i: number, j: number) => sortData.Swap(i, j)
   }
 }
 
@@ -224,4 +227,4 @@ export function StringsAreSorted(x: $.Slice<string>): boolean {
     }
   }
   return true
-} 
+}

package/gs/strings/builder.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { Builder } from './builder.js'
+import { varRef } from '../builtin/varRef.js'
 
 describe('strings/Builder', () => {
   describe('Builder', () => {
@@ -89,6 +90,13 @@ describe('strings/Builder', () => {
       expect(b.Len()).toBe(11)
     })
 
+    it('should accept VarRef pointer receivers', () => {
+      const b = varRef(new Builder())
+      Builder.prototype.WriteString.call(b, 'hello')
+      expect(Builder.prototype.Len.call(b)).toBe(5)
+      expect(Builder.prototype.String.call(b)).toBe('hello')
+    })
+
     it('should handle empty writes', () => {
       const b = new Builder()
       const [n, err] = b.WriteString('')

package/gs/strings/builder.ts

@@ -1,5 +1,11 @@
 import * as $ from '@goscript/builtin/index.js'
 
+function builderValue(
+  builder: Builder | $.VarRef<Builder> | null | undefined,
+): Builder {
+  return $.pointerValue<Builder>(builder)
+}
+
 export class Builder {
   private _content: string = ''
   private _addr: Builder | null = null
@@ -16,21 +22,22 @@ export class Builder {
   }
 
   private copyCheck(): void {
-    if (this._addr == null) {
-      this._addr = this
-    } else if (this._addr !== this) {
+    const builder = builderValue(this)
+    if (builder._addr == null) {
+      builder._addr = builder
+    } else if (builder._addr !== builder) {
       $.panic('strings: illegal use of non-zero Builder copied by value')
     }
   }
 
   // String returns the accumulated string.
   public String(): string {
-    return this._content
+    return builderValue(this)._content
   }
 
   // Len returns the number of accumulated bytes; b.Len() == len(b.String()).
   public Len(): number {
-    return this._content.length
+    return builderValue(this)._content.length
   }
 
   // Cap returns the capacity of the builder's underlying byte slice. It is the
@@ -38,20 +45,21 @@ export class Builder {
   // already written.
   public Cap(): number {
     // For simplicity, return the current length since JavaScript strings are dynamic
-    return this._content.length
+    return builderValue(this)._content.length
   }
 
   // Reset resets the Builder to be empty.
   public Reset(): void {
-    this._addr = null
-    this._content = ''
+    const builder = builderValue(this)
+    builder._addr = null
+    builder._content = ''
   }
 
   // Grow grows b's capacity, if necessary, to guarantee space for
   // another n bytes. After Grow(n), at least n bytes can be written to b
   // without another allocation. If n is negative, Grow panics.
   public Grow(n: number): void {
-    this.copyCheck()
+    builderValue(this).copyCheck()
     if (n < 0) {
       $.panic('strings.Builder.Grow: negative count')
     }
@@ -60,28 +68,32 @@ export class Builder {
 
   // Write appends the contents of p to b's buffer.
   // Write always returns len(p), nil.
-  public Write(p: Uint8Array): [number, $.GoError] {
-    this.copyCheck()
+  public Write(p: $.Bytes): [number, $.GoError] {
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
     // Convert byte array to string
-    const str = new TextDecoder('utf-8').decode(p)
-    this._content += str
-    return [p.length, null]
+    const bytes = $.bytesToUint8Array(p)
+    const str = new TextDecoder('utf-8').decode(bytes)
+    builder._content += str
+    return [$.len(p), null]
   }
 
   // WriteByte appends the byte c to b's buffer.
   // The returned error is always nil.
   public WriteByte(c: number): $.GoError {
-    this.copyCheck()
-    this._content += String.fromCharCode(c)
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
+    builder._content += String.fromCharCode(c)
     return null
   }
 
   // WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
   // It returns the length of r and a nil error.
   public WriteRune(r: number): [number, $.GoError] {
-    this.copyCheck()
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
     const str = String.fromCodePoint(r)
-    this._content += str
+    builder._content += str
     // Return the byte length of the UTF-8 encoding
     const byteLength = new TextEncoder().encode(str).length
     return [byteLength, null]
@@ -90,8 +102,9 @@ export class Builder {
   // WriteString appends the contents of s to b's buffer.
   // It returns the length of s and a nil error.
   public WriteString(s: string): [number, $.GoError] {
-    this.copyCheck()
-    this._content += s
+    builderValue(this).copyCheck()
+    const builder = builderValue(this)
+    builder._content += s
     return [s.length, null]
   }
 

package/gs/strings/iter.test.ts

@@ -124,13 +124,11 @@ describe('strings/iter', () => {
     it('should handle unicode', () => {
       const parts: string[] = []
       const seq = SplitSeq('世界,你好', ',')
-      // This test expects an error due to UTF-8 slicing limitations in JavaScript
-      expect(() => {
-        seq((part: string) => {
-          parts.push(part)
-          return true
-        })
-      }).toThrow('Cannot slice string at byte indices')
+      seq((part: string) => {
+        parts.push(part)
+        return true
+      })
+      expect(parts).toEqual(['世界', '你好'])
     })
   })
 

package/gs/strings/iter.ts

@@ -23,38 +23,64 @@ const asciiSpace: { [key: number]: boolean } = {
 // If s does not end in a newline, the final yielded line will not end in a newline.
 // It returns a single-use iterator.
 export function Lines(s: string): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
-    for (; $.len(s) > 0; ) {
-      let line: string
-      {
-        let i = IndexByte(s, 10)
-        if (i >= 0) {
-          ;[line, s] = [
-            $.sliceString(s, undefined, i + 1),
-            $.sliceString(s, i + 1, undefined),
-          ]
-        } else {
-          ;[line, s] = [s, '']
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
+    const walk = (): void | globalThis.Promise<void> => {
+      for (; $.len(s) > 0; ) {
+        let line: string
+        {
+          let i = IndexByte(s, 10)
+          if (i >= 0) {
+            ;[line, s] = [
+              $.sliceString(s, undefined, i + 1),
+              $.sliceString(s, i + 1, undefined),
+            ]
+          } else {
+            ;[line, s] = [s, '']
+          }
+        }
+        const keepGoing = _yield!(line)
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              return walk()
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
         }
-      }
-      if (!_yield!(line)) {
-        return
       }
     }
-    return
+    return walk()
   }
 }
 
 // explodeSeq returns an iterator over the runes in s.
 export function explodeSeq(s: string): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
-    for (; $.len(s) > 0; ) {
-      let [, size] = utf8.DecodeRuneInString(s)
-      if (!_yield!($.sliceString(s, undefined, size))) {
-        return
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
+    const walk = (): void | globalThis.Promise<void> => {
+      for (; $.len(s) > 0; ) {
+        let [, size] = utf8.DecodeRuneInString(s)
+        const keepGoing = _yield!($.sliceString(s, undefined, size))
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              s = $.sliceString(s, size, undefined)
+              return walk()
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
+        }
+        s = $.sliceString(s, size, undefined)
       }
-      s = $.sliceString(s, size, undefined)
     }
+    return walk()
   }
 }
 
@@ -68,19 +94,36 @@ export function splitSeq(
   if ($.len(sep) == 0) {
     return explodeSeq(s)
   }
-  return (_yield: ((p0: string) => boolean) | null): void => {
-    for (;;) {
-      let i = Index(s, sep)
-      if (i < 0) {
-        break
-      }
-      let frag = $.sliceString(s, undefined, i + sepSave)
-      if (!_yield!(frag)) {
-        return
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
+    const walk = (): void | globalThis.Promise<void> => {
+      for (;;) {
+        let i = Index(s, sep)
+        if (i < 0) {
+          const keepGoing = _yield!(s)
+          if (keepGoing instanceof Promise) {
+            return keepGoing.then(() => {})
+          }
+          return
+        }
+        let frag = $.sliceString(s, undefined, i + sepSave)
+        const keepGoing = _yield!(frag)
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              s = $.sliceString(s, i + $.len(sep), undefined)
+              return walk()
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
+        }
+        s = $.sliceString(s, i + $.len(sep), undefined)
       }
-      s = $.sliceString(s, i + $.len(sep), undefined)
     }
-    _yield!(s)
+    return walk()
   }
 }
 
@@ -105,31 +148,47 @@ export function SplitAfterSeq(s: string, sep: string): iter.Seq<string> {
 // The iterator yields the same strings that would be returned by [Fields](s),
 // but without constructing the slice.
 export function FieldsSeq(s: string): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
     let start = -1
-    for (let i = 0; i < $.len(s); ) {
-      let size = 1
-      let r = $.indexString(s, i) as number
-      let isSpace = asciiSpace[$.indexString(s, i)] === true
-      if (r >= utf8.RuneSelf) {
-        ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
-        isSpace = unicode.IsSpace(r)
-      }
-      if (isSpace) {
-        if (start >= 0) {
-          if (!_yield!($.sliceString(s, start, i))) {
-            return
+    const walk = (i: number): void | globalThis.Promise<void> => {
+      for (; i < $.len(s); ) {
+        let size = 1
+        let r = $.indexString(s, i) as number
+        let isSpace = asciiSpace[$.indexString(s, i)] === true
+        if (r >= utf8.RuneSelf) {
+          ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
+          isSpace = unicode.IsSpace(r)
+        }
+        if (isSpace) {
+          if (start >= 0) {
+            const keepGoing = _yield!($.sliceString(s, start, i))
+            start = -1
+            if (keepGoing instanceof Promise) {
+              return keepGoing.then((next) => {
+                if (next) {
+                  return walk(i + size)
+                }
+              })
+            }
+            if (!keepGoing) {
+              return
+            }
           }
-          start = -1
+        } else if (start < 0) {
+          start = i
+        }
+        i += size
+      }
+      if (start >= 0) {
+        const keepGoing = _yield!($.sliceString(s, start, undefined))
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then(() => {})
         }
-      } else if (start < 0) {
-        start = i
       }
-      i += size
-    }
-    if (start >= 0) {
-      _yield!($.sliceString(s, start, undefined))
     }
+    return walk(0)
   }
 }
 
@@ -141,31 +200,47 @@ export function FieldsFuncSeq(
   s: string,
   f: ((p0: number) => boolean) | null,
 ): iter.Seq<string> {
-  return (_yield: ((p0: string) => boolean) | null): void => {
+  return (
+    _yield: ((p0: string) => iter.YieldResult) | null,
+  ): void | globalThis.Promise<void> => {
     if (f === null) {
       return
     }
     let start = -1
-    for (let i = 0; i < $.len(s); ) {
-      let size = 1
-      let r = $.indexString(s, i) as number
-      if (r >= utf8.RuneSelf) {
-        ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
-      }
-      if (f(r)) {
-        if (start >= 0) {
-          if (!_yield!($.sliceString(s, start, i))) {
-            return
+    const walk = (i: number): void | globalThis.Promise<void> => {
+      for (; i < $.len(s); ) {
+        let size = 1
+        let r = $.indexString(s, i) as number
+        if (r >= utf8.RuneSelf) {
+          ;[r, size] = utf8.DecodeRuneInString($.sliceString(s, i, undefined))
+        }
+        if (f(r)) {
+          if (start >= 0) {
+            const keepGoing = _yield!($.sliceString(s, start, i))
+            start = -1
+            if (keepGoing instanceof Promise) {
+              return keepGoing.then((next) => {
+                if (next) {
+                  return walk(i + size)
+                }
+              })
+            }
+            if (!keepGoing) {
+              return
+            }
           }
-          start = -1
+        } else if (start < 0) {
+          start = i
+        }
+        i += size
+      }
+      if (start >= 0) {
+        const keepGoing = _yield!($.sliceString(s, start, undefined))
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then(() => {})
         }
-      } else if (start < 0) {
-        start = i
       }
-      i += size
-    }
-    if (start >= 0) {
-      _yield!($.sliceString(s, start, undefined))
     }
+    return walk(0)
   }
 }

package/gs/strings/replace.test.ts

@@ -124,10 +124,7 @@ describe('strings/Replacer', () => {
     it('should handle unicode strings', () => {
       const r = NewReplacer('世界', '世界!')
       if (r) {
-        // This test expects an error due to UTF-8 slicing limitations in JavaScript
-        expect(() => r.Replace('Hello 世界')).toThrow(
-          'Cannot slice string at byte indices',
-        )
+        expect(r.Replace('Hello 世界')).toBe('Hello 世界!')
       }
     })