13

I just wonder what's the best way to apply a function that returns Void on an Iterable/Collection?

My usecase is:

  • i have a list of Animal objects
  • i want to call on each animal of the list the eat() function

I have a Function<Animal,Void> which calls input.eat();

It turns out that when i call:

Collections2.transform(animalList,eatFunction);

I dont find this very elegant since i'm not looking for a transformation, but only for an application without any output. Worst, it does not even work since the Guava transformations are returning views.

What works fine is:

Lists.newArrayList( Collections2.transform(animalList,eatFunction) );

But it's not elegant. What is the best way to apply a Void function to an Iterable/Collection, in a functional way with Guava?

Edit:

Improve this question
4
  • 7
    Just do a traditional for-each loop and call animal.eat()? If you don't need laziness and don't transform, don't use Guava's tranfsorm at all. Commented Sep 14, 2012 at 15:01
  • I'd like to not use transform, it's what i'm asking for. And it's still more concice and readable to use Guava functional style to apply the call to each object Commented Sep 14, 2012 at 15:06
  • What can I say - it's subjective that applying is more readable in this case. And Guava team members think it's not. Commented Sep 14, 2012 at 15:15
  • 3
    @Sebastien Lorber: Your eat method returns nothing, so from a functional point of view it's pointless to call it. What you're trying to do is to apply functional style to a procedural thing, and that's not supported. Without closures the functional style is Java is too verbose anyway and no wonder that it's support is limited to where it fits best. Commented Sep 14, 2012 at 17:43

3 Answers 3

Reset to default
28

What do you think is more elegant? A plain old for loop: 

for (Animal animal : animalList) animal.eat();

or a "bending a procedural language by writing a procedural operation in a functional style" madness?

static final Function<Animal, Void> eatFunction = new Function<Animal, Void>() { @Override public Void apply(Animal animal) { animal.eat(); return null; // ugly as hell, but necessary to compile } } Lists.newArrayList(Collections2.transform(animalList, eatFunction));

I would vote for the first case.

If you really would like to write your programs in functional style, I would recommend switching to another JVM language.

Scala might be a good alternative for such a case:

animalList.foreach(animal => animal.eat)

or even a shorter variant using the _ placeholder:

animalList.foreach(_.eat)

EDIT:

After trying the code in Eclipse I found out that I had to add the return null statement to the eatFunction, because 1) Void isn't the same as void and 2) it is uninstantiable. That's even more ugly then expected! :)

Also from performance point of view, the invocation of the lazy function by using some copy constructor like above also pointlessly allocates memory. An ArrayList of the same size as the animalList filled only with nulls is created just to be immediately garbage collected.

If you really have a use case where you want to pass around some function objects and dynamically apply them on some collections, I would write my own functional interface and a foreach method:

public interface Block<T> { void apply(T input); } public class FunctionUtils { public static <T> void forEach(Iterable<? extends T> iterable, Block<? super T> block) { for (T element : iterable) { block.apply(element); } } }

Then you can similarly define a void (lower case) function:

static final Block<Animal> eatFunction = new Block<Animal>() { @Override public void apply(Animal animal) { animal.eat(); } };

And use it like this:

FunctionUtils.forEach(animalList, eatFunction); // or with a static import: forEach(animalList, eatFunction);
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Sure, the hacked declarations of the function-like classes are ugly, but in cases which require applying a parameterized action or a series of actions, how does one do that without an implementation of the Visitor pattern and a functor-like object? So there are in fact reasonable use cases for this. The same argument is made against using verbose true function declarations in functional APIs, even by the Guava team themselves, but they implemented Function anyway because they realized there were use cases which called for it, as long as the disadvantages were carefully weighed first.
A usecase for such a need is when you transform one Optional to another and then want to apply a function on the last object of the chain only if it's present
@Natix: You could optimize the ArrayList away by replacing Lists.newArrayList by a DummyUtils.newEmptyStayingCollection implementing add as a no-op (which IMHO doesn't violate the Collection contract).
@maaartinus That's just a horrible hack. :)
@Natix: No that's a zero-capacity non-blocking queue (or set). :D:D
|
7

I was just looking for the same thing and found a Java Consumer interface. In your case it would be:

final Consumer<Animal> action = new Consumer<Animal>() { @Override public void accept(Animal animal) { animal.eat(); } }; ... FluentIterable.from(animals).forEach(action);
Improve this answer

3 Comments

@dzik... from what i can tell, FluentIterable has no forEach function... you probably mean to use .stream() in the last line.
Yes, forEach() is not there in Guava (unfortunately).
Great answer, just a note that this wasn't available at the time the question was first asked in 2012. Today it's probably the most obvious and best answer to the question.
5

As others pointed out, Guava team has a viewpoint that precludes doing this. If you are looking for other functor-like APIs for doing what you want, you could check out Functional Java's Effect, or Jedi's Command class, or Play! framework's F.Callback, or Commons Collections4's Closure [later edit:] or Java 8+ Consumer-based interfaces.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.