monadplus

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RebindableSyntax #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

module IxMonad where

monadplus

[
  {
    "backcolor": "#ffffff",
    "name": "keyboard.io Model 01 - james's layout, based on algernon's Dvorak version",
    "author": "James Cash <james.cash@occasionallycogent.com>",
    "switchMount": "alps",
    "switchBrand": "matias",
    "switchType": "PG155B01",
    "pcb": false,
    "plate": true

monadplus

use std::collections::BTreeMap;

trait ToValue {
    fn to_value(self) -> Value;
}

impl ToValue for bool {
    fn to_value(self) -> Value {
        Value::Bool(self)
    }

monadplus

use futures::{stream::FuturesUnordered, StreamExt};

async fn do_something(i: u8) -> String {
    format! {"Future {i:#b}"}
}

#[tokio::main]
async fn main() {
    let v = std::sync::Arc::new(tokio::sync::Mutex::new(vec![]));
    (0..100)

monadplus

//! https://doc.rust-lang.org/std/panic/fn.catch_unwind.html

use std::panic::UnwindSafe;
use rand::random;

struct Boxed<'a, T> {
    inner: &'a mut [T],
}

impl<'a, T> UnwindSafe for Boxed<'a, T> {}

monadplus

use std::error::Error;

struct WindowsMut<'t, T> {
    slice: &'t mut [T],
    start: usize,
    window_size: usize,
}

trait LendingIterator {
    type Item<'a>

monadplus

use std::{
    error::Error,
    fs::File,
    io::{self, BufRead},
};

use clap::{ArgGroup, Parser};

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]

monadplus

Rust in a Nutshell

Table of Contents

• Rust: The Language
  • Borrow Checker
  • Macros
  • Parallelism & Concurrency
  • Example
• Dependency injection

monadplus

Cabal: ghc-options

• ghc-options specified in *.cabal apply to LOCAL packages.

• If you want your ghc-options to be applied to ALL packages (including dependencies), you need to create a top-level cabal.project:

  packages: .
  
  package *
  

ghc-options: -O2

monadplus

-- | >>> measure (return $ sum [1..100000000])
-- (5000000050000000,1.892e-6)
measure :: IO a -> IO (a, Double)
measure io = do
  start <- getMonotonicTimeNSec
  a <- io
  end <- getMonotonicTimeNSec
  return (a, fromIntegral (end - start) / 1_000_000_000)

-- | >>> measure (return $ sum [1..100000000])