sergey-scherbina

object OpenUnion extends App {
  
    trait in[A, B] {
      def inj(a: A): B
    }
    object in {
      implicit def inSelf[A]: (A in A) = (a: A) => a
      implicit def inHead[A, B]: (A in (A Either B)) = (a: A) => Left(a)
      implicit def inRight[A, B, C](implicit r: (A in C)): (A in (B Either C)) =
        (a: A) => Right(r.inj(a))

sergey-scherbina

package json.diff;

import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.MapDifference;
import com.google.common.collect.Maps;

import java.io.File;

sergey-scherbina

import io.vavr.Tuple;
import io.vavr.collection.Iterator;
import io.vavr.control.Option;
import io.vavr.control.Try;

import java.util.List;
import java.util.function.*;

public interface Mapper<S, T> extends BiFunction<T, S, Boolean> {

sergey-scherbina

// Faster coroutine pipelines
// https://dl.acm.org/citation.cfm?doid=3136534.3110249
// https://github.com/iokasimov/pipeline/blob/master/Control/Pipeline.hs

object Monads {

  trait Monad[M[_]] {
    def pure[A](a: A): M[A]

    def >>=[A, B](m: M[A])(f: A => M[B]): M[B]

sergey-scherbina

/*
https://github.com/rizo/streams/blob/master/src/coroutine.ml
https://pusher.com/sessions/meetup/the-realtime-guild/realtime-stream-processing-with-coroutines
*/

object Pipes {

  sealed trait Pipe[I, O, R] {

    final def flatMap[T](f: R => Pipe[I, O, T]): Pipe[I, O, T] = this match {

sergey-scherbina

import Cont._

object ContTest extends App {
  
  def fib() = loop(for {
    (x, y) <- take[(BigInt, BigInt), Stream[BigInt]]
    _ <- put(x)
  } yield (y, x + y))(1, 1)

  println(fib().take(100).toList)

sergey-scherbina

import org.parboiled2._

/*
http://okmij.org/ftp/tagless-final/course/lecture.pdf
*/

object Tagless extends scala.App {

  type Id[A] = A
  trait ~>[F[_], G[_]] {

sergey-scherbina

package sandbox

import scala.annotation.tailrec
import scala.util.continuations.{cps, _}

/*
Introduction to Programming with Shift and Reset
http://pllab.is.ocha.ac.jp/~asai/cw2011tutorial/main-e.pdf
*/

sergey-scherbina

import scala.annotation.tailrec
import Thunk._

/*
https://www.cs.utah.edu/~mflatt/past-courses/cs6520/public_html/s02/cps.pdf
*/

sealed trait Thunk[A, B] {
  @inline final def run(f: A => B): B = Thunk.run(this, f)
}

sergey-scherbina

import cats._
import cats.implicits._
import scala.annotation.tailrec
import scala.util.control.TailCalls._

/*
http://okmij.org/ftp/continuations/zipper.html
http://okmij.org/ftp/Haskell/ZipperTraversable.hs
*/