async function main() {
  const time = 100;
  const one = async () => {
    for (let i = 0; i < 10; i++) {
      console.log("promise one: ", i);
      await new Promise((r) => setTimeout(r, time));
    }
  };
  const two = async () => {
    for (;true; ) {
      console.log("promise two");
      await new Promise((r) => setTimeout(r, time * 2));
    }
  };
  return await Promise.race([one(), two()]);
}

// NOTE: even though race succeeds
// Deno won't exit until all
// tasks have exited
await main();

// so we exit manually
Deno.exit(0);
// Otherwise consider using AbortController
// and registering abort event on AbortSignal
// to cancel async tasks manually after race finishes

use futures_concurrency::prelude::*;

#[tokio::main]
pub async fn main() {
  let v: Vec<_> = vec!["chashu", "nori"]
  	   // provides combinators for streams and collections of futures
      .into_co_stream()
      .map(|msg| async move { format!("hello {msg}") })
      .collect()
      .await;

  assert_eq!(v, &["hello chashu", "hello nori"]);
}

use blocking::{unblock, Unblock};
use futures_lite::io;
use std::fs::File;

#[tokio::main]
pub async fn main() -> futures_lite::io::Result<()> {
    let input = unblock(|| File::open("file.txt")).await?;
    let input = Unblock::new(input);
    let mut output = Unblock::new(std::io::stdout());
    // async copy
    io::copy(input, &mut output).await.map(|_| {})
}

use shuttle::sync::{Arc, Mutex};
use shuttle::thread;

shuttle::check_random(|| {
    let lock = Arc::new(Mutex::new(0u64));
    let lock2 = lock.clone();

    thread::spawn(move || {
        *lock.lock().unwrap() = 1;
    });

    assert_eq!(0, *lock2.lock().unwrap());
}, 100);

/// A mutual exclusion primitive that relies on static type information only
///
/// In some cases synchronization can be proven statically:
/// whenever you hold an exclusive `&mut`
/// reference, the Rust type system ensures that no other
/// part of the program can hold another
/// reference to the data. Therefore it is safe to
/// access it even if the current thread obtained
/// this reference via a channel.
use sync_wrapper::SyncWrapper;
use std::future::Future;

struct MyThing {
    future: SyncWrapper<Box<dyn Future<Output = String> + Send>>,
}

impl MyThing {
    // all accesses to `self.future` now require an
    // exclusive reference or ownership
}

fn assert_sync<T: Sync>() {}
assert_sync::<MyThing>();

/// A echo example.
///
/// Run the example and `nc 127.0.0.1 50002` in another shell.
/// All your input will be echoed out.
use monoio::io::{AsyncReadRent, AsyncWriteRentExt};
use monoio::net::{TcpListener, TcpStream};

#[monoio::main]
async fn main() {
    let listener = TcpListener::bind("127.0.0.1:50002").unwrap();
    println!("listening");
    loop {
        let incoming = listener.accept().await;
        match incoming {
            Ok((stream, addr)) => {
                println!("accepted a connection from {}", addr);
                monoio::spawn(echo(stream));
            }
            Err(e) => {
                println!("accepted connection failed: {}", e);
                return;
            }
        }
    }
}

async fn echo(mut stream: TcpStream) -> std::io::Result<()> {
    let mut buf: Vec<u8> = Vec::with_capacity(8 * 1024);
    let mut res;
    loop {
        // read
        (res, buf) = stream.read(buf).await;
        if res? == 0 {
            return Ok(());
        }

        // write all
        (res, buf) = stream.write_all(buf).await;
        res?;

        // clear
        buf.clear();
    }
}

// required for old rust versions
#[macro_use]
extern crate may;

use may::net::TcpListener;
use std::io::{Read, Write};

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8000").unwrap();
    while let Ok((mut stream, _)) = listener.accept() {
        go!(move || {
            let mut buf = vec![0; 1024 * 16]; // alloc in heap!
            while let Ok(n) = stream.read(&mut buf) {
                if n == 0 {
                    break;
                }
                stream.write_all(&buf[0..n]).unwrap();
            }
        });
    }
}

let value = 22;
let result = moro::async_scope!(|scope| {
    let future1 = scope.spawn(async {
        let future2 = scope.spawn(async {
            value // access stack values that outlive scope
        });

        let v = future2.await * 2;
        v
    });

    let v = future1.await * 2;
    v
})
.await;
eprintln!("{result}"); // prints 88

// Note this works with T: NoUninit from bytemuck

pub fn main() {
    let a = Atomic::new(0i64);
    // NOTE: most modern platforms (x86)
    assert_eq!(
        Atomic::<i64>::is_lock_free(),
        cfg!(target_has_atomic = "64") && mem::align_of::<i64>() == 8
    );
}

use shred::{DispatcherBuilder, Read, Resource, ResourceId, System, SystemData, World, Write};

#[derive(Debug, Default)]
struct ResA;
#[derive(Debug, Default)]
struct ResB;

#[derive(SystemData)] // Provided with `shred-derive` feature
struct Data<'a> {
    a: Read<'a, ResA>,
    b: Write<'a, ResB>,
}
struct EmptySystem;
impl<'a> System<'a> for EmptySystem {
    type SystemData = Data<'a>;
    fn run(&mut self, bundle: Data<'a>) {
        // bundle reader & writer
        println!("{:?}", &*bundle.a);
        println!("{:?}", &*bundle.b);
    }
}

fn main() {
    let mut world = World::empty();
    let mut dispatcher = DispatcherBuilder::new()
        .with(EmptySystem, "empty", &[])
        .build();
    world.insert(ResA);
    world.insert(ResB);

    dispatcher.dispatch(&mut world);
}