Filtering elements of one list by looking at boolean values from the second list

Question

I have two lists of equal length. I want to filter the elements of the first list by looking, if the element, with the same index in the second list, has a true boolean value.

Example:

[1,2,3,4,5]:int list

[true,false,false,true,false]:bool list

Expected result: [1,4]

I know two ways I could achieve this:

1) Write a function that takes two lists. For every element in the first list, that I want to append, check if the current(head) element of the second list is true.

2) Zip the two lists and filter it according to the boolean value.

There should be an easier to go about this, right?

Answer 1

Not really. The cleanest way to do this is probably

List.map (fn (x,y) => x) (List.filter (fn (x,y) => y) (ListPair.zip (L1,L2)))

or

List.map Option.valOf (List.filter Option.isSome (ListPair.map(fn (x,y) => if y then SOME x else NONE) (L1,L2)))

The recursive function isn't too bad, either:

fun foo ([],[]) = []
  | foo ([],L) = raise Fail "Different lengths"
  | foo (L,[]) = raise Fail "Different lengths"
  | foo (x::xs, b::bs) = if b then x::foo(xs,bs) else foo(xs,bs)

Answer 2

Those are pretty much the two options you have; either recurse two lists at once, or combine them into one list of tuples and recurse that. There are several combinators you could use to achieve the latter.

val foo = [1,2,3,4,5];
val bar = [true,false,true,true,false];
val pairs = ListPair.zip (foo, bar)

Once zipped, here are two other ways you can do it:

val result = List.foldr (fn ((n,b), res) => if b then n::res else res) [] pairs
val result = List.mapPartial (fn (n,b) => if b then SOME n else NONE) pairs

Answer 3

Don't know if ML has list comprehension, but if your language has it:

[ x | (x, True) <- zip xs ys ]

Answer 4

The simplest is probably

ListPair.foldr (fn (x,y,z) => if y then x :: z else z) [] (L1, L2)