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 {

fancellu

use rand::Rng;
use rasciigraph::{plot, Config};

fn main() {
    let vec = (0..70)
        .map(|_| rand::thread_rng().gen::<f64>() * 13.0 - 3.0)
        .collect::<Vec<_>>();

    let plot = plot(
        vec,

fancellu

use chrono::prelude::*;

fn flexi_data_parse(text: &str) -> Option<NaiveDate> {
    let text = text.replace(['.', '/'], "-");

    let fmts = ["%Y-%m-%d", "%Y-%b-%d", "%d-%b-%Y", "%b-%d-%Y", "%d-%m-%Y"];
    for fmt in fmts {
        let parser = NaiveDate::parse_from_str(text.as_str(), fmt);
        if parser.is_ok() {
            return parser.ok();

fancellu

use std::fmt::Display;
use std::str::FromStr;

#[derive(Debug)]
struct Rle {
    data: Vec<u8>,
}

impl Rle {
    fn decode(&self) -> String {

fancellu

use crate::RGBError::WrongLength;
use std::num::ParseIntError;
use std::str::FromStr;

#[derive(Debug)]
struct RGB {
    red: u8,
    green: u8,
    blue: u8,
}

fancellu

use crate::InvalidIsbn::{BadChecksum, TooLong, TooShort};
use std::str::FromStr;

// check digit calculation for ISBN-13

#[derive(Debug)]
struct Isbn {
    raw: String,
}

fancellu

use std::iter::Sum;

fn sum_with_missing<T: Sum + Copy>(vec: &Vec<Option<T>>) -> T {
    vec.into_iter().filter_map(|x| *x).sum()
}

fn main() {
    let mut v = vec![Some(1), Some(2), Some(3), None, Some(5)];
    println!("{}", sum_with_missing(&v));