justinhj

package examples

import scalaz._, Scalaz._

object ContravariantMap {

// Example of contravariant using Scalaz
  trait Printable[A] {
    def format(value: A): String
  }

justinhj

// Tuples, integers and maps all have monoid 
// instances we can easily combine them

@ val data = "Hello Hello This is some data data data yo" 
data: String = "Hello Hello This is some data data data yo"

@ def step(word: String) = (1, word.length, Map(word -> 1)) 
defined function step

@ def run(data: String) = data.split(" ").toList.map(step).combineAll 

justinhj

// Comonad is the dual of Monad
// example for non empty list, extract is the head of the list
// coflatMap gives you successive lists from the whole list, the tail, the tail of that 
// and you must return a single value for each list...

@ Comonad[NonEmptyList].extract(NonEmptyList.of(1,2,3)) 
res26: Int = 1

@ Comonad[NonEmptyList].extract(NonEmptyList.of(1)) 
res27: Int = 1

justinhj

import cats._
import cats.implicits._
import cats.data.StateT

object Radio {
    case class Radio(volume: Int)

  type RadioError = String
  type RadioEither[A] = Either[RadioError, A]
  type RadioStateEitherT[A] = StateT[RadioEither, Radio, A]

justinhj

import zio._
import zio.console._
import zio.{Queue, UIO}
import akka.actor._
import com.typesafe.config.ConfigFactory
import java.util.concurrent.Executors
import scala.concurrent.{ExecutionContext}
import scala.concurrent.duration.FiniteDuration
import java.util.concurrent.{Executors, TimeUnit}
import java.util.concurrent.{ExecutorService, Executors, ThreadFactory}

justinhj

object ComposePlay {

  // Compose takes two Kleisli arrows (  A => F[B], B => F[C] ) and returns A => F[C]
  // Here I implement unit and compose for Option
  // Then flatMap is implemented using compose showing that you can make a Monad
  // with unit and compose...

  def unitOption[A](a : A) : Option[A] = Some(a)

justinhj

//   "com.lihaoyi"            %% "upickle"                 % "0.7.5",

import upickle.default.{read,write}
import upickle.default.{ReadWriter => RW, macroRW}

object PickleMap {

    case class KeyClass(s: String, i: Int)
    object KeyClass{
        implicit val rw: RW[KeyClass] = macroRW

justinhj

val fb = Stream.emits(List(false, false, true)).repeat.zip(Stream.emits(List(false,false,false,false,true)).repeat).map{
  case (true,true) => "fizzbuzz"
  case (true,false) => "fizz"
  case (false,true) => "buzz"
  case (false,false) => ""
  } 
//fb: Stream[Nothing, String] = Stream(..)

// @ fb.take(30).toList 
// res27: List[String] = List(

justinhj

@ val fb = Stream.emits(List("", "", "fizz")).repeat.zip(Stream.emits(List("", "", "", "", "buzz")).repeat).map{case (a,b) => a |+| b} 
fb: Stream[Nothing, String] = Stream(..)

@ fb.take(30).toList 
res37: List[String] = List(
  "",
  "",
  "fizz",
  "",
  "buzz",

justinhj

import fs2._
import cats._
import cats.implicits._

object Fs2FizzBuzz {

  val fb = Stream.emits(List(None, None, "Fizz".some)).
    repeat.
    zip(Stream.emits(List(None, None, None, None, "Buzz".some)).
      repeat).