julien-truffaut

import io.circe.Json
import io.circe.optics.all._
import io.circe.parse.parse
import monocle.Iso
import monocle.function.Plated
import monocle.function.all._

object PlatedExample extends App {
  val json =
    """{

julien-truffaut

1.2.0-M2

Thanks to all the 14 contributors since 1.2.0-M1

Addition

• add only Prism to match a single value see
• add below Prism to lift a Prism in a Traverse see
• add length for Fold and Traversal #236 (thanks to aoiroaoino)
• add optics for scalaz.Either3 #242 (thanks to aoiroaoino)

julien-truffaut

import remotely.{Type, Field, Protocol}
import remotely.codecs._
import remotely._
import remotely.transport.netty.NettyTransport

object protocol {
  val definition = Protocol.empty
    .codec[Int]
    .specify1("factorial", Field.strict[Int]("in"), Type[Int])
}

julien-truffaut

import monocle.MonocleSuite
import monocle.generic.internal.TupleGeneric

class ProductExample extends MonocleSuite {

  case class Example(i : Int, s: String, b: Boolean)

  implicit val gen = TupleGeneric[Example]

  test("productToTuple creates an Iso between a Product and a Tuple") {

julien-truffaut

Van Laarhoven Lens

A Lens is a functional concept that permits to zoom in a data structure. A key point of Lenses is that they compose together such as you can drill deeper and deeper in your data. Once you arrive at the level you are interested in, you can either extract or modify (even effectfully!) the value you targeted.

In this presentation, I would like to go through a specific Lens implementation known as Van Laarhoven Lenses. This implementation is particularly interesting because it defines Lenses as a unique function! The game is to find out how can we derive all Lens methods from this simple function.

julien-truffaut

scalaVersion := "2.11.7"

libraryDependencies ++= Seq(
  "io.gatling.highcharts"  % "gatling-charts-highcharts"      % "2.1.7"          % "test",
  "io.gatling"             % "gatling-test-framework"         % "2.1.7"          % "test"
)

lazy val LoadTest = config("load") extend Test

lazy val LoadTest = config("load") extend Test

julien-truffaut

package monocle.example

import monocle.Prism
import monocle.macros.Lenses
import monocle.function._
import monocle.std.map._
import monocle.std.string._

import scalaz.Equal

julien-truffaut

import org.http4s.Uri.{RegName, Authority, IPv4}
import org.http4s.client.blaze.SimpleHttp1Client
import org.http4s.dsl._
import org.http4s.server.HttpService
import org.http4s.server.blaze.BlazeBuilder
import org.http4s.{Request, Response, Uri}

import scala.concurrent.duration.Duration

julien-truffaut

import monocle.function._
import monocle.std.list._
import monocle.Lens
import monocle.syntax.apply._

case class Person(name: String, age: Int)

val ps = List(Person("John", 25), Person("Paul", 32))

val _age = Lens[Person, Int](_.age)(a => p => p.copy(age = a))

julien-truffaut

Beyond Scala Lens

A Lens is a functional concept which solves a very common problem: how to update a complex immutable structure. This is probably the reason why Lenses are relatively well known in functional programming languages such as haskell or scala. However, there are far less resources 
available on the generalisation of Lenses known as "optics". Today, I would like to go through a few of these optics namely Iso, Prism and Optional by showing how they relate to each other as well as how to use optics in a day to day programming job.

Julien Truffaut is the author of Monocle, an optics library for scala mainly inspired by haskell lens. He also partcipates in a few open source project such as scalaz, cats or http4s.