allow view.map to accept unequal sequence sizes

`builtin.map` pads with None rather than failing on mismatches sizes.

IPython/parallel/client/remotefunction.py

@@ -161,13 +161,14 b' class ParallelFunction(RemoteFunction):'
     chunksize : int or None
         The size of chunk to use when breaking up sequences in a load-balanced manner
     ordered : bool [default: True]
-        Whether 
+        Whether the result should be kept in order. If False,
+        results become available as they arrive, regardless of submission order.
     **flags : remaining kwargs are passed to View.temp_flags
     """
 
-    chunksize=None
-    ordered=None
-    mapObject=None
+    chunksize = None
+    ordered = None
+    mapObject = None
     _mapping = False
 
     def __init__(self, view, f, dist='b', block=None, chunksize=None, ordered=True, **flags):
@@ -183,6 +184,7 b' class ParallelFunction(RemoteFunction):'
         client = self.view.client
         
         lens = []
+        maxlen = minlen = -1
         for i, seq in enumerate(sequences):
             try:
                 n = len(seq)
@@ -190,20 +192,23 b' class ParallelFunction(RemoteFunction):'
                 seq = list(seq)
                 sequences[i] = seq
                 n = len(seq)
+            if n > maxlen:
+                maxlen = n
+            if minlen == -1 or n < minlen:
+                minlen = n
             lens.append(n)
         
         # check that the length of sequences match
-        len_0 = lens[0]
-        if min(lens) != len_0:
+        if not self._mapping and minlen != maxlen:
             msg = 'all sequences must have equal length, but have %s' % lens
             raise ValueError(msg)
         
         balanced = 'Balanced' in self.view.__class__.__name__
         if balanced:
             if self.chunksize:
-                nparts = len_0//self.chunksize + int(len_0%self.chunksize > 0)
+                nparts = maxlen // self.chunksize + int(maxlen % self.chunksize > 0)
             else:
-                nparts = len_0
+                nparts = maxlen
             targets = [None]*nparts
         else:
             if self.chunksize:
@@ -222,12 +227,9 b' class ParallelFunction(RemoteFunction):'
         for index, t in enumerate(targets):
             args = []
             for seq in sequences:
-                part = self.mapObject.getPartition(seq, index, nparts)
-                if len(part) == 0:
-                    continue
-                else:
-                    args.append(part)
-            if not args:
+                part = self.mapObject.getPartition(seq, index, nparts, maxlen)
+                args.append(part)
+            if not any(args):
                 continue
 
             if self._mapping:
@@ -235,7 +237,7 b' class ParallelFunction(RemoteFunction):'
                     f = lambda f, *sequences: list(map(f, *sequences))
                 else:
                     f = map
-                args = [self.func]+args
+                args = [self.func] + args
             else:
                 f=self.func
 
@@ -243,9 +245,9 b' class ParallelFunction(RemoteFunction):'
             with view.temp_flags(block=False, **self.flags):
                 ar = view.apply(f, *args)
 
-            msg_ids.append(ar.msg_ids[0])
+            msg_ids.extend(ar.msg_ids)
 
-        r = AsyncMapResult(self.view.client, msg_ids, self.mapObject, 
+        r = AsyncMapResult(self.view.client, msg_ids, self.mapObject,
                             fname=getname(self.func),
                             ordered=self.ordered
                         )