milessabin

// local/localtests/test/localtests/LocalTests.scala
package localtests

import java.nio.file._
import java.util.stream.{ Stream => JStream }

import org.junit.{ AfterClass, Test }

import scala.collection.JavaConverters._
import scala.concurrent.duration._

neko-kai

package quantified

import cats.Monad

import scala.language.implicitConversions

/**
  * C[_] constraint applied to type F[_, _] quantified in first parameter, i.e.
  *
  * {{{

artempyanykh

Scalaz RingBuffer

Goal

Scalaz RingBuffer adds a high-performance low-latency multi-producer/multi-consumer task queue to RTS for faster and smarter concurrency in ZIO.

Introduction & Highlights

ZIO RTS runs on a thread pool executor backed by LinkedBlockingQueue. This has the following consequences:

1. Performance and latency are inhibited because: a) waiting on locks cause threads to be de-scheduled, b) traversing a linked list is not cache-friendly.
2. Optimizations to Fiber cooperative multi-tasking strategy is limited because the thread pool doesn't expose any metrics on its queue remaining capacity\processing times.

jdegoes

package fpmax

import scala.util.Try
import scala.io.StdIn.readLine

object App0 {
  def main: Unit = {
    println("What is your name?")

    val name = readLine()

smarter

trait Stream[+F[_], +A]

object Stream {
  // Make scalac get over its oudenophobia.
  type Nothing2[X] <: Nothing

  def emits[F[x] >: Nothing2[x], A](as: List[A]): Stream[F, A] = new Stream[F, A] {}

  implicit class InvariantOps[F[x] >: Nothing2[x], A](private val self: Stream[F, A]) extends AnyVal {
    def ethrough[B](p: Stream[F, A] => Stream[F, B]): Stream[F, B] = p(self)

SystemFw

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]
   ...
}

milessabin

import scala.language.higherKinds

// Whitebox ...
trait Schema[T, R] {
  def conv(t: T): R
}

object Schema {
  // Whitebox macro: R is computed from T
  implicit def mkSchema[T, R]: Schema[T, R] = ??? // macro ...

antirez

RESP3 specification

Versions history:

• 1.0, 2 May 2018, Initial draft to get community feedbacks.

Background

The Redis protocol has served us well in the past years, showing that, if carefully designed, a simple human readable protocol is not the bottleneck in the client server communication, and that the simplicity of the design is a major advantage in creating a healthy client libraries ecosystem.

Yet the Redis experience has shown that after about six years from its introduction (when it replaced the initial Redis protocol), the current RESP protocol could be improved, especially in order to make client implementations simpler and to support new features.

jdegoes

object game {
  case class Lens[S, A](set: A => S => S, get: S => A) { self =>
    def >>> [B](that: Lens[A, B]): Lens[S, B] =
      Lens[S, B](
        set = (b: B) => (s: S) => self.set(that.set(b)(self.get(s)))(s),
        get = (s: S) => that.get(self.get(s))
      )
  }
  case class Prism[S, A](set: A => S, get: S => Option[A]) { self =>

sir-wabbit

// Those pesky lambda expressions don't stand a chance :)
// (and certainly no more higher-order functions!)
// Behold,
trait /*The glorious*/ KappaCalculus {
  
  // rules of the game
  type Type[A]
  
  type Unit
  implicit def unitIsType: Type[Unit]