desc: Tests the RQL `map` function
tests:
    # Type_of
    - js: r.range().map(r.range(), function(x, y){return [x, y]}).type_of()
      py: r.range().map(r.range(), lambda x, y:(x, y)).type_of()
      rb: r.range().map(r.range()){|x, y| [x, y]}.type_of()
      ot: 'STREAM'

    - js: r.range().map(r.expr([]), function(x, y){return [x, y]}).type_of()
      py: r.range().map(r.expr([]), lambda x, y:(x, y)).type_of()
      rb: r.range().map(r.expr([])){|x, y| [x, y]}.type_of()
      ot: 'STREAM'

    - js: r.expr([]).map(r.expr([]), function(x, y){return [x, y]}).type_of()
      py: r.expr([]).map(r.expr([]), lambda x, y:(x, y)).type_of()
      rb: r.expr([]).map(r.expr([])){|x, y| [x, y]}.type_of()
      ot: 'ARRAY'

    # Arity
    - js: r.range(3).map(function(){return 0})
      py: r.range(3).map(lambda:0)
      rb: r.map(r.range(3)){0}
      ot: [0, 0, 0]

    - js: r.range(3).map(r.range(4), function(){return 0})
      py: r.range(3).map(r.range(4), lambda x,y:0)
      rb: r.range(3).map(r.range(4)){0}
      ot: [0, 0, 0]

    - js: r.expr([1]).map(function(x){return [x]})
      py: r.expr([1]).map(lambda x:(x,))
      rb: r.map(r.expr([1])){|x| [x]}
      ot: [[1]]

    - js: r.expr([1]).map(r.expr([1]), function(x, y){return [x, y]})
      py: r.expr([1]).map(r.expr([1]), lambda x, y:(x, y))
      rb: r.map(r.expr([1]), r.expr([1])){|x, y| [x, y]}
      ot: [[1, 1]]

    - js: r.expr([1]).map(r.expr([1]), r.expr([1]), function(x, y, z){return [x, y, z]})
      py: r.expr([1]).map(r.expr([1]), r.expr([1]), lambda x, y, z:(x, y, z))
      rb: r.map(r.expr([1]), r.expr([1]), r.expr([1])){|x, y, z| [x, y, z]}
      ot: [[1, 1, 1]]

    # Incorrect arity
    - js: r.expr([1]).map(function(x, y){return [x, y]})
      py: r.expr([1]).map(lambda x, y:(x, y))
      rb: r.map(r.expr([1])){|x, y| [x, y]}
      ot: err("ReqlQueryLogicError", "The function passed to `map` expects 2 arguments, but 1 sequence was found.", [])

    - js: r.expr([1]).map(r.expr([1]), function(x){return [x]})
      py: r.expr([1]).map(r.expr([1]), lambda x:(x,))
      rb: r.map(r.expr([1]), r.expr([1])){|x| [x]}
      ot: err("ReqlQueryLogicError", "The function passed to `map` expects 1 argument, but 2 sequences were found.", [])

    # Length
    - js: r.range().map(r.expr([]), function(x, y){return [x, y]})
      py: r.range().map(r.expr([]), lambda x, y:(x, y))
      rb: r.map(r.range(), r.expr([])){|x, y| [x, y]}
      ot: []

    - js: r.expr([1, 2]).map(r.expr([1, 2, 3, 4]), function(x, y){return [x, y]})
      py: r.expr([1, 2]).map(r.expr([1, 2, 3, 4]), lambda x, y:(x, y))
      rb: r.map(r.expr([1, 2]), r.expr([1, 2, 3, 4])){|x, y| [x, y]}
      ot: [[1, 1], [2, 2]]

    - js: r.range(2).map(r.range(4), function(x, y){return [x, y]})
      py: r.range(2).map(r.range(4), lambda x, y:(x, y))
      rb: r.map(r.range(2), r.range(4)){|x, y| [x, y]}
      ot: [[0, 0], [1, 1]]

    - js: r.range().map(r.expr([1, 2, 3, 4]), function(x, y){return [x, y]})
      py: r.range().map(r.expr([1, 2, 3, 4]), lambda x, y:(x, y))
      rb: r.map(r.range(), r.expr([1, 2, 3, 4])){|x, y| [x, y]}
      ot: [[0, 1], [1, 2], [2, 3], [3, 4]]

    # Javascript
    - cd: r.range(3).map(r.range(5), r.js("(function(x, y){return [x, y];})"))
      ot: [[0, 0], [1, 1], [2, 2]]

    # Types
    - js: r.range().map(r.expr(1), function(x, y){return [x, y]})
      py: r.range().map(r.expr(1), lambda x, y:(x, y))
      rb: r.map(r.range(), r.expr(1)){|x, y| [x, y]}
      ot: err("ReqlQueryLogicError", "Cannot convert NUMBER to SEQUENCE", [])

    # Range interaction
    - js: r.range().map(r.range(), function(x, y){return [x, y]}).count()
      py: r.range().map(r.range(), lambda x, y:(x, y)).count()
      rb: r.map(r.range(), r.range()){|x, y| [x, y]}.count()
      ot: err("ReqlQueryLogicError", "Cannot use an infinite stream with an aggregation function (`reduce`, `count`, etc.) or coerce it to an array.", [])

    # Prefix notation
    - js: r.map(r.range(3), function(x){return [x]})
      py: r.map(r.range(3), lambda x:(x,))
      rb: r.map(r.range(3), lambda {|x| [x]})
      ot: [[0], [1], [2]]

    - js: r.map(r.range(3), r.row.add(1))
      py: r.map(r.range(3), r.row + 1)
      ot: [1, 2, 3]

    - js: r.map(r.range(3), r.range(5), function(x, y){return [x, y]})
      py: r.map(r.range(3), r.range(5), lambda x, y:(x, y))
      rb: r.map(r.range(3), r.range(5)){|x, y| [x, y]}
      ot: [[0, 0], [1, 1], [2, 2]]