Nanaloveyuki/sync/atomic does not have a README file

    SyncError

    AtomicBool

    type AtomicBool

    AtomicBool::compare_exchange

    fn AtomicBool::compare_exchange(self : AtomicBool, current : Bool, next : Bool, success? : MemoryOrdering, failure? : MemoryOrdering) -> CompareExchangeResult[Bool] raise
    SyncError

    AtomicBool::load

    AtomicBool::new

    fn AtomicBool::new(value : Bool) -> AtomicBool

    Creates an atomic boolean. Defaults on operations are SeqCst.

    AtomicBool::share

    fn AtomicBool::share(self : AtomicBool) -> AtomicBool

    Creates an independent wrapper for use by another OS thread.

    AtomicBool::store

    fn AtomicBool::store(self : AtomicBool, value : Bool, order? : MemoryOrdering) -> Unit raise
    SyncError

    AtomicBool::swap

    fn AtomicBool::swap(self : AtomicBool, value : Bool, order? : MemoryOrdering) -> Bool

    AtomicInt

    type AtomicInt

    AtomicInt::compare_exchange

    fn AtomicInt::compare_exchange(self : AtomicInt, current : Int, next : Int, success? : MemoryOrdering, failure? : MemoryOrdering) -> CompareExchangeResult[Int] raise
    SyncError

    AtomicInt::fetch_add

    fn AtomicInt::fetch_add(self : AtomicInt, delta : Int, order? : MemoryOrdering) -> Int

    AtomicInt::load

    AtomicInt::new

    fn AtomicInt::new(value : Int) -> AtomicInt

    Creates a 32-bit signed atomic integer.

    AtomicInt::share

    fn AtomicInt::share(self : AtomicInt) -> AtomicInt

    Creates an independent wrapper for use by another OS thread.

    AtomicInt::store

    fn AtomicInt::store(self : AtomicInt, value : Int, order? : MemoryOrdering) -> Unit raise
    SyncError

    AtomicInt::swap

    fn AtomicInt::swap(self : AtomicInt, value : Int, order? : MemoryOrdering) -> Int

    AtomicUInt

    type AtomicUInt

    AtomicUInt::compare_exchange

    fn AtomicUInt::compare_exchange(self : AtomicUInt, current : UInt, next : UInt, success? : MemoryOrdering, failure? : MemoryOrdering) -> CompareExchangeResult[UInt] raise
    SyncError

    AtomicUInt::fetch_add

    fn AtomicUInt::fetch_add(self : AtomicUInt, delta : UInt, order? : MemoryOrdering) -> UInt

    AtomicUInt::load

    AtomicUInt::new

    fn AtomicUInt::new(value : UInt) -> AtomicUInt

    Creates a 32-bit unsigned atomic integer.

    AtomicUInt::share

    fn AtomicUInt::share(self : AtomicUInt) -> AtomicUInt

    Creates an independent wrapper for use by another OS thread.

    AtomicUInt::store

    fn AtomicUInt::store(self : AtomicUInt, value : UInt, order? : MemoryOrdering) -> Unit raise
    SyncError

    AtomicUInt::swap

    fn AtomicUInt::swap(self : AtomicUInt, value : UInt, order? : MemoryOrdering) -> UInt

    CompareExchangeResult

    pub struct CompareExchangeResult[T] {
    observed : T
    exchanged : Bool
    } derive(Eq,
    Debug
    )

    MemoryOrdering

    pub(all) enum MemoryOrdering {
    Relaxed
    Acquire
    Release
    AcqRel
    SeqCst
    } derive(Eq,
    Debug
    )

    Memory ordering for atomic operations.

    Windows uses Interlocked operations and may strengthen every ordering to SeqCst. Linux implements the requested ordering with compiler atomics.

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io