Get Started

01
use asupersync::main;02 03#[main]04
async 
fn main() {05    println!("hello from asupersync");06}

01
use asupersync::{main, prelude::*};02 03#[main]04
async 
fn main(cx: &Cx) {05    
let service = Budget::new().with_poll_quota(64);06    
let request = Budget::new().with_poll_quota(16);07    
let effective = service.meet(request);08    assert_eq!(effective.remaining_polls(), 16);09 10    cx.checkpoint()11        .expect("budget and cancellation permit work");12    
let outcome: Outcome<u32, Error> = Outcome::ok(42);13    assert_eq!(outcome.expect("work succeeds"), 42);14}

01
use asupersync::{main, prelude::*};02 03#[main]04
async 
fn main(cx: &Cx) {05    
let scope = cx.scope_with_budget(Budget::new().with_poll_quota(64));06    
let 
mut tasks = JoinSet::new(&scope);07 08    
for value 
in 1..=3_u32 {09        tasks10            .spawn(cx, 
move |_| 
async 
move { Ok::<_, Error>(value) })11            .expect("spawn region-owned task");12    }13 14    
let sum = tasks15        .join_all(cx)16        .
await17        .into_iter()18        .map(|outcome| outcome.expect("child succeeds"))19        .sum::<u32>();20    assert_eq!(sum, 6);21}

01
use asupersync::{LabConfig, LabRuntime, main, prelude::*};02 03#[main]04
async 
fn main(cx: &Cx) {05    
let (tx, 
mut rx) = mpsc::channel::<u8>(1);06    
let permit = tx.reserve(cx).
await.expect("reserve channel capacity");07    permit.send(7);08    assert_eq!(rx.recv(cx).
await.expect("receive committed value"), 7);09 10    // The same reservation inside a deterministic lab task, except that this11    // permit escapes without `send` or `abort`. Stock permits are runtime12    // obligations, so the lab's obligation-leak oracle catches it by kind13    // without any hand-built obligation record.14    
let 
mut lab = LabRuntime::new(LabConfig::new(7).panic_on_leak(false));15    
let region = lab.state.create_root_region(Budget::INFINITE);16    
let (task, _handle) = lab17        .state18        .create_task(region, Budget::INFINITE, 
async {19            
let cx = Cx::current().expect("lab task installs a current Cx");20            
let (tx, _rx) = mpsc::channel::<u8>(1);21            
let permit = tx.reserve(&cx).
await.expect("reserve channel capacity");22            std::mem::forget(permit); // deliberate on-ramp leak23        })24        .expect("create lab task");25    lab.scheduler.lock().schedule(task, 0);26    lab.run_until_quiescent();27 28    
let report = lab.report();29    
let leak = report30        .oracle_report31        .entry("obligation_leak")32        .expect("obligation leak oracle is registered");33    assert!(!leak.passed, "the lab must catch the deliberate leak");34    
let violation = leak.violation.as_deref().unwrap_or_default();35    assert!(36        violation.contains("SendPermit"),37        "the oracle names the leaked permit kind: {violation}"38    );39}