fancellu

use std::fmt::Formatter;

trait MorseCode {
    fn to_morse_code(&self) -> Message;
}

impl MorseCode for String {
    fn to_morse_code(&self) -> Message {
        self.chars()
            .flat_map(|c| c.to_ascii_lowercase().to_morse_code())

fancellu

fn insensitive_sort<T: AsRef<str>>(users: &mut Vec<T>) {
    users.sort_by_cached_key(|a: &T| a.as_ref().to_lowercase());
}

fn main() {
    let mut users: Vec<String> = vec![String::from("zzz"), String::from("xxx")];
    insensitive_sort(&mut users);
    println!("{:?}", users);

    let mut users: Vec<&str> = vec!["Todd", "amy"];

fancellu

use std::collections::HashSet;
use std::hash::Hash;

fn unique_keep_order<T: Eq + Hash + Clone>(vec: Vec<T>) -> Vec<T> {
    let mut seen = HashSet::new();
    let mut output = Vec::with_capacity(vec.len());

    for x in vec.into_iter() {
        if seen.insert(x.clone()) {
            output.push(x); // Use the original x

fancellu

import cats.effect.{IO, IOApp}
import org.http4s.{Headers, MediaType, Method, Request}
import org.http4s.ember.client.EmberClientBuilder
import org.http4s.headers.Accept
import org.http4s.implicits.http4sLiteralsSyntax
import org.typelevel.log4cats.LoggerFactory
import org.typelevel.log4cats.slf4j.Slf4jFactory

object EmberClientCall extends IOApp.Simple {

fancellu

import cats.effect.{IO, IOApp}

// Emits intro text, then prompts for integers, keeping a running sum. Will exit upon 'exit'

object Repl2 extends IOApp.Simple {

  def parseInput(input: String): Int =
    scala.util.Try(input.toInt).toOption.getOrElse(0)

  def repl(total: Int): IO[Int] = {

fancellu

import cats.effect.{IO, IOApp}

// Emits intro text, then prompts for some command. Will exit upon 'exit'
// Note, these programs are values, as expected
object Repl extends IOApp.Simple {

  val repl: IO[Unit] = {
    for {
      input <- IO.println(">>> ") *> IO.readLine
      _ <- IO.println(s"You entered: $input") *> (if (input == "exit") IO.unit else repl)

fancellu

## Plotting an XOR function
import numpy as np
import matplotlib.pyplot as plt
X=np.random.random((1000,2))*2-1 # between -1 and 1
Y=[ (x[0]>0) !=(x[1]>0)  for x in X] # xor is true if booleans are unequal
plt.scatter(X[:,0], X[:,1],c=Y);

fancellu

import requests as requests
from requests import Response
from pydantic import BaseModel


class Quote(BaseModel):
    content: str
    author: str

fancellu

object Scala3TypeClassWithUsingGiven {

  trait MyMonoid[A] {
    def combine(x: A, y: A): A
    def empty: A
  }

  def combineList[A](li: List[A])(using monoid: MyMonoid[A]): A = li.foldLeft(monoid.empty)(monoid.combine)

  def main(args: Array[String]): Unit = {

fancellu

import cats.effect._
import fs2._
import scala.concurrent.duration._
import cats.effect.std._

// FS2 cats.effect.Queue example using flatMap or for comprehension
// Both streams emit nothing, but are effectful, communicating via the queue and updating a sum via the ref

object Fs2Queues extends IOApp.Simple {