goscript 0.1.1 → 0.1.3

package/gs/sync/sync.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { Map, WaitGroup } from './sync.js'
+import { Cond, Map, Mutex, RWMutex, WaitGroup } from './sync.js'
 
 describe('sync.WaitGroup', () => {
   it('Go tracks scheduled work and unblocks Wait after completion', async () => {
@@ -23,7 +23,49 @@ describe('sync.WaitGroup', () => {
   })
 })
 
+describe('sync.Cond', () => {
+  it('exposes the Locker as public field L', async () => {
+    const mutex = new Mutex()
+    const cond = new Cond(mutex)
+
+    expect(cond.L).toBe(mutex)
+    await cond.L.Lock()
+    cond.L.Unlock()
+  })
+})
+
+describe('sync.RWMutex', () => {
+  it('exposes RLocker as a read-lock Locker', async () => {
+    const rw = new RWMutex()
+    const locker = rw.RLocker()
+
+    await locker.Lock()
+    locker.Unlock()
+  })
+})
+
 describe('sync.Map', () => {
+  it('Clear deletes all entries', async () => {
+    const m = new Map()
+
+    await m.Store('first', 1)
+    await m.Store('second', 2)
+    await m.Clear()
+
+    expect(await m.Load('first')).toEqual([undefined, false])
+    expect(await m.Load('second')).toEqual([undefined, false])
+  })
+
+  it('CompareAndSwap swaps only matching entries', async () => {
+    const m = new Map()
+
+    await m.Store('key', 'value')
+    expect(await m.CompareAndSwap('key', 'other', 'next')).toBe(false)
+    expect(await m.Load('key')).toEqual(['value', true])
+    expect(await m.CompareAndSwap('key', 'value', 'next')).toBe(true)
+    expect(await m.Load('key')).toEqual(['next', true])
+  })
+
   it('CompareAndDelete deletes only matching entries', async () => {
     const m = new Map()
 
@@ -33,4 +75,18 @@ describe('sync.Map', () => {
     expect(await m.CompareAndDelete('key', 'value')).toBe(true)
     expect(await m.Load('key')).toEqual([undefined, false])
   })
+
+  it('Range accepts generated async-shaped callbacks', async () => {
+    const m = new Map()
+    const visited: string[] = []
+
+    await m.Store('a', 1)
+    await m.Store('b', 2)
+    await m.Range(async (key, value) => {
+      visited.push(`${key}:${value}`)
+      return key !== 'a'
+    })
+
+    expect(visited).toEqual(['a:1'])
+  })
 })

package/gs/sync/sync.ts

@@ -143,6 +143,15 @@ export class RWMutex {
     }
   }
 
+  // RLocker returns a Locker interface that implements Lock and Unlock by
+  // calling RLock and RUnlock.
+  public RLocker(): Locker {
+    return {
+      Lock: () => this.RLock(),
+      Unlock: () => this.RUnlock(),
+    }
+  }
+
   private _wakeUpWaiters(): void {
     // Prioritize writers
     if (this._writerWaitQueue.length > 0 && this._readers === 0) {
@@ -232,7 +241,7 @@ export class Once {
   }
 
   // Do calls the function f if and only if Do is being called for the first time for this instance of Once
-  public async Do(f: () => void): Promise<void> {
+  public async Do(f: () => void | Promise<void>): Promise<void> {
     if (this._done) {
       return
     }
@@ -240,7 +249,7 @@ export class Once {
     await this._m.Lock()
     try {
       if (!this._done) {
-        f()
+        await f()
         this._done = true
       }
     } finally {
@@ -256,11 +265,11 @@ export class Once {
 
 // Cond implements a condition variable, a rendezvous point for goroutines waiting for or announcing the occurrence of an event
 export class Cond {
-  private _l: Locker
+  public L: Locker
   private _waiters: Array<() => void> = []
 
   constructor(l: Locker) {
-    this._l = l
+    this.L = l
   }
 
   // Broadcast wakes all goroutines waiting on c
@@ -281,11 +290,11 @@ export class Cond {
 
   // Wait atomically unlocks c.L and suspends execution of the calling goroutine
   public async Wait(): Promise<void> {
-    this._l.Unlock()
+    this.L.Unlock()
 
     return new Promise<void>((resolve) => {
       this._waiters.push(async () => {
-        await this._l.Lock()
+        await this.L.Lock()
         resolve()
       })
     })
@@ -293,7 +302,7 @@ export class Cond {
 
   // clone returns a copy of this Cond instance
   public clone(): Cond {
-    return new Cond(this._l)
+    return new Cond(this.L)
   }
 }
 
@@ -311,6 +320,16 @@ export class Map {
     // Map has no public fields to initialize
   }
 
+  // Clear deletes all entries.
+  public async Clear(): Promise<void> {
+    await this._m.Lock()
+    try {
+      this._data.clear()
+    } finally {
+      this._m.Unlock()
+    }
+  }
+
   // Delete deletes the value for a key
   public async Delete(key: any): Promise<void> {
     await this._m.Lock()
@@ -335,6 +354,15 @@ export class Map {
     }
   }
 
+  // CompareAndSwap swaps the old and new values for key if the stored value is old.
+  public CompareAndSwap(key: any, old: any, value: any): boolean {
+    if (!this._data.has(key) || this._data.get(key) !== old) {
+      return false
+    }
+    this._data.set(key, value)
+    return true
+  }
+
   // Load returns the value stored in the map for a key, or nil if no value is present
   public async Load(key: any): Promise<[any, boolean]> {
     await this._m.RLock()
@@ -374,17 +402,21 @@ export class Map {
   }
 
   // Range calls f sequentially for each key and value present in the map
-  public async Range(f: (key: any, value: any) => boolean): Promise<void> {
+  public async Range(
+    f: (key: any, value: any) => boolean | globalThis.Promise<boolean>,
+  ): Promise<void> {
     await this._m.RLock()
+    let entries: [any, any][]
     try {
-      for (const [key, value] of this._data) {
-        if (!f(key, value)) {
-          break
-        }
-      }
+      entries = Array.from(this._data)
     } finally {
       this._m.RUnlock()
     }
+    for (const [key, value] of entries) {
+      if (!(await f(key, value))) {
+        break
+      }
+    }
   }
 
   // Store sets the value for a key