title: How to use `filter` with multiple iterables, as is supported by `map`?
body: <p><code>filter</code> accepts only one iterable, whereas <code>map</code> accepts a variadic number of iterables. For example, I can exhaust <code>map(operator.add, [1, 2, 3, 4], [1, 2, 2, 4])</code> to get <code>[2, 4, 5, 8]</code>.</p>
  
  <p>I'm looking for a similar mechanism for <code>filter</code>, accepting any predicate and a variable number of iterables. Exhausting <code>filter(operator.eq, [1, 2, 3, 4], [1, 2, 2, 4])</code> causes a <code>TypeError</code> about how <code>filter</code> only accepts 1 iterable, not 2. </p>
  
  <p>My expected output for that particular case is <code>([1, 2, 4], [1, 2, 4])</code>, i.e the pairwise elements that don't satisfy <code>operator.eq</code> are removed. </p>
  
  <p>Here's what I have so far (eager version supporting only 2 iterables instead of N): </p>
  
  <pre><code>from typing import TypeVar, Callable, Iterable
  
  A = TypeVar("A")
  B = TypeVar("B")
  
  def filter_(predicate: Callable[[A, B], bool], iterable1: Iterable[A], iterable2: Iterable[B]) -&gt; (Iterable[A], Iterable[B]):
      filtered_iterable1 = []
      filtered_iterable2 = []
  
      for value1, value2 in zip(iterable1, iterable2):
          if predicate(value1, value2):
              filtered_iterable1.append(value1)
              filtered_iterable2.append(value2)
  
      return filtered_iterable1, filtered_iterable2
  </code></pre>
  
  <p>However my goal is to 1) be able to support N iterables and 2) to have <code>filter_</code> be lazy instead of eager, as is with <code>filter</code>. </p>