MateuszKubuszok

sealed trait FList[F[_]] extends Product with Serializable
object FList {
  final case class Last[F[_], A, B](f: A => F[B]) extends FList[F]
  final case class Cons[F[_], A, B, Tail <: FList[F]](f: A => F[B], tail: Tail) extends FList[F]
}

implicit class FunOps[F[_], A, B](f: A => F[B]) extends AnyVal {

  def toFList: FList.One[F, A, B] = FList.One(f)
  

MateuszKubuszok

Keybase proof

I hereby claim:

• I am mateuszkubuszok on github.
• I am mateuszkubuszok (https://keybase.io/mateuszkubuszok) on keybase.
• I have a public key ASDad2uAPXJRFF-i7B7nKeQixgIFu5bVsXJLqD7jJGRg0Ao

To claim this, I am signing this object:

MateuszKubuszok

MateuszKubuszok

backup: .dotsync_bck
global:
  include:
    - .bashrc
    - .zshrc
  exclude: []
local:
  laptop2:
    include:
      - .snxrc

MateuszKubuszok

Compiled from "Test2.scala"
public final class Test2$ {
  public static final Test2$ MODULE$;

  public static {};
    Code:
       0: new           #2                  // class Test2$
       3: dup
       4: invokespecial #20                 // Method "<init>":()V
       7: putstatic     #22                 // Field MODULE$:LTest2$;

MateuszKubuszok

Compiled from "Test1.scala"
public final class Test1$ {
  public static final Test1$ MODULE$;

  public static {};
    Code:
       0: new           #2                  // class Test1$
       3: dup
       4: invokespecial #18                 // Method "<init>":()V
       7: putstatic     #20                 // Field MODULE$:LTest1$;

MateuszKubuszok

trait Uncurry[C, U] {
  def uncurried(curried: C): U
}
object Uncurry {
  def instance[C, U](body: C => U) = new Uncurry[C, U] {
    def uncurried(curried: C): U = body(curried)
  }
  implicit def uncurry2[A, B, Out]: Uncurry[A => B => Out, (A, B) => Out] =
    instance[A => B => Out, (A, B) => Out] { curried => curried(_)(_) }
  implicit def uncurry3[A, B, C, Out]: Uncurry[A => B => C => Out, (A, B, C) => Out] =

MateuszKubuszok

//
// @author: Mateusz Kubuszok
//
// requirements: ammonite 1.1.0
// usage:        run `amm` and copy paste into REPL

import $ivy.`org.typelevel::cats-core:1.3.1`, cats._, cats.syntax.all._
import $ivy.`org.typelevel::cats-effect:1.0.0`, cats.effect._, cats.effect.syntax._
import $ivy.`io.circe::circe-core:0.9.3`, io.circe._, io.circe.syntax._
import $ivy.`io.circe::circe-generic:0.9.3`, io.circe.generic.auto._

MateuszKubuszok

// Parser definitions

type Parser[+A] = String => Option[(A, String)]

object Parser{
  
  def apply[A](re: String)(f: String => A): Parser[A] =
    input => s"""\\s*($re)(\\s*)""".r
      .findPrefixMatchOf(input)
      .map { n =>

MateuszKubuszok

// based on http://pavkin.ru/reverse-state-monad-in-scala-is-it-possible/

import $ivy.`org.typelevel::cats-core:1.4.0`, cats._, cats.implicits._
//import $plugin.$ivy.`org.spire-math::kind-projector:0.9.4`
//import $plugin.$ivy.`com.olegpy::better-monadic-for:0.2.4`

///

{
class ReverseState[S, A](val runF: Eval[Eval[S] => (Eval[S], Eval[A])]) {