| // Coproduct is extension of Either concept, to N multually exlusive choices | |
| type ISB = Int :+: String :+: Boolean :+: CNil | |
| val isb = Coproduct[ISB]("foo") //> isb : qaaz.ISB = foo | |
| isb.select[Int] //> res0: Option[Int] = None | |
| isb.select[String] //> res1: Option[String] = Some(foo) |
| /** | |
| The Play (2.3) json combinator library is arguably the best in the scala world. However it doesnt | |
| work with case classes with greater than 22 fields. | |
| The following gist leverages the shapeless 'Automatic Typeclass Derivation' facility to work around this | |
| limitation. Simply stick it in a common location in your code base, and use like so: | |
| Note: ** Requires Play 2.3 and shapeless 2.0.0 | |
| // Used as a term `the[T]` yields the unique implicit value of type `T` in the current | |
| // implicit scope, if any. It is a compile time error if there is no such value. Its | |
| // primary advantage over `Predef.implicitly` is that it will preserve any refinement that | |
| // the implicit definition has, resulting in more precisely typed, and hence often more | |
| // useful, values, | |
| scala> trait Foo { type T ; val t: T } | |
| defined trait Foo | |
| scala> implicit val intFoo: Foo { type T = Int } = new Foo { type T = Int ; val t = 23 } |
| /* | |
| The Oracle Java enum Planets example using the Klang DIY Enum, modified to include ordering. | |
| */ | |
| object KlangEnumPlanets extends App { | |
| trait Enum { //DIY enum type | |
| import java.util.concurrent.atomic.AtomicReference //Concurrency paranoia | |
| type EnumVal <: Value //This is a type that needs to be found in the implementing class |
| import scala.language.experimental.macros | |
| import scala.reflect.macros.whitebox | |
| trait Foo[T] | |
| object Foo { | |
| implicit def mkFoo[T]: Foo[T] = macro FooMacros.mkFooImpl[T] | |
| } |
| object Demo { | |
| // A couple of type classes with type members ... | |
| trait Foo[T] { | |
| type A | |
| } | |
| object Foo { | |
| implicit val fooIS = new Foo[Int] { type A = String } | |
| } |
| // An ADT+shapeless as a drop-in replacement for a standard Scala Enumeration. | |
| // | |
| // First the unsafe standard Scala Enumeration ... | |
| // | |
| object ScalaEnumDemo extends App { | |
| // Example from scala.Enumeration scaladoc. Terse ... | |
| object WeekDay extends Enumeration { | |
| type WeekDay = Value | |
| val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value | |
| } |
| import shapeless._ | |
| import scalaz._ | |
| import Scalaz._ | |
| object console extends App { | |
| trait Foo[A] { | |
| type B | |
| def value: B |
tell application "Spotlight" to inject SIMBL into Snow Leopard
I'm going to start off by motivating what I'm doing here. And I want to be clear that I'm not "dissing" the existing collections implementation or anything as unproductively negative as that. It was a really good experiment, it was a huge step forward given what we knew back in 2.8, but now it's time to learn from that experiment and do better. This proposal uses what I believe are the lessons we can learn about what worked, what didn't work, and what is and isn't important about collections in Scala.
This is going to start out sounding really negative and pervasively dismissive, but bear with me! There's a point to all my ranting. I want to be really clear about my motivations for the proposal being the way that it is.