Comments on: Real world functional programming in Scala – comparing Java, Clojure and Scala

By: Alexey Tarasevich

Alexey Tarasevich — Fri, 17 Jul 2009 12:18:51 +0000

I think, while you are not using domain-specific macros your Clojure will not look remarkably better then Scala

By: Anders

Anders — Thu, 16 Jul 2009 12:10:32 +0000

I have read tutorial how to write code more functional, i like both Scala and Clojure, but to get developer hocked-on functional development it could be easy way to show how to do it, with the language they all ready use.
IBM have a good introduction.

Functional programming in the Java language
http://www.ibm.com/developerworks/java/library/j-fp.html

mvh Anders

By: Alexander Azarov

Alexander Azarov — Tue, 14 Jul 2009 11:24:23 +0000

I guess you have a mistake in the update. When you don’t write “else”, “if” returns Unit.

By: Arjan Blokzijl

Arjan Blokzijl — Sun, 12 Jul 2009 06:00:11 +0000

Hi Stuart,

My first version also doesn’t handle infinite collections that well, I’ve posted an update to the blog with a version that does some rather crude handling of this using Scala’s Stream class, which implements a lazy list. This version is less generic than the first one, however.

By: Arjan Blokzijl

Arjan Blokzijl — Sat, 11 Jul 2009 06:48:17 +0000

@ASD: You’re correct, that makes the Scala version more concise, and demonstrates my mediocre knowledge of the Scala collections API. As a side note, in the redesigned collections library in the trunk, firstOption is deprecated and its now headOption. About the null checks: in the Clojure version you can pass nil to the function, and the function still works. One of the reasons the apache commons libraries are widely used is that they handle the annoying null checking. I’ve tried to re-create the three Clojure functions in Scala, and in order to have all cases work correctly, the null checking is still required I believe.

By: Stuart Halloway

Stuart Halloway — Sat, 11 Jul 2009 03:56:34 +0000

Cay, Eastsun,

The direct translations are concise, but they lack the generality of the Clojure version. How would you code a Scala version to handle an infinite collection?

By: Eastsun

Eastsun — Thu, 09 Jul 2009 01:11:25 +0000

my scala solution(just a direct translation from the java version)
scala> def indexOfAny(str :String, seq :Array[Char]):Option[Int] = {
| if(str == null || seq == null) None
| else (0 until str.length) find {i => seq.contains(str(i)) }
| }
indexOfAny: (String,Array[Char])Option[Int]

By: Cay Horstmann

Cay Horstmann — Thu, 09 Jul 2009 01:09:57 +0000

This is an interesting exercise, but it might scare away Java refugees who think that everything in Scala must be rethought with a mess of predicates and zipped lists. This particular algorithm translates easily into something that a Java refugee can grasp pretty quickly:

def indexOfAny(str : String, searchChars : Array[Char]) =
if (str == null || searchChars == null) List() else
for { i <- 0 until str.length if (searchChars.contains(str(i))) } yield i

It collects all matching indices, not just the first one.

By: Asd

Asd — Wed, 08 Jul 2009 12:07:27 +0000

D’oh, my Scala could be even shorter:

def indexOfAny(pred:Seq[Any], coll:Seq[Any]) = indexedFilter(pred,coll).firstOption

By: Asd

Asd — Wed, 08 Jul 2009 11:27:39 +0000

The Scala could definitely be shorter. I am omitting the null checks (you didn’t put any type checks in the clojure did you?):

def indexedFilter(pred:Seq[Any], coll:Seq[Any]) =
coll.toList.zipWithIndex.filter(p => pred.contains(p._1)).map(p => p._2)

def indexOfAny(pred:Seq[Any], coll:Seq[Any]) = indexedFilter(pred,coll) match {
case x::xs => Some(x)
case _ => None
}