filter + map api design

Question

I am writing a library call that will allow you to filter and map in the same iteration of the loop, this is async/callback style in Java. The problem of course is that for filtering we usually return true/false, but for mapping we need to return the value we want.

So I am thinking of something like this:

(val, v) -> {
   v.include();   // we want to keep this value
   return val * 2;  // the value to map to
}

so the include() method call is like returning true in a typical filter operation. We could add an exclude() method which is returning false.

My question is - is this a good methodology? Are there libraries that do something like this that have a well-understood way of filtering and mapping in the same iteration?

if it's not clear, this would discard the element in the array.

(val, v) -> {
   v.exclude();   
   return null; 
}

another solution would be for them to return a unique key if they want to filter the value out:

(val, v) -> {
   return DISCARD_KEY;  // return a unique key representing discard, like returning false in a typical filter 
}

Answer 1

In most functional programming languages or libraries, you would do this with a flatMap, and use an empty array (or option) if you want to exclude the item, like in JavaScript:

[5, 6, 7, 8, 9, 10].flatMap(x => (x % 2 == 1) ? [] : x / 2)
// outputs [3, 4, 5]

This removes all the odd numbers and halves all the even numbers.

Answer 2

Using Java, I decided to use the java.util.Optional type, which is essentially a wrapper for a value or an absence of a value. If you use this:

Optional.empty(), it's the absence of a value, which means false in our filter scheme.

otherwise I use:

Optional.of(v), where that means true in our filter scheme and the mapped value is v. So the implementation looks something like:

public void done(E e, Optional<T> o) {
  if (o != null && o.isPresent()) {
    this.done(e, o.get());  
  } else {
    this.discard();
    this.done(e, (T) DISCARD_KEY);
  }
}

note that the java.util.Optional wrapper concept could be implemented in literally any language, it's not unique to Java, which is why this answer is pertinent.

Answer 3

I would say this pattern creates some ambiguity. What should the result be, for instance, if the caller does not call either include() OR exclude()? There is no chance to catch this situation statically, so either you have to deal with this ambiguity in your library or throw a runtime exception.

As a suggestion, why not make the return value of the callback an action defining what to do with the element?

If we call what you want to do a Milter (Map + Filter), you might end up with something like this (Don't have a compiler here so this may not be picture-perfect):

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test
{
    public static void main(String[] args)
    {
        Milter.Visitor<Integer> visitor = new Milter.Visitor<Integer>() {
            @Override
            public MilterAction<Integer> visit(Integer element) {
                if (element % 2 == 0) {
                    return MilterAction.exclude();
                } else {
                    return MilterAction.include(element + 2);
                }
            }
        };

        Milter<Integer> oddsPlus2Milter = new Milter<Integer>(visitor);

        List<Integer> sourceList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

        oddsPlus2Milter.run(sourceList).forEach(System.out::println);
    }
}

class Milter<T> {
    public interface Visitor<I> {
        MilterAction<I> visit(I element);
    }

    private Visitor<T> visitor;

    Milter (Visitor<T> visitor) {
        this.visitor = visitor;
    }

    List<T> run(List<T> source) {
        List<T> milteredResult = new ArrayList<T>();
        source.forEach(element -> {
            MilterAction<T> visitResult = this.visitor.visit(element);
            if (visitResult.shouldInclude()) {
                milteredResult.add(visitResult.getValue());
            }
        });

        return milteredResult;
    }
}

class MilterAction<T> {
    public static <I> MilterAction<I> include(I value) {
        return new MilterAction<I>(FilterAction.INCLUDE, value);
    }

    public static <I> MilterAction<I> exclude() {
        return new MilterAction<I>(FilterAction.EXCLUDE, null);
    }

    public enum FilterAction {
        INCLUDE,
        EXCLUDE
    }

    private FilterAction action;
    private T value;

    MilterAction(FilterAction action, T value) {
        this.action = action;
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public boolean shouldInclude() {
        return this.action.equals(FilterAction.INCLUDE);
    }
}

This way, your compiler can ensure for you that all consumer's of the Milter class provide it with a visitor that always returns an appropriate action.

Answer 4

Java has the Optional::stream function, and streams have flatMap. These two together will let you write java code that is very similar to the JavaScript code in https://softwareengineering.stackexchange.com/a/387859/3307

values.stream()
      .flatMap( v -> (include(v) ? Optional.empty() : Optional.of(v*2)).stream() )