static L lambdaMethodMap(Iterable l, O f) {
  ret map(l, f);
}



static L lambdaMethodMap(O f, Iterable l) {
  ret map(f, l);
}


  static <A, B> L<B> lambdaMethodMap(Iterable<A> l, F1<A, B> f) {
  ret map(l, f);
}



  static <A, B> L<B> lambdaMethodMap(F1<A, B> f, Iterable<A> l) {
  ret map(f, l);
}



static <A, B> L<B> lambdaMethodMap(IF1<A, B> f, Iterable<A> l) {
  ret map(f, l);
}


static <A, B> L<B> lambdaMethodMap(Iterable<A> l, IF1<A, B> f) {
  ret map(l, f);
}


  
static <A, B> L<B> lambdaMapLike lambdaMethodMap(IF1<A, B> f, A[] l) {
  ret map(f, l);
}


static <A, B> L<B> lambdaMethodMap(A[] l, IF1<A, B> f) {
  ret map(l, f);
}


  
static L lambdaMethodMap(O f, O[] l) {
  ret map(f, l);
}


static L lambdaMethodMap(O[] l, O f) {
  ret map(l, f);
}



static L lambdaMethodMap(O f, Map map) {
  ret map(f, map);
}



// map: func(key, value) -> list element
static L lambdaMethodMap(Map map, O f) {
  ret map(map, f);
}



static <A, B, C> L<C> lambdaMethodMap(Map<A, B> map, IF2<A, B, C> f) {
  ret map(map, f);
}



// new magic alias for mapLL - does it conflict?

static <A, B> L<A> lambdaMethodMap(IF1<A, B> f, A data1, A... moreData) {
  ret map(f, data1, moreData);
}