Index

Modules: sync, sync/barrier, sync/channels, sync/latch, sync/once, sync/rwlock, sync/semaphore, sync/smartptrs.

API symbols

`$`:

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

`=copy`:

• barrier: proc `=copy`(dest: var Barrier; src: Barrier)
• channels: proc `=copy`[T](dest: var Chan[T]; src: Chan[T])
• latch: proc `=copy`(dest: var Latch; source: Latch)
• 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`:

• barrier: proc `=dup`(source: Barrier): Barrier
• channels: proc `=dup`[T](src: Chan[T]): Chan[T]
• latch: proc `=dup`(source: Latch): Latch
• once: proc `=dup`(source: Once): Once
• rwlock: proc `=dup`(source: RwLock): RwLock
• semaphore: proc `=dup`(source: Semaphore): Semaphore
• smartptrs: proc `=dup`[T](src: SharedPtr[T]): SharedPtr[T]
• smartptrs: proc `=dup`[T](src: UniquePtr[T]): UniquePtr[T]

`=sink`:

• barrier: proc `=sink`(dest: var Barrier; src: Barrier)
• latch: proc `=sink`(dest: var Latch; source: Latch)
• 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

Barrier:

• barrier: object Barrier

beginRead:

• rwlock: proc beginRead(rw: var RwLock)

beginWrite:

• rwlock: proc beginWrite(rw: var RwLock)

Chan:

• channels: object Chan

ConstPtr:

• smartptrs: type ConstPtr

dec:

• latch: proc dec(x: var Latch)

endRead:

• rwlock: proc endRead(rw: var RwLock)

endWrite:

• rwlock: proc endWrite(rw: var RwLock)

initBarrier:

• barrier: proc initBarrier(b: out Barrier; parties: Natural)

initLatch:

• latch: proc initLatch(x: out Latch; count: Natural)

initOnce:

• once: proc initOnce(o: out Once)

initRwLock:

• rwlock: proc initRwLock(rw: out RwLock)

initSem:

• semaphore: proc initSem(s: out Semaphore; count: Natural = 0)

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

Latch:

• latch: object Latch

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)

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)

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)
• latch: proc wait(x: var Latch)
• semaphore: proc wait(s: var Semaphore)

writeWith:

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