🥮 mooncakes.io

    mokomoking2501/lockwire/clock does not have a README file

    SimInstant

    source
    type SimInstant = Instant[SimTruth]

    CrossStamper

    source
    pub(open) trait CrossStamper {
      fn cross_stamp(Self) -> DomainCrossStamp
    }

    MonotonicClock

    source
    pub(open) trait MonotonicClock {
      fn now(Self) -> DomainInstant
      fn domain(Self) -> DomainId
      fn resolution(Self) -> 
    Duration
    }

    TimerDriver

    source
    pub(open) trait TimerDriver {
      fn sleep_until(Self, DomainInstant) -> Unit
    }

    ClockRelation

    source
    pub struct ClockRelation[A, B] {
      // private fields
    }

    ClockRelation::bound

    source

    ClockRelation::convert

    source
    fn[A, B] ClockRelation::convert(self : ClockRelation[A, B], instant : Instant[A]) -> Uncertain[Instant[B]]

    ClockRelation::new

    source
    fn[A, B] ClockRelation::new(source_domain~ : DomainId, target_domain~ : DomainId, offset~ : 
    Duration    , rate_ppb~ : Int64, bound~ : 
    Duration    , asof~ : Instant[A]) -> ClockRelation[A, B]

    ClockRelation::source_domain

    source
    fn[A, B] ClockRelation::source_domain(self : ClockRelation[A, B]) -> DomainId

    ClockRelation::target_domain

    source
    fn[A, B] ClockRelation::target_domain(self : ClockRelation[A, B]) -> DomainId

    CrossStamp

    source
    pub(all) struct CrossStamp[A, B] {
      source : Instant[A]
      target : Instant[B]
      bound : 
    Duration
    }

    DcDomain

    source
    pub(all) enum DcDomain {
      DcDomain
    } derive(Eq, 
    Debug    )

    DomainCrossStamp

    source
    pub(all) struct DomainCrossStamp {
      source : DomainInstant
      target : DomainInstant
      bound : 
    Duration
    } derive(Eq, 
    Debug    )

    DomainId

    source
    pub(all) enum DomainId {
      DomainId(String)
    } derive(Eq, 
    Debug    )

    DomainId::name

    source
    fn DomainId::name(self : DomainId) -> String

    DomainId::new

    source
    fn DomainId::new(name~ : String) -> DomainId

    DomainInstant

    source
    pub(all) struct DomainInstant {
      domain : DomainId
      ns : Int64
    } derive(Eq, 
    Debug    )

    DomainInstant::domain

    source
    fn DomainInstant::domain(self : DomainInstant) -> DomainId

    DomainInstant::from_typed

    source
    fn[D] DomainInstant::from_typed(instant : Instant[D]) -> DomainInstant

    DomainInstant::new

    source
    fn DomainInstant::new(domain~ : DomainId, ns~ : Int64) -> DomainInstant

    DomainInstant::ns

    source
    fn DomainInstant::ns(self : DomainInstant) -> Int64

    Instant

    source
    pub struct Instant[D] {
      // private fields
    }

    Instant::add

    source

    Instant::domain

    source
    fn[D] Instant::domain(self : Instant[D]) -> DomainId

    Instant::duration_since

    source
    fn[D] Instant::duration_since(self : Instant[D], earlier : Instant[D]) -> 
    Duration

    Instant::equals

    source
    fn[D] Instant::equals(self : Instant[D], other : Instant[D]) -> Bool

    Instant::new

    source
    fn[D] Instant::new(domain~ : DomainId, ns~ : Int64) -> Instant[D]

    Instant::ns

    source
    fn[D] Instant::ns(self : Instant[D]) -> Int64

    SimTruth

    source
    pub(all) enum SimTruth {
      SimTruth
    } derive(Eq, 
    Debug    )

    Uncertain

    source
    pub(all) struct Uncertain[T] {
      value : T
      bound : 
    Duration
    }

    VirtualClock

    source
    pub struct VirtualClock[D] {
      // private fields
    }

    VirtualClock::advance

    source

    VirtualClock::domain

    source
    fn[D] VirtualClock::domain(self : VirtualClock[D]) -> DomainId

    VirtualClock::new

    source
    fn[D] VirtualClock::new(domain~ : DomainId, seed~ : Int) -> VirtualClock[D]

    VirtualClock::now

    source
    fn[D] VirtualClock::now(self : VirtualClock[D]) -> Instant[D]

    VirtualClock::resolution

    source

    VirtualClock::seed

    source
    fn[D] VirtualClock::seed(self : VirtualClock[D]) -> Int

    VirtualClock::set

    source
    fn[D] VirtualClock::set(self : VirtualClock[D], instant : Instant[D]) -> Unit

    VirtualClock::sleep_until

    source
    fn[D] VirtualClock::sleep_until(self : VirtualClock[D], deadline : Instant[D]) -> Unit

    VirtualClock::sleep_until_domain

    source
    fn[D] VirtualClock::sleep_until_domain(self : VirtualClock[D], deadline : DomainInstant) -> Unit

    VirtualCrossStamper

    source
    pub struct VirtualCrossStamper[A, B] {
      // private fields
    }

    VirtualCrossStamper::new

    source
    fn[A, B] VirtualCrossStamper::new(source~ : VirtualClock[A], relation~ : ClockRelation[A, B]) -> VirtualCrossStamper[A, B]

    VirtualCrossStamper::typed_cross_stamp

    source
    fn[A, B] VirtualCrossStamper::typed_cross_stamp(self : VirtualCrossStamper[A, B]) -> CrossStamp[A, B]

    WallDomain

    source
    pub(all) enum WallDomain {
      WallDomain
    } derive(Eq, 
    Debug    )

    deterministic_sequence

    source
    fn[D] deterministic_sequence(domain~ : DomainId, seed~ : Int, count~ : Int, step~ : 
    Duration    ) -> Array[Instant[D]]

    ghost_domain_status

    source
    fn ghost_domain_status() -> String

    package_id

    source
    fn package_id() -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io