retronym’s gists

retronym / traversable-bind.scala

Created December 10, 2009 12:58

First attempt at a Bind[M[X] <: Traversable[X]]

	import collection._
	import collection.generic._

	trait Bind[Z[_]] {
	def bind[A, B](a: Z[A], f: A => Z[B]): Z[B]
	}

	def TraversableBind[M[X] <: Traversable[X]] = new Bind[M] {
	def bind[A, B](r: M[A], f: A => M[B]): M[B] = {
	implicit object cbf extends CanBuildFrom[Traversable[A], B, M[B]] {

retronym / early-initialization.scala

Created December 10, 2009 21:17

Limitations of Early Definitions, a new feature in Scala 2.8

	trait Base {
	val abstractVal: String
	final val useAbstractVal = abstractVal
	}

	{
	class C1 extends Base {
	val abstractVal = "C1.abstractVal"
	}
	assert(new C1().useAbstractVal eq null)

retronym / improved-traversable-bind.scala

Created December 11, 2009 07:16

Bind Type Class instance for scala.collection.traversable. It ain't pretty.

	import collection._
	import collection.generic._

	trait Bind[Z[_]] {
	def bind[A, B](a: Z[A], f: A => Z[B]): Z[B]
	}

	implicit def TraversableBind[M[X] <: Traversable[X]] = new Bind[M] {
	def bind[A, B](r: M[A], f: A => M[B]): M[B] = {
	implicit object cbf extends CanBuildFrom[Traversable[A], B, M[B]] {

retronym / param-name-access-proposal.scala

Created December 12, 2009 06:57

Proposal for exposing parameter names to case class toString or to any method

	trait NamedElementsProduct extends Product {
	def namedElements: Iterator[(String, Any)]
	}

	trait HaskellLikeToString extends NamedElementsProduct {
	override def toString: String = namedElements.map((p) => p._1 + "=" + p._2).mkString(productPrefix + "(", ",", ")")
	}

	case class A(a: Int, b: Int) extends NamedElementsProduct with HaskellLikeToString {
	def namedElements = List(("a", a), ("b", b)).iterator

retronym / chained-implicits.scala

Created December 16, 2009 10:58

How to Chain Implicit Conversions (aka Views) in Scala

	class T {
	val t = "T"
	}

	class U
	class V

	object T {
	implicit def UToT[UU <% U](u: UU) = new T
	}

retronym / type-bounds.scala

Created December 16, 2009 11:17

Tour of Scala Type Bounds

	class A
	class A2 extends A
	class B

	trait M[X]

	//
	// Upper Type Bound
	//
	def upperTypeBound[AA <: A](x: AA): A = x

retronym / implicits-overload-resolution-eta-expansion.scala

Created December 17, 2009 23:11

Investigation for https://lampsvn.epfl.ch/trac/scala/ticket/2811

	object test1 {
	implicit def s2s(s: String): String = "s2s"
	assert(implicitly[String => String].apply("foo") == "foo")
	// Predef.conforms chosen here because it returns the required type (A => A),
	// so no need to try to eta transform the method s2s.
	}

	object test2 {
	locally {
	// s2s is a def inside a block. it seems to be automatically eta transformed to (String => String),

retronym / experimental-curried-dependent-types.scala

Created December 18, 2009 08:32

A foray into dependant types

	type HasTree = { type Tree }


	def r[HT <: HasTree](x: HT)(y: x.Tree) = null
	//r: [HT <: HasTree](x$0:HT)(x$0:<param 1.0>#Tree)Null
	trait T { type Tree }
	//defined trait T
	r(new T{ type Tree = Int})(1)
	/*Exception in thread "main" java.lang.AssertionError: assertion failed: <param 1.0>.type Tree does no longer exist, phase = namer
	at scala.tools.nsc.symtab.Types$adaptToNewRunMap$.adaptToNewRun(Types.scala:3529)

retronym / html-builder-mutable-state.scala

Created December 20, 2009 10:03

Emulating Groovy's Builder in Scala

	class HtmlBuilder {
	var html: NodeSeq = NodeSeq.Empty
	def b(f: (HtmlBuilder) => Unit): Unit = appendNodes(<b>{val b1 = new HtmlBuilder; f(b1); b1.html}</b>)
	def a(href: String)(f: (HtmlBuilder) => Unit): Unit = appendNodes(<a href={href}>{val b1 = new HtmlBuilder; f(b1); b1.html}</a>)
	def text(text: String): Unit = appendNodes(Text(text))
	def appendNodes(nodes: xml.Node*) = html = html ++ nodes
	}

	implicit val builder: HtmlBuilder = new HtmlBuilder
	import builder._

retronym / html-builder-immutable.scala

Created December 20, 2009 11:39

Immutable HTML Builder

	import xml.{Text, Node, NodeSeq}

	class HtmlBuilder {
	var html: NodeSeq = NodeSeq.Empty
	def b(f: (HtmlBuilder) => Seq[Node]): Node = <b>{f(this).toSeq}</b>
	def a(href: String)(f: (HtmlBuilder) => Seq[Node]): Node = <a href={href}>{f(this).toSeq}</a>
	def text(text: String): Text = Text(text)
	}

	val builder: HtmlBuilder = new HtmlBuilder

Jason Zaugg retronym