This post originated from an RSS feed registered with Scala Buzz
by Jeff Heon.
Original Post: The Scala Influence
Feed Title: The Careful Programmer
Feed URL: http://thecarefulprogrammer.blogspot.com/feeds/posts/default
Feed Description: A (starting) collection of my musings about programming. I'll brush more often on Scala related topics since I am currently learning it.
If wish I could have replied something then, but I was just starting to learn Scala, and I couldn't.
Now, I'm still just at the beginning of grokking FP, but I can write about how it almost influenced a bit of Java code I had to write the other day at work.
I had a list of instances of a certain class, and I wanted to get a list made from the result of invoking a certain method on each instance.
We'll pretend I had a Domino class, and I wanted to invoke the method getPoints() on each instances
Here's how I would have done it in Scala: class Domino(p: int) { val points=p }
val dominoes = List(new Domino(1), new Domino(2), new Domino(3))
val points = dominoes map (_.points)
Let's say it's a bit cryptic in Scala and make it a bit more explicit: val points = dominoes map (x => x.points)
I'll skip the Java class definition, but it implements the interface WithPoints, which declares the "Integer getPoints()" method .
Now, just look at what I had to code in Java to get the point list: List points; for (Iterator iter = Dominoes.iterator(); iter.hasNext();) { points.add((WithPoints) iter.next().getPoints()); }
Simple really, but I couldn't get over how much neater (to me) it was in Scala.
Now comes the functional programming influence part. It so happens that I had a transformation library at my disposal in my Java project: org.apache.commons.collections
It's not what I really wanted, but I could use some kind of functional programming style with it. And here's the end result: List dominoes; CollectionUtils.transform(dominoes, new Transformer() { public Object transform(Object domino) { return ((WithPoints) domino).getPoints(); } });
So there, it's not so bad, except that: 1) It transforms my list instead of returning a new list, which is what I wanted. 2) The imperative version is, in my opinion, clearer.
And so this is how functional programming has (almost, but not quite) influenced my coding style so far.
I don't know why you would choose to use Transformer, as it has not been generified. It's a few lines of code to implement what it provides for Java 5. Here's some untested code:
interface F<T, R> { R invoke(T t); } class Utils { public static <T, R> Iterable<R> map(final Iterable<T> iterable, final F<T, R> f) { return new Iterable<R>() { public Iterator<R> iterator() { final Iterator<T> wrapped = iterable.iterator(); return new Iterator<R>() { public boolean hasNext() { return wrapped.hasNext(); } public R next() { return f.invoke(wrapped.next()); } public void remove() { throw null; } } }; } }
Previous Topic
