julien-truffaut

import monocle.macros.GenIso
import scalaz.std.option._

object Test extends App {
  case class Bar(blub: Option[String])
  case class Foo(bar: Option[Bar])

  val bar  = GenIso[Foo, Option[Bar]]
  val blub = GenIso[Bar, Option[String]]

julien-truffaut

trait Semigroup[A] {}
trait Monoid[A] extends Semigroup[A] {}

trait Functor[F[_]] {}
trait Applicative[F[_]] extends Functor[F] {}

trait Foo[A] { override def toString: String = "Foo"}
trait Foo2[A] extends Foo[A] { override def toString: String = "Foo2"}
trait Foo3[A] extends Foo2[A] {override def toString: String = "Foo3"}

julien-truffaut

1.3.0

17 October 2016

Addition

• new unsafe module with select #394 (thanks to cesartl)
• refactor optics laws to use random functions #357
• add Wrapped typeclass #365 (thanks to puffnfresh)
• add State syntax for Optional #387 (thanks to cb372)

julien-truffaut

package vanilla

sealed trait Optic[G[_,_] <: Optic[G, _, _], S, A] {
  def compose[F[_, _] <: Optic[F, _, _], B](o: F[A, B])(implicit lub : Lub[G,F]) : lub.T[S, B] =
    lub.compose(self, o)
  def self: G[S,A]
  def desc: List[String]
}

case class Traversal[A,B](desc : List[String]) extends Optic[Traversal,A,B] {

julien-truffaut

package foobar.style

import scalacss.Defaults._

object ExampleStyle extends StyleSheet.Inline {
  import dsl._

  val ul = style(
    backgroundColor.blue
  )

julien-truffaut

λ> parseString parseSemVer mempty "1.0.0-alpha+001"
Success (SemVer 1 0 0 [NOSS "alpha"] [NOSI 1])
λ> parseString parseSemVer mempty "1.0.0+20130313144700"
Success (SemVer 1 0 0 [] [NOSI 20130313144700])
λ> parseString parseSemVer mempty "1.0.0"
Success (SemVer 1 0 0 [] [])

julien-truffaut

sealed trait Alg1[A]
case class Foo1(s: String) extends Alg1[Int]
case object Bar1 extends Alg1[Boolean]

sealed trait Alg2[A]
case class Foo2[A](s: String, f: String => A) extends Alg2[A]
case class Bar[A](f: Boolean => A) extends Alg2[A]

julien-truffaut

package sandbox

import cats.data.Coproduct
import cats.free.{Free, Inject}

sealed trait Alg1[A]
sealed trait Alg2[A]
sealed trait Alg3[A]

class Alg1Ops[F[_]](implicit I: Inject[Alg1, F]){

julien-truffaut

package freee

import scalaz.\/
import scalaz.concurrent.Task

object Example extends App {
  import Interact._

  val program: API[Unit] = for {
    _    <- tell("Hey")

julien-truffaut

package bilberry.snippet

import scalaz.syntax.functor._

trait MyShow[A] {
  def show(a: A): String
}

object MyShow {
  def apply[A](implicit ev: MyShow[A]): MyShow[A] = ev // summon the implicit using syntax MyShow[X]