Duck typing in Scala

Scala keeps surprising me. It has much good stuff that F# has. For example, I believed that statically resolved type parameters are unique to F#. Turns out this is not the case. Scala has equivalent feature called "structural types". It has nice syntax compared to F#'s statically resolved type parameters. However, it uses reflection under the hood while F# uses inlining to instantiate functions in-place at compile time. This approach should definitely have awful performance characteristics. Surprisingly, it's not the case:

	object StructuralTypes {
	def time[A](f: => A) = {
	val t0 = System.nanoTime
	val ans = f
	printf("Elapsed: %.3f sec\n", (System.nanoTime - t0) * 1e-9)
	ans
	}
	class My(value: Int){
	def getId = value
	}
	val mys = (1 to 10000000) map (i => new My(i))
	// this fucntion uses a normal static call
	def staticGetId(source: My) = source.getId
	time(
	mys foreach staticGetId
	)
	// this one uses "structural typing" which allows to pass any type
	// which has "getId: Int" function (duck typing)
	def structuralGetId(source: {def getId: Int}) = source.getId
	time(
	mys map structuralGetId
	)
	}

view raw structural_types.scala hosted with ❤ by GitHub

Static call took about 0.5 seconds, "duck typing" call took about 4 seconds. It only 8-10 times slower than static call. Frankly, I expected something like 100x - 1000x degradation. So, it's not as fast as the equivalent feature in F#, but it certainly practically useful in many circumstances.