Load the REPLesent.scala file in a scala REPL (it's a slightly modified version, the original can be found here).
Then create the presentation with :
scala> val presentation = REPLesent(input = "shapeless_easy.txt", intp = $intp)
scala> import presentation._You can run the code on a slide using !!!
| /* | |
| * Copyright 2015 Marconi Lanna | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| case class REPLesent( | |
| width: Int = 0 | |
| , height: Int = 0 | |
| , input: String = "REPLesent.txt" | |
| , slideCounter: Boolean = false | |
| , slideTotal: Boolean = false | |
| , intp: scala.tools.nsc.interpreter.IMain = null | |
| ) { | |
| import scala.util.Try | |
| private case class Config( | |
| top: String = "*" | |
| , bottom: String = "*" | |
| , sinistral: String = "* " | |
| , dextral: String = " *" | |
| , newline: String = System.lineSeparator | |
| , whiteSpace: String = " " | |
| , private val width: Int | |
| , private val height: Int | |
| ) { | |
| val (screenWidth, screenHeight): (Int, Int) = { | |
| val defaultWidth = 80 | |
| val defaultHeight = 25 | |
| if (width > 0 && height > 0) (width, height) else { | |
| // Experimental support for screen size auto-detection. | |
| // Supports only Unix-like systems, including Mac OS X and Linux. | |
| // Does not work with Microsoft Windows. | |
| val Array(h, w) = Try { | |
| import scala.sys.process._ | |
| val stty = Seq("sh", "-c", "stty size < /dev/tty").!! | |
| stty.trim.split(' ') map (_.toInt) | |
| } getOrElse Array(0, 0) | |
| val screenWidth = Seq(width, w) find (_ > 0) getOrElse defaultWidth | |
| val screenHeight = Seq(height, h) find (_ > 0) getOrElse defaultHeight | |
| (screenWidth, screenHeight) | |
| } | |
| } | |
| private def fill(s: String): String = if (s.isEmpty) s else { | |
| val t = s * (screenWidth / s.length) | |
| t + s.take(screenWidth - t.length) | |
| } | |
| val topRow = fill(top) + newline | |
| val bottomRow = fill(bottom) | |
| val verticalSpace = screenHeight - 3 // accounts for header, footer, and REPL prompt | |
| val horizontalSpace = screenWidth - sinistral.length - dextral.length | |
| val blankLine = { | |
| val padding = if (dextral.isEmpty) "" else whiteSpace * horizontalSpace + dextral | |
| sinistral + padding + newline | |
| } | |
| } | |
| private val config = Config(width = width, height = height) | |
| private case class Line(content: String, length: Int, private val style: Line.Style) { | |
| override def toString: String = content | |
| def isEmpty: Boolean = content.isEmpty | |
| def render(margin: Int): String = style(this, margin) | |
| } | |
| private object Line { | |
| import scala.io.AnsiColor._ | |
| protected sealed trait Style { | |
| import config.whiteSpace | |
| protected def horizontalSpace = config.horizontalSpace | |
| protected def fill(line: Line, left: Int, right: Int): String = { | |
| whiteSpace * left + line + whiteSpace * right | |
| } | |
| def apply(line: Line, margin: Int): String | |
| } | |
| private object HorizontalRuler extends Style { | |
| private val ansiBegin = RESET.head | |
| private val ansiEnd = RESET.last | |
| private val defaultPattern = Line("-") | |
| def apply(line: Line, margin: Int): String = { | |
| // Provides a default pattern if none was specified | |
| val pattern = if (line.isEmpty) defaultPattern else line | |
| val width = horizontalSpace - margin | |
| val repeats = width / pattern.length | |
| val content = pattern.toString * repeats | |
| var remaining = width - repeats * pattern.length | |
| var ansi = false | |
| var reset = "" | |
| val padding = pattern.toString takeWhile { c => | |
| val continue = remaining > 0 | |
| if (continue) c match { | |
| case `ansiEnd` if ansi => ansi = false | |
| case _ if ansi => // no-op | |
| case `ansiBegin` => ansi = true; reset = RESET | |
| case c if Character.isHighSurrogate(c) => // no-op | |
| case _ => remaining -= 1 | |
| } | |
| continue | |
| } | |
| val left = margin / 2 | |
| val right = margin - left | |
| val l = Line(content + padding + reset, width, LeftAligned) | |
| fill(l, left, right) | |
| } | |
| } | |
| private object FullScreenHorizontalRuler extends Style { | |
| def apply(line: Line, ignored: Int): String = HorizontalRuler(line, 0) | |
| } | |
| private object LeftFlushed extends Style { | |
| def apply(line: Line, ignored: Int): String = { | |
| val left = 0 | |
| val right = horizontalSpace - line.length | |
| fill(line, left, right) | |
| } | |
| } | |
| private object LeftAligned extends Style { | |
| def apply(line: Line, margin: Int): String = { | |
| val left = margin / 2 | |
| val right = horizontalSpace - left - line.length | |
| fill(line, left, right) | |
| } | |
| } | |
| private object Centered extends Style { | |
| def apply(line: Line, ignored: Int): String = { | |
| val margin = horizontalSpace - line.length | |
| val left = margin / 2 | |
| val right = margin - left | |
| fill(line, left, right) | |
| } | |
| } | |
| private object RightAligned extends Style { | |
| def apply(line: Line, margin: Int): String = { | |
| val right = (margin + 1) / 2 | |
| val left = horizontalSpace - right - line.length | |
| fill(line, left, right) | |
| } | |
| } | |
| private object RightFlushed extends Style { | |
| def apply(line: Line, ignored: Int): String = { | |
| val left = horizontalSpace - line.length | |
| val right = 0 | |
| fill(line, left, right) | |
| } | |
| } | |
| private def style(line: String): (String, Style) = line match { | |
| case s if s startsWith "<< " => (s.drop(3), LeftFlushed) | |
| case s if s startsWith "< " => (s.drop(2), LeftAligned) | |
| case s if s startsWith "| " => (s.drop(2), Centered) | |
| case s if s startsWith "> " => (s.drop(2), RightAligned) | |
| case s if s startsWith ">> " => (s.drop(3), RightFlushed) | |
| case s if s startsWith "//" => (s.drop(2), FullScreenHorizontalRuler) | |
| case s if s startsWith "/" => (s.drop(1), HorizontalRuler) | |
| case s: String => (s, LeftAligned) | |
| } | |
| private val ansiEscape = """\\.""".r | |
| private val ansiColor = Map( | |
| 'b' -> BLUE, | |
| 'c' -> CYAN, | |
| 'g' -> GREEN, | |
| 'k' -> BLACK, | |
| 'm' -> MAGENTA, | |
| 'r' -> RED, | |
| 'w' -> WHITE, | |
| 'y' -> YELLOW, | |
| 'B' -> BLUE_B, | |
| 'C' -> CYAN_B, | |
| 'G' -> GREEN_B, | |
| 'K' -> BLACK_B, | |
| 'M' -> MAGENTA_B, | |
| 'R' -> RED_B, | |
| 'W' -> WHITE_B, | |
| 'Y' -> YELLOW_B, | |
| '!' -> REVERSED, | |
| '*' -> BOLD, | |
| '_' -> UNDERLINED | |
| ) | |
| private def ansi(line: String): (String, Int) = { | |
| var drop = 0 | |
| var reset = "" | |
| val content: String = ansiEscape.replaceAllIn(line, m => | |
| m.matched(1) match { | |
| case c if ansiColor.contains(c) => drop += 2; reset = RESET; ansiColor(c) | |
| case 's' => drop += 2; RESET | |
| case '\\' => drop += 1; "\\\\" | |
| case c: Char => "\\\\" + c | |
| } | |
| ) | |
| (content + reset, drop) | |
| } | |
| private val emojiEscape = """:([\w+\-]+):""".r | |
| private lazy val emojis: Map[String, String] = { | |
| Try { | |
| val input = io.Source.fromFile("emoji.txt").getLines | |
| input.map { l => | |
| val a = l.split(' ') | |
| (a(1), a(0)) | |
| }.toMap | |
| } getOrElse Map.empty | |
| } | |
| private def emoji(line: String): (String, Int) = { | |
| var drop = 0 | |
| val content: String = emojiEscape.replaceAllIn(line, m => { | |
| m.group(1) match { | |
| case e if emojis.contains(e) => drop += m.matched.length - 1; emojis(e) | |
| case _ => m.matched | |
| } | |
| }) | |
| (content, drop) | |
| } | |
| def apply(line: String): Line = { | |
| val (l1, lineStyle) = style(line) | |
| val (l2, ansiDrop) = ansi(l1) | |
| val (content, emojiDrop) = emoji(l2) | |
| val length = l1.codePointCount(0, l1.length) - ansiDrop - emojiDrop | |
| Line(content = content, length = length, style = lineStyle) | |
| } | |
| } | |
| // `size` and `maxLength` refer to the dimensions of the slide's last build | |
| private case class Build(content: IndexedSeq[Line], size: Int, maxLength: Int, footer: Line) | |
| private case class Slide(content: IndexedSeq[Line], builds: IndexedSeq[Int], code: IndexedSeq[String]) { | |
| private val maxLength = content.maxBy(_.length).length | |
| def lastBuild: Int = builds.size - 1 | |
| def hasBuild(n: Int): Boolean = builds.isDefinedAt(n) | |
| def build(n: Int, footer: Line): Build = Build(content.take(builds(n)), content.size, maxLength, footer) | |
| } | |
| private case class Deck(slides: IndexedSeq[Slide]) { | |
| private var slideCursor = -1 | |
| private var buildCursor = 0 | |
| private def currentSlideIsDefined: Boolean = slides.isDefinedAt(slideCursor) | |
| private def currentSlide: Slide = slides(slideCursor) | |
| private def footer: Line = { | |
| val sb = StringBuilder.newBuilder | |
| if (slideCounter) { | |
| sb ++= ">> " + (slideCursor + 1) | |
| if (slideTotal) sb ++= "/" + slides.size | |
| sb ++= " " | |
| } | |
| Line(sb.mkString) | |
| } | |
| private def select(slide: Int = slideCursor, build: Int = 0): Option[Build] = { | |
| // "Stops" the cursor one position after/before the last/first slide to avoid | |
| // multiple next/previous calls taking it indefinitely away from the deck | |
| slideCursor = slide.min(slides.size).max(-1) | |
| buildCursor = build | |
| if (currentSlideIsDefined && currentSlide.hasBuild(buildCursor)) { | |
| Some(currentSlide.build(buildCursor, footer)) | |
| } else None | |
| } | |
| def jumpTo(n: Int): Option[Build] = select(slide = n) | |
| def jump(n: Int): Option[Build] = jumpTo(slideCursor + n) | |
| def nextBuild: Option[Build] = select(build = buildCursor + 1) orElse jump(1) | |
| def redrawBuild: Option[Build] = select(build = buildCursor) | |
| def previousBuild: Option[Build] = select(build = buildCursor - 1) orElse { | |
| jump(-1) flatMap { _ => | |
| select(build = currentSlide.lastBuild) | |
| } | |
| } | |
| def lastSlide: Option[Build] = jumpTo(slides.size - 1) | |
| def lastBuild: Option[Build] = jumpTo(slides.size) orElse previousBuild | |
| def runAll: Unit = { | |
| val code = currentSlide.code.mkString("\n") | |
| if (repl.isEmpty) { | |
| Console.err.print(s"No reference to REPL found. Please call with parameter intp=$$intp") | |
| } else if (code.isEmpty) { | |
| Console.err.print("No code for you") | |
| } else { | |
| repl foreach (_.interpret(code)) | |
| } | |
| } | |
| def runCode: Unit = { | |
| val code = currentSlide.code(buildCursor) | |
| if (repl.isEmpty) { | |
| Console.err.print(s"No reference to REPL found. Please call with parameter intp=$$intp") | |
| } else if (code.isEmpty) { | |
| Console.err.print("No code for you") | |
| } else { | |
| repl foreach (_.interpret(code)) | |
| } | |
| } | |
| } | |
| private val helpMessage = """Usage: | |
| | next n > go to next build/slide | |
| | previous p < go back to previous build/slide | |
| | redraw z redraw the current build/slide | |
| | Next N >> go to next slide | |
| | Previous P << go back to previous slide | |
| | i next i n advance i slides | |
| | i previous i p go back i slides | |
| | i go i g go to slide i | |
| | first f |< go to first slide | |
| | last l >| go to last slide | |
| | Last L >>| go to last build of last slide | |
| | run r !! execute code that appears on slide | |
| | blank b blank screen | |
| | help h ? print this help message""".stripMargin | |
| private val repl = Option(intp) | |
| private val deck = Deck(parseFile(input)) | |
| private def parseFile(file: String): IndexedSeq[Slide] = { | |
| Try { | |
| val input = io.Source.fromFile(file).getLines | |
| parse(input) | |
| } getOrElse { | |
| Console.err.print(s"Sorry, could not parse file $file. Quick, say something funny before anyone notices!") | |
| IndexedSeq.empty | |
| } | |
| } | |
| private def parse(input: Iterator[String]): IndexedSeq[Slide] = { | |
| sealed trait Parser { | |
| def switch: Parser | |
| def apply(line: String): (Line, Option[String]) | |
| } | |
| object LineParser extends Parser { | |
| def switch: Parser = CodeParser | |
| def apply(line: String): (Line, Option[String]) = (Line(line), None) | |
| } | |
| object CodeParser extends Parser { | |
| private val regex = { | |
| val wb = "\\b" | |
| val colors = Seq("m", "b", "c", "g", "y") | |
| Seq( | |
| """(?:true|false|null|this)""" | |
| , """[$_]*[A-Z][_$A-Z0-9]*[\w$]*""" | |
| , """(?:contains|exists|filter|filterNot|find|flatMap|flatten|fold|""" + | |
| """forall|foreach|getOrElse|map|orElse)""" | |
| , """(?i)(?:(?:0(?:[0-7]+|X[0-9A-F]+))L?|(?:(?:0|[1-9][0-9]*)""" + | |
| """(?:(?:\.[0-9]+)?(?:E[+\-]?[0-9]+)?F?|L?))|\\.[0-9]+(?:E[+\-]?[0-9]+)?F?)""" | |
| , """(?:abstract|case|catch|class|def|do|else|extends|final|finally|for|""" + | |
| """forSome|if|implicit|import|lazy|match|new|object|override|package|private|""" + | |
| """protected|return|sealed|super|throw|trait|try|type|val|var|while|with|yield)""" | |
| ) map { s => | |
| (wb + s + wb).r | |
| } zip colors | |
| } | |
| def switch: Parser = LineParser | |
| def apply(line: String): (Line, Option[String]) = { | |
| val l = Line("< " + (line /: regex) { case (line, (regex, color)) => | |
| regex.replaceAllIn(line, m => | |
| s"\\\\$color$m\\\\s" | |
| ) | |
| }) | |
| (l, Option(line)) | |
| } | |
| } | |
| case class Acc( | |
| content: IndexedSeq[Line] = IndexedSeq.empty | |
| , builds: IndexedSeq[Int] = IndexedSeq.empty | |
| , deck: IndexedSeq[Slide] = IndexedSeq.empty | |
| , code: IndexedSeq[String] = IndexedSeq.empty | |
| , codeAcc: IndexedSeq[String] = IndexedSeq.empty | |
| , parser: Parser = LineParser | |
| ) { | |
| import config.newline | |
| def switchParser: Acc = copy(parser = parser.switch) | |
| def append(line: String): Acc = { | |
| val (l, c) = parser(line) | |
| copy(content = content :+ l, codeAcc = c.fold(codeAcc)(codeAcc :+ _)) | |
| } | |
| def pushBuild: Acc = copy( | |
| builds = builds :+ content.size | |
| , code = code :+ codeAcc.mkString(newline) | |
| , codeAcc = IndexedSeq.empty | |
| ) | |
| def pushSlide: Acc = { | |
| if (content.isEmpty) { | |
| append("").pushSlide | |
| } else { | |
| val finalBuild = pushBuild | |
| val slide = Slide(content, finalBuild.builds, finalBuild.code) | |
| Acc(deck = deck :+ slide) | |
| } | |
| } | |
| } | |
| val slideSeparator = "---" | |
| val buildSeparator = "--" | |
| val codeDelimiter = "```" | |
| val acc = (Acc() /: input) { (acc, line) => | |
| line match { | |
| case `slideSeparator` => acc.pushSlide | |
| case `buildSeparator` => acc.pushBuild | |
| case `codeDelimiter` => acc.switchParser | |
| case _ => acc.append(line) | |
| } | |
| }.pushSlide | |
| acc.deck | |
| } | |
| private def render(build: Build): String = { | |
| import config._ | |
| val topPadding = (verticalSpace - build.size) / 2 | |
| val bottomPadding = verticalSpace - topPadding - build.content.size | |
| val margin = horizontalSpace - build.maxLength | |
| val sb = StringBuilder.newBuilder | |
| def render(line: Line): StringBuilder = { | |
| sb ++= sinistral | |
| sb ++= line.render(margin) | |
| sb ++= dextral | |
| sb ++= newline | |
| } | |
| sb ++= topRow | |
| sb ++= blankLine * topPadding | |
| build.content foreach render | |
| if (slideCounter && bottomPadding > 0) { | |
| sb ++= blankLine * (bottomPadding - 1) | |
| render(build.footer) | |
| } else { | |
| sb ++= blankLine * bottomPadding | |
| } | |
| sb ++= bottomRow | |
| sb.mkString | |
| } | |
| private def show(build: Option[Build]): Unit = { | |
| if (build.isEmpty) Console.err.print("No slide for you") | |
| build foreach { b => | |
| print(render(b)) | |
| } | |
| } | |
| implicit class Ops(val i: Int) { | |
| def next: Unit = show(deck.jump(i)) | |
| def n: Unit = next | |
| def previous: Unit = show(deck.jump(-i)) | |
| def p: Unit = previous | |
| def go: Unit = show(deck.jumpTo(i - 1)) | |
| def g: Unit = go | |
| } | |
| def next: Unit = show(deck.nextBuild) | |
| def n: Unit = next | |
| def > : Unit = next | |
| def previous: Unit = show(deck.previousBuild) | |
| def p: Unit = previous | |
| def < : Unit = previous | |
| def redraw: Unit = show(deck.redrawBuild) | |
| def z: Unit = redraw | |
| def Next: Unit = 1.next | |
| def N: Unit = Next | |
| def >> : Unit = Next | |
| def Previous: Unit = 1.previous | |
| def P: Unit = Previous | |
| def << : Unit = Previous | |
| def first: Unit = 1.go | |
| def f: Unit = first | |
| def |< : Unit = first | |
| def last: Unit = show(deck.lastSlide) | |
| def l: Unit = last | |
| def >| : Unit = last | |
| def Last: Unit = show(deck.lastBuild) | |
| def L: Unit = Last | |
| def >>| : Unit = Last | |
| def run: Unit = deck.runCode | |
| def r: Unit = run | |
| def !! : Unit = run | |
| def !!! : Unit = deck.runAll | |
| def blank: Unit = print(config.newline * config.screenHeight) | |
| def b: Unit = blank | |
| def help: Unit = print(helpMessage) | |
| def h: Unit = help | |
| def ? : Unit = help | |
| } |
| < \r███████\m╗\r██\m╗ \r██\m╗ \r█████\m╗ \r██████\m╗ \r███████\m╗\r██\m╗ \r███████\m╗\r███████\m╗\r███████\m╗ \r██████\m╗ | |
| < \r██\m╔════╝\r██\m║ \r██\m║\r██\m╔══\r██\m╗\r██\m╔══\r██\m╗\r██\m╔════╝\r██\m║ \r██\m╔════╝\r██\m╔════╝\r██\m╔════╝ ╚════\r██\m╗ | |
| < \r███████\m╗\r███████\m║\r███████\m║\r██████\m╔╝\r█████\m╗ \r██\m║ \r█████\m╗ \r███████\m╗\r███████\m╗ ▄\r███\m╔╝ | |
| < \m╚════\r██\m║\r██\m╔══\r██\m║\r██\m╔══\r██\m║\r██\m╔═══╝ \r██\m╔══╝ \r██\m║ \r██\m╔══╝ ╚════\r██\m║╚════\r██\m║ ▀▀══╝ | |
| < \r███████\m║\r██\m║ \r██\m║\r██\m║ \r██\m║\r██\m║ \r███████\m╗\r███████\m╗\r███████\m╗\r███████\m║\r███████\m║ \r██\m╗ | |
| < \m╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚══════╝╚══════╝╚══════╝╚══════╝╚══════╝ ╚═╝ | |
| < \r███████\m╗ \r█████\m╗ \r███████\m╗\r██\m╗ \r██\m╗ \r██\m╗ | |
| < \r██\m╔════╝\r██\m╔══\r██\m╗\r██\m╔════╝╚\r██\m╗ \r██\m╔╝ \r██\m║ | |
| < \r█████\m╗ \r███████\m║\r███████\m╗ ╚\r████\m╔╝ \r██\m║ | |
| < \r██\m╔══╝ \r██\m╔══\r██\m║╚════\r██\m║ ╚\r██\m╔╝ ╚═╝ | |
| < \r███████\m╗\r██\m║ \r██\m║\r███████\m║ \r██\m║ \r██\m╗ | |
| < \m╚══════╝╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝ | |
| | Scalar conference - Warsaw - 2016/4/16 | |
| > \g@ValentinKasas \_\chttp://kanaka.io | |
| --- | |
| | Who am I ? | |
| * Freelance developer from \r█\w█\b█\s | |
| * Using Scala since mid 2012 | |
| * (\_Extremely\s) modest Shapeless contributor (\g131\s loc) | |
| --- | |
| | What is Shapeless ? | |
| * A library for generic programming in Scala | |
| * Started as an experiment back in 2011 | |
| * Now has \b67\s contributors and \g44k\s loc | |
| --- | |
| | Generic programming | |
| * Programming with types not known beforehand | |
| * Goes beyond classical polymorphism | |
| ╔═ \gGeneric program\s ╗ | |
| ║ ║ | |
| ║ v | |
| * \bType\s ══> \gGeneric representation\s ══> \bType\s | |
| --- | |
| | Heterogeneous Lists | |
| -- | |
| * A "List" containing elements of different types | |
| -- | |
| * Retains the type of each element in its own type | |
| -- | |
| ``` | |
| sealed trait HList | |
| case object HNil extends HList | |
| case class ::[H, T <: HList](head: H, tail: T) extends HList | |
| ``` | |
| --- | |
| | HList examples | |
| ``` | |
| val intStringLong = 42 :: "Scalar" :: 1L :: HNil | |
| type LSB = Long :: String :: Boolean :: HNil | |
| val lsb: LSB = 1L :: "foo" :: false :: HNil | |
| // this wouldn't compile | |
| // val lsb2: LSB = intStringLong | |
| ``` | |
| --- | |
| | Manipulating HLists | |
| -- | |
| * The HList trait defines no method | |
| -- | |
| * Every operation is injected through typeclasses | |
| --- | |
| | Counting the elements of a HList | |
| -- | |
| ``` | |
| case class Size[L <: HList](get: Int) | |
| ``` | |
| -- | |
| ``` | |
| object Size { | |
| ``` | |
| -- | |
| ``` | |
| implicit val hnilSize = Size[HNil](0) | |
| ``` | |
| -- | |
| ``` | |
| implicit def hconsSize[H, T <: HList](implicit tailSize: Size[T]) = | |
| Size[H :: T](1 + tailSize.get) | |
| ``` | |
| -- | |
| ``` | |
| def apply[L <: HList](l: L)(implicit size: Size[L]): Int = size.get | |
| } | |
| ``` | |
| --- | |
| | How does that work ? | |
| -- | |
| < Calling | |
| ``` | |
| Size("foo" :: true :: HNil) | |
| ``` | |
| -- | |
| < Requires an implicit | |
| ``` | |
| Size[String :: Boolean :: HNil] | |
| ``` | |
| -- | |
| < It can be obtained by calling | |
| ``` | |
| hconsSize[String, Boolean :: HNil] | |
| ``` | |
| -- | |
| < Which requires an implicit | |
| ``` | |
| Size[Boolean :: HNil] | |
| ``` | |
| -- | |
| < Obtained via | |
| ``` | |
| hconsSize[Boolean, HNil] | |
| ``` | |
| -- | |
| < Which needs an implicit | |
| ``` | |
| Size[HNil] | |
| ``` | |
| -- | |
| < Which is the type of | |
| ``` | |
| hnilSize | |
| ``` | |
| -- | |
| < So in the end we have | |
| ``` | |
| Size("foo" :: true :: HNil) = hconsSize[String, Boolean :: HNil]( | |
| hconsSize[Boolean, HNil]( | |
| hnilSize)) | |
| = Size[String :: Boolean :: HNil](1 + | |
| Size[Boolean :: HNil](1 + | |
| Size[HNil](0).get).get) | |
| ``` | |
| --- | |
| | Manipulating HList (cont'd) | |
| * Decompose the HList recursively | |
| * Use implicit resolution to derive the whole traversal | |
| --- | |
| | Ok, that's all fun and games, but it's pretty \ruseless\s so far | |
| --- | |
| | Generic : making things useful | |
| -- | |
| * We need a way to transform our classes to their generic representation | |
| -- | |
| * \bGeneric\s does that for us | |
| -- | |
| ``` | |
| case class Person(name: String, age: Int) | |
| val genPerson = Generic[Person] | |
| val homer = Person("Homer Simpson", 42) | |
| val repr = genPerson.to(homer) | |
| val ned = genPerson.from("Ned Flanders" :: 42 :: HNil) | |
| ``` | |
| --- | |
| | Real life use case : computing deltas | |
| * Imagine we want to be able to determine what are the difference between two objects of the same type | |
| * For example, we need to know what have changed in our DB since the last backup | |
| * We need to be able to compute such deltas over a wide variety of classes, that are unrelated | |
| * Of course, doing this by hand for each and every class is not an option | |
| --- | |
| | Our diff representation | |
| ``` | |
| sealed trait Diff[A] | |
| final case class Identical[A](value: A) extends Diff[A] | |
| final case class Different[A](left: A, right: A) extends Diff[A] | |
| object Diff { | |
| def apply[A](left: A, right: A): Diff[A] = | |
| if (left == right) Identical(left) | |
| else Different(left, right) | |
| } | |
| ``` | |
| --- | |
| | A first Delta implementation | |
| ``` | |
| trait SimpleDelta[R <: HList] extends DepFn2[R, R] { | |
| type Out <: HList | |
| } | |
| -- | |
| object SimpleDelta { | |
| type Aux[I <: HList, O <: HList] = SimpleDelta[I]{ type Out = O } | |
| -- | |
| implicit def hnilDelta: Aux[HNil, HNil] = ??? | |
| -- | |
| implicit def hconsDelta[H, T <: HList, DT <: HList] | |
| (implicit tailDelta: Aux[T, DT]) | |
| : Aux[H::T, Diff[H] :: DT] = ??? | |
| } | |
| ``` | |
| --- | |
| | A first Delta implementation | |
| ``` | |
| trait SimpleDelta[R <: HList] extends DepFn2[R, R] { | |
| type Out <: HList | |
| } | |
| object SimpleDelta { | |
| type Aux[I <: HList, O <: HList] = SimpleDelta[I]{ type Out = O } | |
| implicit def hnilDelta: Aux[HNil, HNil] = new SimpleDelta[HNil] { | |
| type Out = HNil | |
| def apply(l: HNil, r: HNil): Out = HNil | |
| } | |
| implicit def hconsDelta[H, T <: HList, DT <: HList] | |
| (implicit tailDelta: Aux[T, DT]) | |
| : Aux[H::T, Diff[H] :: DT] = ??? | |
| } | |
| ``` | |
| --- | |
| | A first Delta implementation | |
| ``` | |
| trait SimpleDelta[R <: HList] extends DepFn2[R, R] { | |
| type Out <: HList | |
| } | |
| object SimpleDelta { | |
| type Aux[I <: HList, O <: HList] = SimpleDelta[I]{ type Out = O } | |
| implicit def hnilDelta: Aux[HNil, HNil] = new SimpleDelta[HNil] { | |
| type Out = HNil | |
| def apply(l: HNil, r: HNil): Out = HNil | |
| } | |
| implicit def hconsDelta[H, T <: HList, DT <: HList] | |
| (implicit tailDelta: Aux[T, DT]) | |
| : Aux[H::T, Diff[H] :: DT] = new SimpleDelta[H :: T]{ | |
| type Out = Diff[H] :: DT | |
| def apply(l: H :: T, r: H :: T) : Out = | |
| Diff(l.head, r.head) :: tailDelta(l.tail, r.tail) | |
| } | |
| } | |
| ``` | |
| --- | |
| | A first Delta implementation | |
| ``` | |
| trait SimpleDelta[R <: HList] extends DepFn2[R, R] { | |
| type Out <: HList | |
| } | |
| object SimpleDelta { | |
| type Aux[I <: HList, O <: HList] = SimpleDelta[I]{ type Out = O } | |
| implicit def hnilDelta: Aux[HNil, HNil] = new SimpleDelta[HNil] { | |
| type Out = HNil | |
| def apply(l: HNil, r: HNil): Out = HNil | |
| } | |
| implicit def hconsDelta[H, T <: HList, DT <: HList] | |
| (implicit tailDelta: Aux[T, DT]) | |
| : Aux[H::T, Diff[H] :: DT] = new SimpleDelta[H :: T]{ | |
| type Out = Diff[H] :: DT | |
| def apply(l: H :: T, r: H :: T) : Out = | |
| Diff(l.head, r.head) :: tailDelta(l.tail, r.tail) | |
| } | |
| def apply[A, R <: HList](l: A, r: A) | |
| (implicit genA: Generic.Aux[A, R], | |
| delta: SimpleDelta[R]) | |
| : delta.Out = | |
| delta(genA.to(l), genA.to(r)) | |
| } | |
| ``` | |
| --- | |
| | Lets try it out | |
| ``` | |
| case class Address(number: Int, street: String, city: String) | |
| case class Character(name: String, age: Int, address: Address) | |
| val homer = Character("Homer Simpson", 42, Address(742, "Evergreen Terrace", "Springfield")) | |
| val ned = Character("Ned Flanders", 42, Address(744, "Evergreen Terrace", "Springfield")) | |
| ``` | |
| --- | |
| | Going further | |
| * That's quite nice, but still a bit coarse-grained | |
| * SimpleDelta doesn't work on nested fields | |
| --- | |
| ``` | |
| trait Delta[R <: HList] extends DepFn2[R, R]{ | |
| type Out <: HList | |
| } | |
| object Delta { | |
| type Aux[R <: HList, O <: HList] = Delta[R]{type Out = O} | |
| implicit def hnilDelta: Aux[HNil, HNil] = new Delta[HNil] { | |
| override type Out = HNil | |
| override def apply(l: HNil, r: HNil): Out = HNil | |
| } | |
| implicit def hconsGenDelta[H, GH <: HList, DH <: HList, T <: HList, DT <: HList] | |
| (implicit genH: Generic.Aux[H, GH], | |
| nested: Delta.Aux[GH, DH], | |
| tailDelta: Delta.Aux[T, DT]) | |
| : Aux[H :: T, DH :: DT] = new Delta[H :: T] { | |
| override type Out = DH :: DT | |
| override def apply(l: H :: T, r: H :: T): Out = | |
| nested(genH.to(l.head), genH.to(r.head)) :: tailDelta(l.tail, r.tail) | |
| } | |
| } | |
| ``` | |
| --- | |
| ``` | |
| trait Delta[R <: HList] extends DepFn2[R, R]{ | |
| type Out <: HList | |
| } | |
| object Delta extends LowPriorityDelta { | |
| type Aux[R <: HList, O <: HList] = Delta[R]{type Out = O} | |
| implicit def hnilDelta: Aux[HNil, HNil] = new Delta[HNil] { | |
| override type Out = HNil | |
| override def apply(l: HNil, r: HNil): Out = HNil | |
| } | |
| implicit def hconsGenDelta[H, GH <: HList, DH <: HList, T <: HList, DT <: HList] | |
| (implicit genH: Generic.Aux[H, GH], | |
| nested: Delta.Aux[GH, DH], | |
| tailDelta: Delta.Aux[T, DT]) | |
| : Aux[H :: T, DH :: DT] = new Delta[H :: T] { | |
| override type Out = DH :: DT | |
| override def apply(l: H :: T, r: H :: T): Out = | |
| nested(genH.to(l.head), genH.to(r.head)) :: tailDelta(l.tail, r.tail) | |
| } | |
| } | |
| trait LowPriorityDelta { | |
| implicit def hconsDelta[H, T <: HList, DT <: HList] | |
| (implicit tailDelta: Delta.Aux[T, DT]) | |
| : Delta.Aux[H :: T, Diff[H] :: DT] = new Delta[H :: T] { | |
| override type Out = Diff[H] :: DT | |
| override def apply(l: H :: T, r: H :: T): Out = | |
| Diff(l.head, r.head) :: tailDelta(l.tail, r.tail) | |
| } | |
| } | |
| ``` | |
| --- | |
| ``` | |
| trait Delta[R <: HList] extends DepFn2[R, R]{ | |
| type Out <: HList | |
| } | |
| object Delta extends LowPriorityDelta { | |
| type Aux[R <: HList, O <: HList] = Delta[R]{type Out = O} | |
| implicit def hnilDelta: Aux[HNil, HNil] = new Delta[HNil] { | |
| override type Out = HNil | |
| override def apply(l: HNil, r: HNil): Out = HNil | |
| } | |
| implicit def hconsGenDelta[H, GH <: HList, DH <: HList, T <: HList, DT <: HList] | |
| (implicit genH: Generic.Aux[H, GH], | |
| nested: Delta.Aux[GH, DH], | |
| tailDelta: Delta.Aux[T, DT]) | |
| : Aux[H :: T, DH :: DT] = new Delta[H :: T] { | |
| override type Out = DH :: DT | |
| override def apply(l: H :: T, r: H :: T): Out = | |
| nested(genH.to(l.head), genH.to(r.head)) :: tailDelta(l.tail, r.tail) | |
| } | |
| def apply[A, R <: HList](l: A, r: A) | |
| (implicit genA: Generic.Aux[A, R], | |
| delta: Delta[R]) | |
| : delta.Out = | |
| delta(genA.to(l), genA.to(r)) | |
| } | |
| trait LowPriorityDelta { | |
| implicit def hconsDelta[H, T <: HList, DT <: HList] | |
| (implicit tailDelta: Delta.Aux[T, DT]) | |
| : Delta.Aux[H :: T, Diff[H] :: DT] = new Delta[H :: T] { | |
| override type Out = Diff[H] :: DT | |
| override def apply(l: H :: T, r: H :: T): Out = | |
| Diff(l.head, r.head) :: tailDelta(l.tail, r.tail) | |
| } | |
| } | |
| ``` | |
| --- | |
| | There is so much more to explore ! | |
| * Coproduct | |
| * Singleton types | |
| * LabelledGeneric | |
| * Extensible records | |
| * Poly | |
| * Typeclass derivation | |
| * etc ... | |
| --- | |
| | \gThanks | |
| --- | |
| | Bonus : Patcher | |
| ``` | |
| trait Patcher[R <: HList, P <: HList] { | |
| def apply(repr: R, patch: P): R | |
| } | |
| trait LowPriorityPatcher { | |
| implicit def hconsPatcher[H, T <: HList, PT <: HList] | |
| (implicit tailPatcher: Patcher[T, PT]): Patcher[H::T, Diff[H]::PT] = new Patcher[H::T, Diff[H]::PT] { | |
| override def apply(repr: H :: T, patch: Diff[H] :: PT): H :: T = { | |
| val head = patch.head match { | |
| case Identical(_) => repr.head | |
| case Different(_, x) => x | |
| } | |
| head :: tailPatcher(repr.tail, patch.tail) | |
| } | |
| } | |
| } | |
| object Patcher extends LowPriorityPatcher{ | |
| def apply[A, R <: HList, P <: HList](value: A, patch: P) | |
| (implicit gen: Generic.Aux[A, R], patcher: Patcher[R, P]): A = | |
| gen.from(patcher(gen.to(value), patch)) | |
| implicit def hnilPatcher: Patcher[HNil, HNil] = new Patcher[HNil, HNil] { | |
| override def apply(repr: HNil, patch: HNil): HNil = HNil | |
| } | |
| implicit def hconsGenPatcher[H, GH <: HList, T <: HList, PH <: HList, PT <: HList] | |
| (implicit genH: Generic.Aux[H, GH], | |
| headPatcher: Patcher[GH, PH], | |
| tailPatcher: Patcher[T, PT]) | |
| : Patcher[H::T, PH::PT] = | |
| new Patcher[H::T, PH::PT] { | |
| override def apply(repr: H :: T, patch: PH :: PT): H :: T = | |
| genH.from(headPatcher(genH.to(repr.head), patch.head)) :: tailPatcher(repr.tail, patch.tail) | |
| } | |
| } | |
| ``` |