| package demo | |
| import scala.tools.nsc.io.AbstractFile | |
| import scala.tools.nsc.{Global, Phase} | |
| import scala.tools.nsc.plugins.{Plugin, PluginComponent} | |
| class DemoPlugin(val global: Global) extends Plugin { | |
| import global._ | |
| override def init(options: List[String], error: String => Unit): Boolean = true |
Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.
A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.
val square : Int => Int = x => x * x
| scala> class Foo { self: Singleton => } | |
| defined class Foo | |
| scala> class Bar extends Foo | |
| <console>:12: error: illegal inheritance; | |
| self-type Bar does not conform to Foo's selftype Foo with Singleton | |
| class Bar extends Foo | |
| ^ | |
| scala> object Bar extends Foo |
| sealed trait RegExp { | |
| def isFinal:Boolean | |
| def acceptsEmpty:Boolean | |
| def shift(prev:Boolean, character:Char):RegExp | |
| def matches(str:String) = | |
| if(str.isEmpty) this.acceptsEmpty | |
| else str.foldLeft(this.shift(true, str.head))(_.shift(false,_)).isFinal | |
| } | |
| object Epsilon extends RegExp { |
Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.
But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.
For starters, here is the sort of thing that SI-2712 affects:
def foo[F[_], A](fa: F[A]): String = fa.toString
| /** | |
| * Solves the n-Queen puzzle in O(n!) | |
| * Let p[r] be the column of the queen on the rth row (must be exactly 1 queen per row) | |
| * There also must be exactly 1 queen per column and hence p must be a permuation of (0 until n) | |
| * There must be n distinct (col + diag) and n distinct (col - diag) for each queen (else bishop attacks) | |
| * @return returns a Iterator of solutions | |
| * Each solution is an array p of length n such that p[i] is the column of the queen on the ith row | |
| */ | |
| def nQueens(n: Int): Iterator[Seq[Int]] = | |
| (0 until n) |
| trait NotSubTypeOf[A, B] // encoding to capture A is not a subtype of B | |
| // Note: We can use infix notation to write `A NotSubTypeOf B` instead of `NotSubTypeOf[A, B]` | |
| // evidence for any two arbitrary types A and B, A is not a subtype of B | |
| implicit def isSub[A, B]: A NotSubTypeOf B = null | |
| // define ambigous implicits to trigger compile error in case A is a subtype of B (or A =:= B) | |
| implicit def iSubAmbig1[A, B >: A]: A NotSubTypeOf B = null | |
| implicit def iSubAmbig2[A, B >: A]: A NotSubTypeOf B = null |
| class NorvigSpellChecker(corpus: String, alphabet: Seq[Char] = 'a' to 'z', level: Int = 2) { | |
| val words = s"[${alphabet.head}-${alphabet.last}]+".r.findAllIn(corpus.toLowerCase).toSeq | |
| val count = words.groupBy(_.toSeq).mapValues(_.size) withDefaultValue 0 | |
| def edit(n: Int)(word: Seq[Char]): Set[Seq[Char]] = n match { | |
| case 0 => Set(word) | |
| case 1 => | |
| val splits = word.indices map word.splitAt | |
| val deletes = splits collect {case (a, b0 +: b1) => a ++ b1} |
| sealed trait Caster[A, B] | |
| case object CastTo extends Caster[Unit, Unit] | |
| case class Ignored[A, B]() extends Caster[A, B] | |
| def cast[A, B]: A =:= B = | |
| (Ignored(): Caster[A, B]) match { | |
| case CastTo | _ => implicitly[B =:= Unit] | |
| } | |
| cast[String, Int]: String =:= Int |