fancellu

use std::sync::Arc;
use tokio::sync::Barrier;
use tokio::sync::BarrierWaitResult;
use tokio::sync::Notify;
use tokio::time::sleep;
use tokio::time::Duration;

// Simulating the filling of boxes with 5 cans, from many tasks

async fn barrier_wait(barrier: Arc<Barrier>, notify: Arc<Notify>, id: usize) -> BarrierWaitResult {

fancellu

use std::sync::Arc;
use tokio::sync::Notify;
use tokio::time::sleep;
use tokio::time::Duration;

// Notify can be thought of a Semaphore with 0 permits

async fn order_packages(package_delivered: Arc<Notify>) {
    sleep(Duration::from_secs(2)).await;
    println!("Company: Find package");

fancellu

use std::sync::Arc;
use tokio::sync::{Semaphore, SemaphorePermit};
use tokio::time::sleep;
use tokio::time::Duration;

async fn person(sem: Arc<Semaphore>, name: String) {
    println!("Person {}: waiting for a permit", name);
    teller(sem, &name).await;
    println!("\tPerson {} finished", name);
}

fancellu

use std::sync::Arc;
use tokio::sync::Mutex;

// async tokio function to increment i32 behind arc mutex
async fn increment(remote: Arc<Mutex<i32>>) {
    println!("trying to lock");
    let mut tvc = remote.lock().await;
    println!("incremented");
    *tvc += 1;
}

fancellu

async fn hello(name: &str) -> String {
    // pretend to be doing some work
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;

    format!("Hello {}", name)
}

fn blocking() -> String {    
    println!("Blocking");

fancellu

use std::{error::Error, process};

fn cities() -> Result<(), Box<dyn Error>> {
    let mut csv_rdr = csv::Reader::from_path("data/cities.csv")?;
    for result in csv_rdr.records() {
        let record = result?;
        println!("{:?}", record);
        println!("{}",record.get(0).unwrap());
    }
    Ok(())

fancellu

use serde::Deserialize;
use std::time::Duration;

#[derive(Deserialize, Debug)]
struct Product {
    id: i32,
    title: String,
    description: String,
    price: f64,
    #[serde(rename = "discountPercentage")]

fancellu

import cats.effect.std.Semaphore
import cats.effect._
import cats.implicits._

import scala.concurrent.duration._

object DiningPhilosophersIOApp extends IOApp {

  case class Fork(id: Int, lock: Semaphore[IO])

fancellu

import java.util.concurrent.Executors
import java.util.concurrent.locks.{Lock, ReentrantLock}
import scala.concurrent.{Await, ExecutionContext, Future}
import scala.concurrent.duration.*
import scala.concurrent.ExecutionContext.Implicits.global

case class Fork(id: Int, lock: Lock)

case class Philosopher(name: String, left: Fork, right: Fork)

fancellu

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

struct Fork {
    id: usize,
    mutex: Mutex<()>,
}

impl Fork {