fancellu

import cats._
import cats.implicits._

// Cats Apply, does cartesian maps, extends Functor and Semigroupal (which does cartesian joins, unlike pairwise Align)

object CatsAp extends App {

  val apOption=Apply[Option]

  val option1: Option[(Int, Int)] =apOption.product(Option(1), Option(2))

fancellu

// take out the + and see the last few lines fail as doit then only takes Animal, and not its subtypes
// we output A, so + is fine, we are covariant
sealed trait ThisThatValue[+A]

object ThisThatValue {
  final case class This[+A](value: A) extends ThisThatValue[A]
  final case class That[+A](value: A) extends ThisThatValue[A]
}

fancellu

import cats._
import cats.data._
import cats.syntax._
import cats.implicits._

object CatsBi extends App {

  val fail = Left("failed")

  val ok = Right(123)

fancellu

import cats._
import cats.data._
import cats.syntax._
import cats.implicits._

object CatsAlign extends App {

  val alOption=Align[Option]

  val iorO: Option[Ior[Int, Int]] =alOption.align(Option(1), Option(2))

fancellu

// Shows how to use okhttp and sttp in Scala asynchronously to talk to a Tor onion address via a Tor socks proxy, 
// without trying to resolve DNS outside of proxy (few http clients do this properly and instead return UnknownHostException)

// libraryDependencies ++= Seq("com.squareup.okhttp3" % "okhttp" % "4.7.2",
//                             "com.softwaremill.sttp.client" %% "okhttp-backend" % "2.1.2"))

import java.io.IOException
import java.net.{InetSocketAddress, Proxy}

import okhttp3.{Call, Callback, OkHttpClient, Request, Response}

fancellu

import cats._
import cats.data._
import cats.syntax._
import cats.implicits._

object CatFold extends App{

    // list of Tuple[Int, Double]
  println(List((20,1.1),(29,2.2)).combineAllOption)

fancellu

import play.api.libs.json._

object PlayJsonAnyVal extends App {

  final case class Address(path: String) extends AnyVal

  object Address {
    // this allows Address to be used as a map key, even though it is not a String
   implicit val keyReads: KeyReads[Address]= key => JsSuccess(Address(key))
   implicit val keyWrites: KeyWrites[Address] = _.path

fancellu

import cats._
import cats.data._
import cats.syntax._
import cats.implicits._

object CatFunc extends App {

   // a very naive linked list implementation and functor for it
  trait MyList[+A]
  case class MyNode[A]( head: A, tail: MyList[A]) extends MyList[A]

fancellu

import simulacrum._

// Example usage of Simulacrum, v similar to math.Ordering/Numeric in standard SDK
object SimType extends App {

  @typeclass trait Showing[T] {
    def show(x: T): String
  }

  @typeclass trait Ordering[T] extends Showing[T]{

fancellu

import cats.Eval

object Ev extends App{

   // eager, method call
  val always: Eval[Int] =Eval.always{
    println("running always")
    123
  }
    // lazy, memoized