Skip to content

Instantly share code, notes, and snippets.

Fabio Labella SystemFw

Block or report user

Report or block SystemFw

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
@SystemFw
SystemFw / Ex.scala
Last active Nov 3, 2018
Encoding existentials via abstract types (1) and higher-ranks (2)
View Ex.scala
// This is the traditional encoding, using abstract type members
// to encode existentials
object AbstractExistentials {
trait E {
type X
val x: X
def f(p: X): String
}
@SystemFw
SystemFw / Ex.scala
Created Oct 26, 2018
Get instances of a typeclass `TC[_]` for all cases of a Coproduct [shapeless]
View Ex.scala
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
SystemFw / groupBy.scala
Created Jul 9, 2018
fs2 `groupBy/partitions`
View groupBy.scala
// Grows with the number of distinct `K`
def partitions[F[_], A, K](selector: A => F[K])(implicit F: Effect[F], ec: ExecutionContext) : Pipe[F, A, (K, Stream[F, A])] = in =>
Stream.eval(async.refOf[F, Map[K, Queue[F, Option[A]]]](Map.empty)).flatMap { st =>
val cleanup = {
import alleycats.std.all._
st.get.flatMap(_.traverse_(_.enqueue1(None)))
}
(in ++ Stream.eval_(cleanup)).evalMap { el =>
(selector(el), st.get).mapN { (key, queues) =>
@SystemFw
SystemFw / RankN shift-and-shiftback.md
Last active Jun 1, 2019
Cats-effect, blocking, RankN-types.
View RankN shift-and-shiftback.md

cats-effect

The cats-effect project defines a purely functional effect type (IO[A]), and associated typeclasses defining its behaviour. The ones we care about for this example are:

trait Sync[F[_]] extends MonadError[F, Throwable] {
   def delay[A](a: => A): F[A]
   ...
}
@SystemFw
SystemFw / Test.scala
Created Jan 21, 2018
Recursively increment every Int in a case class by a given runtime quantity
View Test.scala
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
SystemFw / Test.scala
Last active Jul 9, 2018
Parallel foldMonoid with fs2
View Test.scala
object Test {
import cats.implicits._
import cats.kernel.CommutativeMonoid
import cats.effect._
import fs2._
import scala.concurrent.ExecutionContext
// same as parallelFoldMonoid, but with some logging to show the parallelism
def loggedParallelFoldMonoid[F[_], A: CommutativeMonoid](n: Int)(
input: Stream[F, A])(implicit F: Effect[F], ec: ExecutionContext) =
@SystemFw
SystemFw / Lib.scala
Last active Jun 7, 2019
Shapeless: derive JDBC Results for arbitrary case classes
View Lib.scala
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)
@SystemFw
SystemFw / Q.scala
Created Oct 9, 2017
Shapeless: create an HList of functions from case class T to each of its fields
View Q.scala
object Q {
import shapeless._, labelled._, ops.record.Selector
trait Accessors[T, I] {
type Out
def value: Out
}
object Accessors {
type Aux[T, I, O] = Accessors[T, I] { type Out = O }
@SystemFw
SystemFw / example.scala
Last active Oct 12, 2019
Running fs2 streams in parallel and collect their result in sequence, with queues
View example.scala
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
SystemFw / Test.scala
Last active Jun 7, 2019
Shapeless: Convert between any two compatible case classes, selecting a subset of the fields
View Test.scala
object Test {
case class User(name: String, age: Int)
case class UserDTO(name: Option[String], age: Option[Int])
import conversions._
def a = User("John", 24).convertTo[UserDTO](Set("name"))
// res0: Test.UserDTO = UserDTO(Some(John),None)
case class WrongFieldNames(surname: Option[String], age: Option[Int])
You can’t perform that action at this time.