goscript 0.1.1 → 0.1.3

package/gs/slices/slices.test.ts

@@ -3,10 +3,24 @@ import { describe, expect, it } from 'vitest'
 import * as $ from '@goscript/builtin/index.js'
 
 import {
+  All,
   Backward,
+  BinarySearch,
+  Clip,
+  Compact,
+  CompactFunc,
+  CompareFunc,
+  Concat,
+  DeleteFunc,
+  EqualFunc,
+  IndexFunc,
   IsSorted,
   IsSortedFunc,
   Max,
+  MaxFunc,
+  Min,
+  MinFunc,
+  Replace,
   Sorted,
   SortStableFunc,
 } from './slices.js'
@@ -26,6 +40,63 @@ describe('slices.SortStableFunc', () => {
   })
 })
 
+describe('slices compatibility helpers', () => {
+  it('implements comparison, min/max, compact, replace, clip, and search helpers', () => {
+    expect(
+      CompareFunc($.arrayToSlice(['a', 'c']), $.arrayToSlice(['a', 'b']), (a, b) =>
+        a.localeCompare(b),
+      ),
+    ).toBeGreaterThan(0)
+    expect(Min($.arrayToSlice([3, 1, 2]))).toBe(1)
+    expect(MaxFunc($.arrayToSlice([{ v: 1 }, { v: 4 }]), (a, b) => a.v - b.v).v).toBe(4)
+    expect(MinFunc($.arrayToSlice([{ v: 3 }, { v: 2 }]), (a, b) => a.v - b.v).v).toBe(2)
+    expect(Array.from(Compact($.arrayToSlice([1, 1, 2, 2, 3])) ?? [])).toEqual([1, 2, 3])
+    expect(
+      Array.from(
+        CompactFunc(
+          $.arrayToSlice(['a', 'A', 'b']),
+          (a, b) => a.toLowerCase() === b.toLowerCase(),
+        ) ?? [],
+      ),
+    ).toEqual(['a', 'b'])
+    expect(Array.from(Replace($.arrayToSlice([1, 2, 3, 4]), 1, 3, 9, 8)) ?? []).toEqual([
+      1, 9, 8, 4,
+    ])
+    expect(Array.from(Clip($.arrayToSlice([1, 2])) ?? [])).toEqual([1, 2])
+    expect(BinarySearch($.arrayToSlice([1, 3, 5]), 3)).toEqual([1, true])
+  })
+
+  it('concatenates slices and preserves empty concat nilness', () => {
+    expect(Concat()).toBeNull()
+    expect(Concat($.arrayToSlice<number>([]))).toBeNull()
+    expect(Array.from(Concat($.arrayToSlice([1]), null, $.arrayToSlice([2, 3])) ?? [])).toEqual([
+      1, 2, 3,
+    ])
+    expect(Array.from(Concat(new Uint8Array([1, 2]), new Uint8Array([3])) ?? [])).toEqual([
+      1, 2, 3,
+    ])
+  })
+
+  it('accepts generated possibly-async callback types for sync helpers', () => {
+    const compare: (a: number, b: number) => number | Promise<number> = (a, b) => a - b
+    const keepOdd: (v: number) => boolean | Promise<boolean> = (v) => v % 2 === 0
+    const equal: (a: string, b: string) => boolean | Promise<boolean> = (a, b) => a === b
+
+    expect(CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), compare)).toBeLessThan(0)
+    expect(Array.from(DeleteFunc($.arrayToSlice([1, 2, 3]), keepOdd) ?? [])).toEqual([1, 3])
+    expect(EqualFunc($.arrayToSlice(['a']), $.arrayToSlice(['a']), equal)).toBe(true)
+    expect(IndexFunc($.arrayToSlice([1, 2, 3]), keepOdd)).toBe(1)
+    expect(IsSortedFunc($.arrayToSlice([1, 2, 3]), compare)).toBe(true)
+    expect(BinarySearch($.arrayToSlice([1, 2, 3]), 2)).toEqual([1, true])
+  })
+
+  it('rejects actual async callback results in sync helpers', () => {
+    expect(() =>
+      CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), async (a, b) => a - b),
+    ).toThrow('slices: asynchronous callback result is not supported')
+  })
+})
+
 describe('slices.Sorted', () => {
   it('collects and sorts iterator values', () => {
     const values = Sorted<string>((yieldValue) => {
@@ -67,6 +138,21 @@ describe('slices.Backward', () => {
   })
 })
 
+describe('slices.All', () => {
+  it('accepts async yield callbacks', async () => {
+    const visited: Array<[number, string]> = []
+    await All($.arrayToSlice(['a', 'b', 'c']))(async (index, value) => {
+      visited.push([index, value])
+      return index < 1
+    })
+
+    expect(visited).toEqual([
+      [0, 'a'],
+      [1, 'b'],
+    ])
+  })
+})
+
 describe('slices.IsSorted', () => {
   it('reports ordered and unordered slices', () => {
     expect(IsSorted($.arrayToSlice([1, 2, 3]))).toBe(true)

package/gs/slices/slices.ts

@@ -3,6 +3,11 @@ import * as $ from '@goscript/builtin/index.js'
 import * as cmp from '../cmp/index.js'
 import * as iter from '../iter/index.js'
 
+type SyncCallbackResult<T> = T | globalThis.Promise<T>
+type CompareCallback<T, U = T> = ((v1: T, v2: U) => SyncCallbackResult<number>) | null
+type PredicateCallback<T> = ((value: T) => SyncCallbackResult<boolean>) | null
+type EqualCallback<T, U = T> = ((v1: T, v2: U) => SyncCallbackResult<boolean>) | null
+
 /**
  * Compare compares the elements of s1 and s2 using cmp.Compare.
  * The elements are compared sequentially, starting at index 0,
@@ -42,6 +47,34 @@ export function Compare<T extends string | number>(
   return 0
 }
 
+export function CompareFunc<T, U>(
+  s1: $.Slice<T>,
+  s2: $.Slice<U>,
+  compare: CompareCallback<T, U>,
+): number {
+  if (compare == null) {
+    throw new Error('slices.CompareFunc: nil comparison function')
+  }
+  const len1 = $.len(s1)
+  const len2 = $.len(s2)
+  const minLen = len1 < len2 ? len1 : len2
+  for (let i = 0; i < minLen; i++) {
+    const result = syncNumber(
+      compare((s1 as any)[i] as T, (s2 as any)[i] as U),
+    )
+    if (result !== 0) {
+      return result
+    }
+  }
+  if (len1 < len2) {
+    return -1
+  }
+  if (len1 > len2) {
+    return 1
+  }
+  return 0
+}
+
 /**
  * Clone returns a shallow copy of s while preserving nilness.
  * @param s The slice to clone
@@ -58,6 +91,38 @@ export function Clone<T>(s: $.Slice<T>): $.Slice<T> {
   return out
 }
 
+export function Concat<T>(...slices: $.Slice<T>[]): $.Slice<T> {
+  let size = 0
+  let byteSlice = false
+  for (const slice of slices) {
+    size += $.len(slice)
+    byteSlice = byteSlice || slice instanceof Uint8Array
+  }
+  if (size === 0) {
+    return null
+  }
+  if (byteSlice) {
+    const out = new Uint8Array(size)
+    let pos = 0
+    for (const slice of slices) {
+      const length = $.len(slice)
+      for (let i = 0; i < length; i++) {
+        out[pos++] = (slice as any)[i] as number
+      }
+    }
+    return out as $.Slice<T>
+  }
+  const out = $.makeSlice<T>(size)
+  let pos = 0
+  for (const slice of slices) {
+    const length = $.len(slice)
+    for (let i = 0; i < length; i++) {
+      ;(out as any)[pos++] = (slice as any)[i] as T
+    }
+  }
+  return out
+}
+
 /**
  * All returns an iterator over index-value pairs in the slice.
  * This is equivalent to Go's slices.All function.
@@ -66,22 +131,35 @@ export function Clone<T>(s: $.Slice<T>): $.Slice<T> {
  */
 export function All<T>(
   s: $.Slice<T>,
-): (yieldFunc: (index: number, value: T) => boolean) => void {
-  return function (_yield: (index: number, value: T) => boolean): void {
+): (yieldFunc: (index: number, value: T) => iter.YieldResult) => void | globalThis.Promise<void> {
+  return function (
+    _yield: (index: number, value: T) => iter.YieldResult,
+  ): void | globalThis.Promise<void> {
     const length = $.len(s)
-    for (let i = 0; i < length; i++) {
-      const value = (s as any)[i] as T // Use proper indexing to avoid type issues
-      if (!_yield(i, value)) {
-        break
+    const walk = (i: number): void | globalThis.Promise<void> => {
+      for (; i < length; i++) {
+        const value = (s as any)[i] as T // Use proper indexing to avoid type issues
+        const keepGoing = _yield(i, value)
+        if (keepGoing instanceof Promise) {
+          return keepGoing.then((next) => {
+            if (next) {
+              return walk(i + 1)
+            }
+          })
+        }
+        if (!keepGoing) {
+          return
+        }
       }
     }
+    return walk(0)
   }
 }
 
 export function Backward<T>(
   s: $.Slice<T>,
 ): (
-  _yield: (index: number, value: T) => boolean | globalThis.Promise<boolean>
+  _yield: (index: number, value: T) => boolean | globalThis.Promise<boolean>,
 ) => void | globalThis.Promise<void> {
   return function (
     _yield: (index: number, value: T) => boolean | globalThis.Promise<boolean>,
@@ -136,17 +214,73 @@ export function Max<T extends cmp.Ordered>(x: $.Slice<T>): T {
   return max
 }
 
+export function Min<T extends cmp.Ordered>(x: $.Slice<T>): T {
+  if ($.len(x) === 0) {
+    throw new Error('slices.Min: empty list')
+  }
+  let min = (x as any)[0] as T
+  for (let i = 1; i < $.len(x); i++) {
+    const value = (x as any)[i] as T
+    if (cmp.Compare(value, min) < 0) {
+      min = value
+    }
+  }
+  return min
+}
+
+export function MaxFunc<T>(
+  x: $.Slice<T>,
+  compare: CompareCallback<T>,
+): T {
+  if (compare == null) {
+    throw new Error('slices.MaxFunc: nil comparison function')
+  }
+  if ($.len(x) === 0) {
+    throw new Error('slices.MaxFunc: empty list')
+  }
+  let max = (x as any)[0] as T
+  for (let i = 1; i < $.len(x); i++) {
+    const value = (x as any)[i] as T
+    if (syncNumber(compare(max, value)) < 0) {
+      max = value
+    }
+  }
+  return max
+}
+
+export function MinFunc<T>(
+  x: $.Slice<T>,
+  compare: CompareCallback<T>,
+): T {
+  if (compare == null) {
+    throw new Error('slices.MinFunc: nil comparison function')
+  }
+  if ($.len(x) === 0) {
+    throw new Error('slices.MinFunc: empty list')
+  }
+  let min = (x as any)[0] as T
+  for (let i = 1; i < $.len(x); i++) {
+    const value = (x as any)[i] as T
+    if (syncNumber(compare(value, min)) < 0) {
+      min = value
+    }
+  }
+  return min
+}
+
 export function Collect<T>(seq: iter.Seq<T>): $.Slice<T> {
   const out: T[] = []
-  seq((value) => {
+  seq((value: T) => {
     out.push(value)
     return true
   })
   return out.length === 0 ? null : out
 }
 
-export function Sorted<T extends string | number>(seq: iter.Seq<T>): $.Slice<T> {
-  const out = Collect(seq)
+export function Sorted<T extends string | number>(
+  seq: iter.Seq<T>,
+): $.Slice<T> {
+  const out = Collect<T>(seq)
   Sort(out)
   return out
 }
@@ -185,15 +319,18 @@ export function Delete<T>(s: $.Slice<T>, i: number, j: number): $.Slice<T> {
 
 export function DeleteFunc<T>(
   s: $.Slice<T>,
-  del: (value: T) => boolean,
+  del: PredicateCallback<T>,
 ): $.Slice<T> {
+  if (del == null) {
+    throw new Error('slices.DeleteFunc: nil delete function')
+  }
   if (s === null || s === undefined) {
     return s
   }
   let w = 0
   for (let i = 0; i < s.length; i++) {
     const value = s[i] as T
-    if (!del(value)) {
+    if (!syncBoolean(del(value))) {
       ;(s as any)[w] = value
       w++
     }
@@ -204,6 +341,83 @@ export function DeleteFunc<T>(
   return $.goSlice(s, 0, w) as $.Slice<T>
 }
 
+export function Replace<T>(
+  s: $.Slice<T>,
+  i: number,
+  j: number,
+  ...v: T[]
+): $.Slice<T> {
+  const length = $.len(s)
+  if (i < 0 || j < i || j > length) {
+    throw new Error(
+      `slice bounds out of range [${i}:${j}] with length ${length}`,
+    )
+  }
+  const out = $.makeSlice<T>(length - (j - i) + v.length)
+  let pos = 0
+  for (let idx = 0; idx < i; idx++) {
+    ;(out as any)[pos++] = (s as any)[idx]
+  }
+  for (const value of v) {
+    ;(out as any)[pos++] = value
+  }
+  for (let idx = j; idx < length; idx++) {
+    ;(out as any)[pos++] = (s as any)[idx]
+  }
+  return out
+}
+
+export function Compact<T>(s: $.Slice<T>): $.Slice<T> {
+  if (s === null || s === undefined || $.len(s) < 2) {
+    return s
+  }
+  let w = 1
+  for (let i = 1; i < $.len(s); i++) {
+    if ((s as any)[i] !== (s as any)[i - 1]) {
+      ;(s as any)[w] = (s as any)[i]
+      w++
+    }
+  }
+  for (let i = w; i < $.len(s); i++) {
+    ;(s as any)[i] = clearValue(s)
+  }
+  return $.goSlice(s, 0, w) as $.Slice<T>
+}
+
+export function CompactFunc<T>(
+  s: $.Slice<T>,
+  eq: EqualCallback<T>,
+): $.Slice<T> {
+  if (eq == null) {
+    throw new Error('slices.CompactFunc: nil equality function')
+  }
+  if (s === null || s === undefined || $.len(s) < 2) {
+    return s
+  }
+  let w = 1
+  for (let i = 1; i < $.len(s); i++) {
+    if (!syncBoolean(eq((s as any)[i - 1] as T, (s as any)[i] as T))) {
+      ;(s as any)[w] = (s as any)[i]
+      w++
+    }
+  }
+  for (let i = w; i < $.len(s); i++) {
+    ;(s as any)[i] = clearValue(s)
+  }
+  return $.goSlice(s, 0, w) as $.Slice<T>
+}
+
+export function Clip<T>(s: $.Slice<T>): $.Slice<T> {
+  if (s == null) {
+    return null
+  }
+  const out = $.makeSlice<T>($.len(s), $.len(s))
+  for (let i = 0; i < $.len(s); i++) {
+    ;(out as any)[i] = (s as any)[i]
+  }
+  return out
+}
+
 export function Equal<T>(s1: $.Slice<T>, s2: $.Slice<T>): boolean {
   const len1 = $.len(s1)
   if (len1 !== $.len(s2)) {
@@ -220,14 +434,17 @@ export function Equal<T>(s1: $.Slice<T>, s2: $.Slice<T>): boolean {
 export function EqualFunc<T, U>(
   s1: $.Slice<T>,
   s2: $.Slice<U>,
-  eq: (v1: T, v2: U) => boolean,
+  eq: EqualCallback<T, U>,
 ): boolean {
+  if (eq == null) {
+    throw new Error('slices.EqualFunc: nil equality function')
+  }
   const len1 = $.len(s1)
   if (len1 !== $.len(s2)) {
     return false
   }
   for (let i = 0; i < len1; i++) {
-    if (!eq((s1 as any)[i] as T, (s2 as any)[i] as U)) {
+    if (!syncBoolean(eq((s1 as any)[i] as T, (s2 as any)[i] as U))) {
       return false
     }
   }
@@ -243,9 +460,12 @@ export function Index<T>(s: $.Slice<T>, v: T): number {
   return -1
 }
 
-export function IndexFunc<T>(s: $.Slice<T>, f: (v: T) => boolean): number {
+export function IndexFunc<T>(s: $.Slice<T>, f: PredicateCallback<T>): number {
+  if (f == null) {
+    throw new Error('slices.IndexFunc: nil predicate function')
+  }
   for (let i = 0; i < $.len(s); i++) {
-    if (f((s as any)[i] as T)) {
+    if (syncBoolean(f((s as any)[i] as T))) {
       return i
     }
   }
@@ -256,14 +476,16 @@ export function Contains<T>(s: $.Slice<T>, v: T): boolean {
   return Index(s, v) >= 0
 }
 
-export function ContainsFunc<T>(s: $.Slice<T>, f: (v: T) => boolean): boolean {
+export function ContainsFunc<T>(s: $.Slice<T>, f: PredicateCallback<T>): boolean {
   return IndexFunc(s, f) >= 0
 }
 
 export function Insert<T>(s: $.Slice<T>, i: number, ...v: T[]): $.Slice<T> {
   const length = $.len(s)
   if (i < 0 || i > length) {
-    throw new Error(`slice bounds out of range [${i}:${i}] with length ${length}`)
+    throw new Error(
+      `slice bounds out of range [${i}:${i}] with length ${length}`,
+    )
   }
   if (v.length === 0) {
     return s
@@ -333,20 +555,29 @@ export function Grow<T>(s: $.Slice<T>, n: number): $.Slice<T> {
  * @param s The slice to sort in place
  * @param cmp Comparison function
  */
-export function SortFunc<T>(s: $.Slice<T>, cmp: (a: T, b: T) => number): void {
+export function SortFunc<T>(
+  s: $.Slice<T>,
+  cmp: CompareCallback<T>,
+): void {
+  if (cmp == null) {
+    throw new Error('slices.SortFunc: nil comparison function')
+  }
   if (s === null || s === undefined) {
     return
   }
   const arr = s as any as T[]
-  arr.sort(cmp)
+  arr.sort((a, b) => syncNumber(cmp(a, b)))
 }
 
 export function IsSortedFunc<T>(
   x: $.Slice<T>,
-  cmp: (a: T, b: T) => number,
+  cmp: CompareCallback<T>,
 ): boolean {
+  if (cmp == null) {
+    throw new Error('slices.IsSortedFunc: nil comparison function')
+  }
   for (let i = $.len(x) - 1; i > 0; i--) {
-    if (cmp((x as any)[i] as T, (x as any)[i - 1] as T) < 0) {
+    if (syncNumber(cmp((x as any)[i] as T, (x as any)[i - 1] as T)) < 0) {
       return false
     }
   }
@@ -355,23 +586,15 @@ export function IsSortedFunc<T>(
 
 export function SortStableFunc<T>(
   s: $.Slice<T>,
-  cmp: (a: T, b: T) => number,
+  cmp: CompareCallback<T>,
 ): void {
+  if (cmp == null) {
+    throw new Error('slices.SortStableFunc: nil comparison function')
+  }
   if (s === null || s === undefined) {
     return
   }
-  const sorted = (s as any as T[])
-    .map((value, index) => ({ value, index }))
-    .sort((a, b) => {
-      const result = cmp(a.value, b.value)
-      if (result !== 0) {
-        return result
-      }
-      return a.index - b.index
-    })
-  for (let i = 0; i < sorted.length; i++) {
-    ;(s as any)[i] = sorted[i].value
-  }
+  ;(s as any as T[]).sort((a, b) => syncNumber(cmp(a, b)))
 }
 
 function clearValue<T>(s: $.Slice<T>): T | null {
@@ -409,14 +632,17 @@ function clearValue<T>(s: $.Slice<T>): T | null {
 export function BinarySearchFunc<E, T>(
   x: $.Slice<E>,
   target: T,
-  cmp: (a: E, b: T) => number,
+  cmp: CompareCallback<E, T>,
 ): [number, boolean] {
+  if (cmp == null) {
+    throw new Error('slices.BinarySearchFunc: nil comparison function')
+  }
   let left = 0
   let right = $.len(x)
 
   while (left < right) {
     const mid = Math.floor((left + right) / 2)
-    const result = cmp((x as any)[mid] as E, target)
+    const result = syncNumber(cmp((x as any)[mid] as E, target))
 
     if (result < 0) {
       left = mid + 1
@@ -429,3 +655,24 @@ export function BinarySearchFunc<E, T>(
 
   return [left, false]
 }
+
+function syncNumber(value: SyncCallbackResult<number>): number {
+  if (value instanceof Promise) {
+    throw new Error('slices: asynchronous callback result is not supported')
+  }
+  return value
+}
+
+function syncBoolean(value: SyncCallbackResult<boolean>): boolean {
+  if (value instanceof Promise) {
+    throw new Error('slices: asynchronous callback result is not supported')
+  }
+  return value
+}
+
+export function BinarySearch<T extends cmp.Ordered>(
+  x: $.Slice<T>,
+  target: T,
+): [number, boolean] {
+  return BinarySearchFunc(x, target, cmp.Compare)
+}

package/gs/sort/slice.gs.ts

@@ -8,47 +8,98 @@ 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 async function Slice(
   x: $.Slice<any>,
-  less: (i: number, j: number) => boolean | globalThis.Promise<boolean>
+  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 && await 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 async function SliceIsSorted(
   x: $.Slice<any>,
-  less: (i: number, j: number) => boolean | globalThis.Promise<boolean>
+  less: LessFunc,
 ): globalThis.Promise<boolean> {
   if (!x) return true
-  
+
   const n = $.len(x)
   for (let i = n - 1; i > 0; i--) {
     if (await less(i, i - 1)) {
@@ -61,8 +112,7 @@ export async function SliceIsSorted(
 // SliceStable sorts the slice x while keeping the original order of equal elements
 export async function SliceStable(
   x: $.Slice<any>,
-  less: (i: number, j: number) => boolean | globalThis.Promise<boolean>
+  less: LessFunc,
 ): globalThis.Promise<void> {
-  // For simplicity, use the same sort - can be improved later
   await Slice(x, less)
 }