🥮 mooncakes.io
README

mokomoking2501/lockwire/scenario does not have a README file

#
Timeout

source
type Timeout = Event[Unit]

#
AnyResult

source
pub(all) struct AnyResult[T] {
  winner_id : Int
  winner_index : Int
  value : T
  pending_ids : Array[Int]
} derive(Eq, 
Debug)

#
CancelReason

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

#
Event

source
pub struct Event[T] {
  // private fields
}

#
Event::cause_id

source
fn[T] Event::cause_id(self : Event[T]) -> Int

#
Event::id

source
fn[T] Event::id(self : Event[T]) -> Int

#
Event::is_pending

source
fn[T] Event::is_pending(self : Event[T]) -> Bool

#
Event::state

source
fn[T] Event::state(self : Event[T]) -> EventState

#
Event::value

source
fn[T] Event::value(self : Event[T]) -> T?

#
EventCell

source
type EventCell[T]

#
EventState

source
pub(all) enum EventState {
  Pending
  Scheduled(
VTime)
  Processed
  Cancelled(CancelReason)
  Failed(String)
} derive(Eq, 
Debug)

#
ProcessHandle

source
pub struct ProcessHandle[T] {
  // private fields
}

#
ProcessHandle::event

source
fn[T] ProcessHandle::event(self : ProcessHandle[T]) -> Event[T]

#
ProcessHandle::name

source
fn[T] ProcessHandle::name(self : ProcessHandle[T]) -> String

#
ScheduledAction

source
type ScheduledAction

#
SimEnv

source
pub struct SimEnv {
  // private fields
}

#
SimEnv::checkpoint

source

#
SimEnv::new

source
fn SimEnv::new(seed~ : Int) -> SimEnv

#
SimEnv::now

source

#
SimEnv::peek

source

#
SimEnv::run

source
fn SimEnv::run(self : SimEnv) -> Unit

#
SimEnv::run_until_event

source
fn[T] SimEnv::run_until_event(self : SimEnv, ev : Event[T]) -> T

#
SimEnv::run_until_pred

source
fn SimEnv::run_until_pred(self : SimEnv, pred : () -> Bool) -> Unit

#
SimEnv::run_until_time

source
fn SimEnv::run_until_time(self : SimEnv, t : 
VTime) -> Unit

#
SimEnv::step

source
fn SimEnv::step(self : SimEnv) -> StepResult

#
StepResult

source
pub(all) enum StepResult {
  StepProcessed(event_id~ : Int, time~ : 
VTime)
  Idle
} derive(Eq, 
Debug)

#
all_of

source
fn[T] all_of(env : SimEnv, events : Array[Event[T]]) -> Event[Array[T]]

#
any_of

source
fn[T] any_of(env : SimEnv, events : Array[Event[T]]) -> Event[AnyResult[T]]

#
cancel

source
fn[T] cancel(ev : Event[T], reason : CancelReason) -> Unit

#
event

source
fn[T] event(env : SimEnv) -> Event[T]

#
fail

source
fn[T] fail(ev : Event[T], message : String) -> Unit

#
package_id

source
fn package_id() -> String

#
spawn

source
fn[T] spawn(env : SimEnv, name~ : String, f : (SimEnv) -> T) -> ProcessHandle[T]

#
succeed

source
fn[T] succeed(ev : Event[T], value : T) -> Unit

#
timeout

source

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io