fancellu

import scala.util.{Success, Failure}

val seq=Seq(Success(1), Failure(new Exception("bang")), Success(2))

// all emit         List(1, 2)

seq.map(_.toOption).flatten
seq.flatMap(_.toOption)
seq.filter(_.isSuccess).map(_.get)
seq.collect{case Success(x) => x}

fancellu

license: gpl-3.0
height: 600

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 MyErrsIO.Controller.{Request, postTransfer}
import MyErrsIO.Models.Account
import cats.data.Validated.{Invalid, Valid}
import cats.data.{EitherT, OptionT, Validated, ValidatedNec}
import cats.effect._
import cats.implicits._

import scala.util.control.NonFatal

// A simple example of cat-effect and error handling, with MonadTransformers

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 {

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 requests as requests
from requests import Response
from pydantic import BaseModel


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

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 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

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] = {