SystemFw

/*
 Here's a derivation for a tail recursive fibonacci function.
 Let's start from the Maths definition:
   fib(0) = 0
   fib(1) = 1
   fib(n) = fib(n - 1)  + fib(n - 2)
*/


// Let's translate the structure, leaving the recursive case unspecified:

SystemFw

Balaji Sivaraman @balajisivaraman_twitter

Hi all, I need some help understanding a piece of Doobie code from the examples. It is the StreamingCopy one: (https://github.com/tpolecat/doobie/blob/series/0.4.x/yax/example/src/main/scala/example/StreamingCopy.scala). I am using a modified version of the fuseMap2 example from that file. Here’s how I’ve modified it for my requirements:

  def fuseMap[F[_]: Catchable: Monad, A, B](
      source: Process[ConnectionIO, A],
      sink: Vector[A] => ConnectionIO[B],
      delete: ConnectionIO[Unit]
  )(
 sourceXA: Transactor[F],

SystemFw

object Example {
  import cats._, implicits._
  import cats.effect._
  import fs2._
  import scala.concurrent.ExecutionContext

  // start N streams concurrently, and stream their results in order
  // e.g. download a file from  a server in N parts concurrently, and stream it

  abstract class Channel[F[_], A] {

SystemFw

-- The assumption here is that stream based I/O is a better fit for 
-- distributed systems than monadic I/O, because there is a greater
-- separation between logic, which can be idempotent and distributed
-- via something like differential dataflow, and actions, which can 
-- be represented like ports and actuators

-- We already know that stream based I/O is a good fit for reactive programs
-- but what about more "imperative" ones that fit monads well? I took an imperative
-- example and tried to express it via stream I/O

SystemFw

object Ex {
  import Lib._

  case class Person(name: String, age: Int)
  case class PersonOpt(name: Option[String], age: Option[Int])

  def mergePerson(p: Person, po: PersonOpt) =
    Person(po.name.getOrElse(p.name), po.age.getOrElse(p.age))

  case class Contact(person: Person, phone: String)

SystemFw

object Conversions {
  import cats._, implicits._, data.ValidatedNel
  import mouse._, string._, option._
  import shapeless._, labelled._

  private type Result[A] = ValidatedNel[ParseFailure, A]

  case class ParseFailure(error: String)

  trait Convert[V] {

SystemFw

// stemming from
// https://gitter.im/typelevel/general?at=5f987f8161007f7d1b9b4b92
// The idea is
// read the JSON files in a directory
// try to decode each of them as Event which could be either One or Two, we don't know this at compile time
// serialize the values we got, again could be either One or Two and compare it with the content of the JSON file
// verify that there was at least a JSON file for One and Two (exhaustivity check)

import shapeless._

SystemFw

import shapeless._

@annotation.implicitNotFound("Make sure all cases of ${C} have an instance of ${TC}")
trait CopTCs[C <: Coproduct, TC[_]] {
  type Out <: HList
  def result: Out
}
object CopTCs {
  type Aux[C <: Coproduct, TC[_], O <: HList] = CopTCs[C, TC] { type Out = O }
  def apply[C <: Coproduct, TC[_]](implicit ev: CopTCs[C, TC]) = ev

SystemFw

object Test {
  import inc._

  case class Foo(i: Int, s: String)
  case class Bar(f: Int, a: Foo, n: Int)

  val res = Bar(0, Foo(1, "hello"), 2).incBy(2)
  //res0: Test.Bar = Bar(2,Foo(3,hello),4)
}

SystemFw

import shapeless._  // requires.shapeless
import cats._, implicits._, data.Kleisli // requires.cats
import cats.sequence._ //requires kittens
import cats.effect.IO //requires cats-effect
// ofc, uses "-Ypartial-unification" and kind-projector

case class Result() // replace with the JDBC equivalent

case class DB(val r: Result) {
  def nextInt: IO[Int] = ??? //IO(g.nextInt)