Strange, but true! It would help if inject were given a better name (like one that was, maybe, descriptive of what it does).

I think this has totally another reason: Ruby started to be the “better Perl” and was heavily pushed by showing that it really is. The backtick solution of Jules (shell exec) is a typical example of that style of influence. Beside that, Ruby was introduced as “truly object oriented”, targeting at Java, leaving behind Python and especially the Perl OO. Functional style was never really discussed in Ruby communities, unless in niche threads.

OTOH Scala was introduced as being “functional” (beside OO) and all focus was on documenting what that means, how this is applied a.s.o. (among that your article, covering “functional scripting” ).

No wonder, that people grown up with such documentation background end thinking imperatively or object-imperatively in Ruby, whilst they are driven to think functional in Scala.

You have to explicitly think about “functional Ruby” to approach the API from this perspective.

for (f <- myDir.listFiles; if !f.isDrectory) {
// do your thing…
}

I suspect this is partially because most operating systems treat files and directories identically under the surface. Ever wonder why directories need to have the executable bit set in order to allow cd? That’s it.

As to a built-in mechanism, I think the Java 7 NIO² will have something like this. But until then, you can do the following in Scala:

for (f <- myDir.listFiles; if f.isDrectory) {
// do your thing…
}

n = 0
IO.foreach(fname){|line| n += 1}

> If we just go off LoC (Lines of Code), Scala actually wins here. This was a more-than-slightly surprising discovery for me [...]

Could it be that your Scala program is shorter because you know Scala better?

> On the readability score, I think Scala wins here too. The file processing and set creation is all done in a highly functional style (using foldLeft). At least to my eyes, this is a lot easier to follow than the imperative form in Ruby.

I don’t agree with this.

val init = new BloomSet[String](optimalM, optimalK)
val set = src.reset.getLines.foldLeft(init) { _ + _.trim }

I find this less readable than the Ruby version:

set = BloomSet.new(optimal_m, optimal_k)
IO.foreach(fname){|line| set += line.strip}

And less writable too (mostly because I can’t remember the order of arguments to fold).

So while I don’t agree with everything you said, this is a very good article. Keep it up

It’s strange that there isn’t a built-in way to iterate over all files in a directory in either Ruby or Scala (I could be wrong). You almost always want to get the files, not directories.

Ah, very clever! I was unaware of those handy conversion methods. I seem to remember a ClassCastException arising from some dynamic JVM language (not necessarily JRuby) passing objects of the wrong type into a Java method, thus I assumed that the result would be the same here.

In any case, the code given was still not going to work. There certainly were more concise ways that I could have written the Ruby code…mostly because I wasn’t aware of them. However, that doesn’t really affect my point. I was trying to illustrate how Ruby and Scala aren’t really too far separated in concision, contrary to popular perception of statically typed languages. In fact, even if Scala *were* significantly more concise than Ruby for this script, it wouldn’t mean anything. This script was interacting with a Java (actually, Scala) API for most of its functionality. *Naturally* Scala is going to be a little more in its element than Ruby. It’s a credit to JRuby’s Java integration that the script was as concise as it was.

set.store file.to_outputstream

This will take the “out” channel of the File object and present it as an output stream suitable for any Java API. There’s also to_inputstream and to_channel.

Good question. I don’t think so. To be safe, try it like this:

java -Xms8m -cp ${SCALA_HOME}/lib/scala-library.jar HelloWorld

You may have to use HelloWorld$ as the main class if your main object has a companion class.

$ scala -DXms8m HelloWorld
and
$ scala -DXms128m HelloWorld

Is this the right way to set this in scala?