Documentation
¶
Overview ¶
Package gointerop provides Go concurrency primitive wrappers.
Channels ¶
- make-channel, channel?
- channel-send!, channel-receive
- channel-try-send!, channel-try-receive
- channel-close!
Wait Groups ¶
- make-wait-group, wait-group?
- wait-group-add!, wait-group-done!
- wait-group-wait!
Read-Write Mutexes ¶
- make-rw-mutex, rw-mutex?
- rw-mutex-lock!, rw-mutex-unlock!
- rw-mutex-rlock!, rw-mutex-runlock!
Once ¶
- make-once, once?
- once-do!
Atomics ¶
- make-atomic, atomic?
- atomic-load, atomic-store!, atomic-swap!, atomic-cas!
- make-atomic-int64, atomic-int64?
- atomic-int64-load, atomic-int64-store!, atomic-int64-add!
Use Extension or AddToRegistry to register all primitives.
Package gointerop provides Go-specific concurrency primitives.
Index ¶
- Variables
- func PrimAtomicCompareAndSwap(mc machine.CallContext) error
- func PrimAtomicSwap(mc machine.CallContext) error
- func PrimChannelClose(mc machine.CallContext) error
- func PrimChannelReceive(mc machine.CallContext) error
- func PrimChannelSend(mc machine.CallContext) error
- func PrimChannelTryReceive(mc machine.CallContext) error
- func PrimChannelTrySend(mc machine.CallContext) error
- func PrimMakeAtomic(mc machine.CallContext) error
- func PrimMakeChannel(mc machine.CallContext) error
- func PrimMakeOnce(mc machine.CallContext) error
- func PrimMakeRWMutex(mc machine.CallContext) error
- func PrimMakeWaitGroup(mc machine.CallContext) error
- func PrimOnceDo(cc machine.CallContext) error
- func PrimWaitGroupAdd(mc machine.CallContext) error
Constants ¶
This section is empty.
Variables ¶
var AddToRegistry = Builder.AddToRegistry
AddToRegistry registers all Go interop primitives.
var Builder = registry.NewRegistryBuilder(addChannels, addWaitGroup, addRWMutex, addOnce, addAtomic)
Builder aggregates all Go interop registration functions.
var Extension = registry.NewDescribedExtension("gointerop", "Go interop: Go value wrapping, struct access, method calls.", AddToRegistry)
Extension is the Go interop extension.
var PrimAtomicLoad = helpers.MakeUnaryAccessor(werr.ErrNotAnAtomic, "atomic-load", func(a *values.AtomicBox) values.Value { return values.ValueOrVoid(a.Load()) })
PrimAtomicLoad atomically loads the value (atomic-load a) -> value
var PrimAtomicQ = helpers.MakeTypePredicate(func(o values.Value) bool { _, ok := o.(*values.AtomicBox) return ok })
PrimAtomicQ tests if an object is an AtomicBox (atomic? obj) -> boolean
var PrimAtomicStore = helpers.MakeBinarySetter(werr.ErrNotAnAtomic, "atomic-store!", func(a *values.AtomicBox, val values.Value) {
a.Store(val)
})
PrimAtomicStore atomically stores a value (atomic-store! a value) -> void
var PrimChannelCapacity = helpers.MakeUnaryAccessor(werr.ErrNotAChannel, "channel-capacity", func(ch *values.Channel) values.Value { return values.NewInteger(int64(ch.Cap())) })
PrimChannelCapacity returns the channel's buffer capacity (channel-capacity ch) -> integer
var PrimChannelClosedQ = helpers.MakeUnaryAccessor(werr.ErrNotAChannel, "channel-closed?", func(ch *values.Channel) values.Value { return values.BoolToBoolean(ch.IsClosed()) })
PrimChannelClosedQ tests if a channel is closed (channel-closed? ch) -> boolean
var PrimChannelLength = helpers.MakeUnaryAccessor(werr.ErrNotAChannel, "channel-length", func(ch *values.Channel) values.Value { return values.NewInteger(int64(ch.Len())) })
PrimChannelLength returns the number of elements in the channel buffer (channel-length ch) -> integer
var PrimChannelQ = helpers.MakeTypePredicate(func(o values.Value) bool { _, ok := o.(*values.Channel) return ok })
PrimChannelQ tests if an object is a channel (channel? obj) -> boolean
var PrimOnceDoneQ = helpers.MakeUnaryAccessor(werr.ErrNotAOnce, "once-done?", func(once *values.Once) values.Value { return values.BoolToBoolean(once.Done()) })
PrimOnceDoneQ tests if the Once has been executed (once-done? once) -> boolean
var PrimOnceQ = helpers.MakeTypePredicate(func(o values.Value) bool { _, ok := o.(*values.Once) return ok })
PrimOnceQ tests if an object is a Once (once? obj) -> boolean
var PrimRWMutexQ = helpers.MakeTypePredicate(func(o values.Value) bool { _, ok := o.(*values.RWMutex) return ok })
PrimRWMutexQ tests if an object is an RWMutex (rw-mutex? obj) -> boolean
var PrimRWMutexReadLock = helpers.MakeUnarySideEffect(werr.ErrNotARWMutex, "rw-mutex-read-lock!", func(rwm *values.RWMutex) {
rwm.RLock()
})
PrimRWMutexReadLock acquires the read lock (rw-mutex-read-lock! rwm) -> void
var PrimRWMutexReadUnlock = helpers.MakeUnarySideEffect(werr.ErrNotARWMutex, "rw-mutex-read-unlock!", func(rwm *values.RWMutex) {
rwm.RUnlock()
})
PrimRWMutexReadUnlock releases the read lock (rw-mutex-read-unlock! rwm) -> void
var PrimRWMutexTryReadLock = helpers.MakeUnaryAccessor(werr.ErrNotARWMutex, "rw-mutex-try-read-lock!", func(rwm *values.RWMutex) values.Value { return values.BoolToBoolean(rwm.TryRLock()) })
PrimRWMutexTryReadLock tries to acquire the read lock (rw-mutex-try-read-lock! rwm) -> boolean
var PrimRWMutexTryWriteLock = helpers.MakeUnaryAccessor(werr.ErrNotARWMutex, "rw-mutex-try-write-lock!", func(rwm *values.RWMutex) values.Value { return values.BoolToBoolean(rwm.TryLock()) })
PrimRWMutexTryWriteLock tries to acquire the write lock (rw-mutex-try-write-lock! rwm) -> boolean
var PrimRWMutexWriteLock = helpers.MakeUnarySideEffect(werr.ErrNotARWMutex, "rw-mutex-write-lock!", func(rwm *values.RWMutex) {
rwm.Lock()
})
PrimRWMutexWriteLock acquires the write lock (rw-mutex-write-lock! rwm) -> void
var PrimRWMutexWriteUnlock = helpers.MakeUnarySideEffect(werr.ErrNotARWMutex, "rw-mutex-write-unlock!", func(rwm *values.RWMutex) {
rwm.Unlock()
})
PrimRWMutexWriteUnlock releases the write lock (rw-mutex-write-unlock! rwm) -> void
var PrimWaitGroupDone = helpers.MakeUnarySideEffect(werr.ErrNotAWaitGroup, "wait-group-done!", func(wg *values.WaitGroup) {
wg.Done()
})
PrimWaitGroupDone decrements the WaitGroup counter (wait-group-done! wg) -> void
var PrimWaitGroupQ = helpers.MakeTypePredicate(func(o values.Value) bool { _, ok := o.(*values.WaitGroup) return ok })
PrimWaitGroupQ tests if an object is a WaitGroup (wait-group? obj) -> boolean
var PrimWaitGroupWait = helpers.MakeUnarySideEffect(werr.ErrNotAWaitGroup, "wait-group-wait!", func(wg *values.WaitGroup) {
wg.Wait()
})
PrimWaitGroupWait waits for the WaitGroup counter to reach zero (wait-group-wait! wg) -> void
Functions ¶
func PrimAtomicCompareAndSwap ¶
func PrimAtomicCompareAndSwap(mc machine.CallContext) error
PrimAtomicCompareAndSwap atomically compares and swaps (atomic-compare-and-swap! a old new) -> boolean
func PrimAtomicSwap ¶
func PrimAtomicSwap(mc machine.CallContext) error
PrimAtomicSwap atomically swaps and returns the old value (atomic-swap! a new) -> old
func PrimChannelClose ¶
func PrimChannelClose(mc machine.CallContext) error
PrimChannelClose closes the channel (channel-close! ch) -> void
func PrimChannelReceive ¶
func PrimChannelReceive(mc machine.CallContext) error
PrimChannelReceive receives a value from the channel (blocking) (channel-receive ch) -> value
func PrimChannelSend ¶
func PrimChannelSend(mc machine.CallContext) error
PrimChannelSend sends a value on the channel (blocking) (channel-send! ch value) -> void
func PrimChannelTryReceive ¶
func PrimChannelTryReceive(mc machine.CallContext) error
PrimChannelTryReceive attempts to receive without blocking (channel-try-receive ch) -> (values value received? open?)
func PrimChannelTrySend ¶
func PrimChannelTrySend(mc machine.CallContext) error
PrimChannelTrySend attempts to send without blocking (channel-try-send! ch value) -> boolean
func PrimMakeAtomic ¶
func PrimMakeAtomic(mc machine.CallContext) error
PrimMakeAtomic creates a new AtomicBox value (make-atomic initial) -> atomic
func PrimMakeChannel ¶
func PrimMakeChannel(mc machine.CallContext) error
PrimMakeChannel creates a new channel (make-channel [buffer-size]) -> channel
func PrimMakeOnce ¶
func PrimMakeOnce(mc machine.CallContext) error
PrimMakeOnce creates a new Once (make-once) -> once
func PrimMakeRWMutex ¶
func PrimMakeRWMutex(mc machine.CallContext) error
PrimMakeRWMutex creates a new RWMutex (make-rw-mutex [name]) -> rw-mutex
func PrimMakeWaitGroup ¶
func PrimMakeWaitGroup(mc machine.CallContext) error
PrimMakeWaitGroup creates a new WaitGroup (make-wait-group) -> wait-group
func PrimOnceDo ¶
func PrimOnceDo(cc machine.CallContext) error
PrimOnceDo executes the thunk only once (once-do! once thunk) -> boolean (true if executed, false if already done)
func PrimWaitGroupAdd ¶
func PrimWaitGroupAdd(mc machine.CallContext) error
PrimWaitGroupAdd adds to the WaitGroup counter (wait-group-add! wg n) -> void
Types ¶
This section is empty.
Source Files