Index

Modules: atomics, barrier, channels, once, rwlock, semaphore, smartptrs, waitgroups.

API symbols

`$`:

• smartptrs: proc `$`[T](p: ConstPtr[T]): string
• smartptrs: proc `$`[T](p: SharedPtr[T]): string
• smartptrs: proc `$`[T](p: UniquePtr[T]): string

`+=`:

• atomics: proc `+=`[T: SomeInteger](location: var Atomic[T]; value: T)

`-=`:

• atomics: proc `-=`[T: SomeInteger](location: var Atomic[T]; value: T)

`=copy`:

• atomics: proc `=copy`[T](dst: var Atomic[T]; src: Atomic[T])
• barrier: proc `=copy`(dest: var Barrier; src: Barrier)
• channels: proc `=copy`[T](dest: var Chan[T]; src: Chan[T])
• once: proc `=copy`(dest: var Once; source: Once)
• rwlock: proc `=copy`(dest: var RwLock; source: RwLock)
• semaphore: proc `=copy`(dest: var Semaphore; src: Semaphore)
• smartptrs: proc `=copy`[T](dest: var SharedPtr[T]; src: SharedPtr[T])
• smartptrs: proc `=copy`[T](dest: var UniquePtr[T]; src: UniquePtr[T])

`=destroy`:

• barrier: proc `=destroy`(b: Barrier)
• channels: proc `=destroy`[T](c: Chan[T])
• once: proc `=destroy`(o: Once)
• rwlock: proc `=destroy`(rw: RwLock)
• semaphore: proc `=destroy`(s: Semaphore)
• smartptrs: proc `=destroy`[T](p: SharedPtr[T])
• smartptrs: proc `=destroy`[T](p: UniquePtr[T])

`=dup`:

• channels: proc `=dup`[T](src: Chan[T]): Chan[T]
• smartptrs: proc `=dup`[T](src: SharedPtr[T]): SharedPtr[T]
• smartptrs: proc `=dup`[T](src: UniquePtr[T]): UniquePtr[T]

`=sink`:

• atomics: proc `=sink`[T](dst: var Atomic[T]; src: Atomic[T])
• barrier: proc `=sink`(dest: var Barrier; src: Barrier)
• once: proc `=sink`(dest: var Once; source: Once)
• rwlock: proc `=sink`(dest: var RwLock; source: RwLock)
• semaphore: proc `=sink`(dest: var Semaphore; src: Semaphore)

`=wasMoved`:

• channels: proc `=wasMoved`[T](x: var Chan[T])
• smartptrs: proc `=wasMoved`[T](p: var SharedPtr[T])

`[]=`:

• smartptrs: proc `[]=`[T](p: ConstPtr[T]; v: T)
• smartptrs: proc `[]=`[T](p: SharedPtr[T]; val: sink Isolated[T])
• smartptrs: proc `[]=`[T](p: UniquePtr[T]; val: sink Isolated[T])
• smartptrs: template `[]=`[T](p: SharedPtr[T]; val: T)
• smartptrs: template `[]=`[T](p: UniquePtr[T]; val: T)

`[]`:

• smartptrs: proc `[]`[T](p: ConstPtr[T]): lent T
• smartptrs: proc `[]`[T](p: SharedPtr[T]): var T
• smartptrs: proc `[]`[T](p: UniquePtr[T]): var T

Atomic:

• atomics: type Atomic

atomicDec:

• atomics: proc atomicDec[T: SomeInteger](location: var Atomic[T]; value: T = 1)

atomicInc:

• atomics: proc atomicInc[T: SomeInteger](location: var Atomic[T]; value: T = 1)

Barrier:

• barrier: object Barrier

beginRead:

• rwlock: proc beginRead(rw: var RwLock)

beginWrite:

• rwlock: proc beginWrite(rw: var RwLock)

Chan:

• channels: object Chan

compareExchange:

• atomics: proc compareExchange[T](location: var Atomic[T]; expected: var T; desired: T; order: Ordering = SeqCst): bool
• atomics: proc compareExchange[T](location: var Atomic[T]; expected: var T; desired: T; success, failure: Ordering): bool

compareExchangeWeak:

• atomics: proc compareExchangeWeak[T](location: var Atomic[T]; expected: var T; desired: T; order: Ordering = SeqCst): bool
• atomics: proc compareExchangeWeak[T](location: var Atomic[T]; expected: var T; desired: T; success, failure: Ordering): bool

ConstPtr:

• smartptrs: type ConstPtr

createBarrier:

• barrier: proc createBarrier(parties: Natural): Barrier

createOnce:

• once: proc createOnce(): Once

createRwLock:

• rwlock: proc createRwLock(): RwLock

createSemaphore:

• semaphore: proc createSemaphore(count: Natural = 0): Semaphore

createWaitGroup:

• waitgroups: proc createWaitGroup(): WaitGroup

endRead:

• rwlock: proc endRead(rw: var RwLock)

endWrite:

• rwlock: proc endWrite(rw: var RwLock)

enter:

• waitgroups: proc enter(b: var WaitGroup; delta: Natural = 1)

exchange:

• atomics: proc exchange[T](location: var Atomic[T]; desired: T; order: Ordering = SeqCst): T

fetchAdd:

• atomics: proc fetchAdd[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchAnd:

• atomics: proc fetchAnd[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchOr:

• atomics: proc fetchOr[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchSub:

• atomics: proc fetchSub[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

fetchXor:

• atomics: proc fetchXor[T: SomeInteger](location: var Atomic[T]; value: T; order: Ordering = SeqCst): T

isNil:

• smartptrs: proc isNil[T](p: ConstPtr[T]): bool
• smartptrs: proc isNil[T](p: SharedPtr[T]): bool
• smartptrs: proc isNil[T](p: UniquePtr[T]): bool

leave:

• waitgroups: proc leave(b: var WaitGroup)

load:

• atomics: proc load[T](location: var Atomic[T]; order: Ordering = SeqCst): T

newChan:

• channels: proc newChan[T](elements: Positive = 30): Chan[T]

newConstPtr:

• smartptrs: proc newConstPtr[T](val: sink Isolated[T]): ConstPtr[T]
• smartptrs: template newConstPtr[T](val: T): ConstPtr[T]

newSharedPtr:

• smartptrs: proc newSharedPtr[T](val: sink Isolated[T]): SharedPtr[T]
• smartptrs: proc newSharedPtr[T](t: typedesc[T]): SharedPtr[T]
• smartptrs: template newSharedPtr[T](val: T): SharedPtr[T]

newUniquePtr:

• smartptrs: proc newUniquePtr[T](val: sink Isolated[T]): UniquePtr[T]
• smartptrs: proc newUniquePtr[T](t: typedesc[T]): UniquePtr[T]
• smartptrs: template newUniquePtr[T](val: T): UniquePtr[T]

Once:

• once: object Once

once:

• once: template once(o: Once; body: untyped)

Ordering:

• atomics: enum Ordering

peek:

• channels: proc peek[T](c: Chan[T]): int

readWith:

• rwlock: template readWith(a: RwLock; body: untyped)

recv:

• channels: proc recv[T](c: Chan[T]): T
• channels: proc recv[T](c: Chan[T]; dst: var T)

recvIso:

• channels: proc recvIso[T](c: Chan[T]): Isolated[T]

RwLock:

• rwlock: object RwLock

Semaphore:

• semaphore: object Semaphore

send:

• channels: proc send[T](c: Chan[T]; src: sink Isolated[T])
• channels: template send[T](c: Chan[T]; src: T)

SharedPtr:

• smartptrs: object SharedPtr

signal:

• semaphore: proc signal(s: var Semaphore)

store:

• atomics: proc store[T](location: var Atomic[T]; desired: T; order: Ordering = SeqCst)

tryRecv:

• channels: proc tryRecv[T](c: Chan[T]; dst: var T): bool

trySend:

• channels: proc trySend[T](c: Chan[T]; src: sink Isolated[T]): bool
• channels: template trySend[T](c: Chan[T]; src: T): bool

tryTake:

• channels: proc tryTake[T](c: Chan[T]; src: var Isolated[T]): bool

UniquePtr:

• smartptrs: object UniquePtr

wait:

• barrier: proc wait(b: var Barrier)
• semaphore: proc wait(s: var Semaphore)
• waitgroups: proc wait(b: var WaitGroup)

WaitGroup:

• waitgroups: object WaitGroup

writeWith:

• rwlock: template writeWith(a: RwLock; body: untyped)