code: def map(source, func, *more_sources, ordered=True, task_limit=None):
      
      if asyncio.iscoroutinefunction(func):
          return amap.raw(
              source, func, *more_sources,
              ordered=ordered, task_limit=task_limit)
      return smap.raw(source, func, *more_sources)
docs: Apply a given function to the elements of one or several
      asynchronous sequences.
  
      Each element is used as a positional argument, using the same order as
      their respective sources. The generation continues until the shortest
      sequence is exhausted. The function can either be synchronous or
      asynchronous (coroutine function).
  
      The results can either be returned in or out of order, depending on
      the corresponding ``ordered`` argument. This argument is ignored if the
      provided function is synchronous.
  
      The coroutines run concurrently but their amount can be limited using
      the ``task_limit`` argument. A value of ``1`` will cause the coroutines
      to run sequentially. This argument is ignored if the provided function
      is synchronous.
  
      If more than one sequence is provided, they're also awaited concurrently,
      so that their waiting times don't add up.
  
      It might happen that the provided function returns a coroutine but is not
      a coroutine function per se. In this case, one can wrap the function with
      ``aiostream.async_`` in order to force ``map`` to await the resulting
      coroutine. The following example illustrates the use ``async_`` with a
      lambda function::
  
          from aiostream import stream, async_
          ...
          ys = stream.map(xs, async_(lambda ms: asyncio.sleep(ms / 1000)))