Unfortunately, this doesn’t play so well with another wonderful Scala feature — implicit parameters. It’s often the case that you’ll want to defer resolution of an implicit until a method call, rather than in the scope of object creation. But lazy values cannot take any parameters, implicit or otherwise — so it seems you’re stuck.

Memoized to the rescue! This is a simple helper class that takes care of the caching of a result. Where you might have had the following method with an implicit parameter:

def foo(implicit bar: Bar): ResultType = { ... }

you instead write the following:

private var _foo = Memoized[ResultType]
def foo(implicit bar: Bar) = _foo or { ... }

(complete source below the fold)

That’s it; nothing fancy. This is not a true memoization solution for a function that takes a parameter — check out the memo package in Scalaz for that. But I’ve found it handy, and you might too.

class Memoized[T] {
	private var value: Option[T] = None
	def isEmpty = value.isEmpty
	def isDefined = ! isEmpty
	def get: T = value.get
	def set(newValue: T) { value = Some(newValue) }
	def getOrSet( newValue: => T): T = if (isDefined) get else {
		set(newValue)
		get
	}
	def or( newValue: => T): T = getOrSet(newValue)
	override def toString = value.toString
}
 
object Memoized {
	def apply[T] = new Memoized[T]
}

While we’re at it, somebody oughta write a Markdown plugin for Apple Mail, too. But I think that somebody should be me, so I’ll put off thinking about it for awhile.

While we’re at it, somebody oughta write a Markdown plugin for Apple Mail, too. But I think that somebody should be me, so I’ll put off thinking about it for awhile.

At the moment, it just contains a bare-bones language definition, a template for Ant tasks, and a couple of snippets. I’d like to keep improving it, and would welcome suggestions and modifications.

I’ll be setting up anonymous SVN access one of these days (yeah, right), but for the moment, you can download the bundle directly:

ScalaAWH.tmbundle.zip

The authors show a simple sample program to find and list words ending in “ing” from the standard input:

import sys for line in sys.stdin.readlines(): for word in line.split(): if word.endswith('ing'): print word

and contrast this elegant Python implementation with a variety of monstrosities in other languages. I won’t disagree that the Python is nice, but it seemed like a good little exercise to see whether I can’t produce something almost as good in my languages de jour.

To wit, a Ruby version: for line in ARGF for word in line.split if word.match(/ing$/) then puts word
end end end

which is almost identical to the Python version, though showing Ruby’s not-exactly-pretty fascination with the ‘end’ keyword.

And a Scala version using for-comprehensions. Note to Scala creators: It’s really frustrating having the various ways of executing Scala — as a script, as an object, etc. — all disagree slightly on how the outermost wrapper of a procedure should be formatted.

import scala.io._ object IngWords extends Application { for ( val line <- Source.fromInputStream(System.in).getLines; val word <- line.split(" "); word.endsWith("ing") ) Console.println(word)
}

(Aside: I need a decent syntax highlighting package for WP, it seems.)

The authors show a simple sample program to find and list words ending in “ing” from the standard input:

import sys for line in sys.stdin.readlines(): for word in line.split(): if word.endswith('ing'): print word

and contrast this elegant Python implementation with a variety of monstrosities in other languages. I won’t disagree that the Python is nice, but it seemed like a good little exercise to see whether I can’t produce something almost as good in my languages de jour.

To wit, a Ruby version: for line in ARGF for word in line.split if word.match(/ing$/) then puts word
end end end

which is almost identical to the Python version, though showing Ruby’s not-exactly-pretty fascination with the ‘end’ keyword.

And a Scala version using for-comprehensions. Note to Scala creators: It’s really frustrating having the various ways of executing Scala — as a script, as an object, etc. — all disagree slightly on how the outermost wrapper of a procedure should be formatted.

import scala.io._ object IngWords extends Application { for ( val line <- Source.fromInputStream(System.in).getLines; val word <- line.split(" "); word.endsWith("ing") ) Console.println(word)
}

(Aside: I need a decent syntax highlighting package for WP, it seems.)

Here’s an approximation of it, though I’d love to hear that there’s an even more scala-ish (scalic?) way of doing this:

def eachline(stream : InputStream)(f : String => Unit) { val buf = new BufferedReader( new InputStreamReader( stream ) ) var line = buf.readLine while (line != null) { f(line) line = buf.readLine } }

I use this with a block as so: eachline(System.in) { line => Console.println(line) }

Not bad, but it could be better, I think. Can I tickle this to be a method on streams, instead of a funny little function sitting on its own?

Here’s an approximation of it, though I’d love to hear that there’s an even more scala-ish (scalic?) way of doing this:

def eachline(stream : InputStream)(f : String => Unit) { val buf = new BufferedReader( new InputStreamReader( stream ) ) var line = buf.readLine while (line != null) { f(line) line = buf.readLine } }

I use this with a block as so: eachline(System.in) { line => Console.println(line) }

Not bad, but it could be better, I think. Can I tickle this to be a method on streams, instead of a funny little function sitting on its own?

I have a DTD, describing a bunch of entities, their relationships, and their attributes. I’m going to push data from a set of XML files (adhering to said DTD) into a Ruby-on-Rails savvy database. Wouldn’t be nice to have a simple tool that, in the most general way possible, would, given that DTD:

1. Issue a series of ’script/general model Foo’ commands for the various entities.

2. Populate the Rails migration files appropriately, to manage the creation of the database tables for these entities. That would include inserting :foo_id columns for has-many and has-and-belongs-to-many relationships (though differentiating between the two might require some human supervision), and exploiting the wonderful Red Hill Foreign Key Migrations to create appropriate FK constraints.

3. In addition / as an alternative to using the Red Hill plugin, insert the appropriate has_many / habtm declarations in the model files.

4. And finally, make a script that can read a set of such XML files and fill the database appropriately.

Well, sounds nice to me, anyway. Put it on the someday-maybe list.