hom(X, Y) in scala

Actually, just Y^X, where Y and X are sets.

  def maps[X, Y](xs: Set[X], ys: Set[Y]) = {
    (Set(Map.empty[X,Y])/: xs) { // initially the set is empty; will append mappings for each x
      (set, x) => { // given a set of maps and an x, build a new set, where maps are defined on x
        val pairs = { for (y <- ys; map <- set) yield (map, y) } // will append x->y to each map for each y for given x
        (Set(Map.empty[X,Y]) /: pairs) {
          (newSetOfMaps, p) => {
            val map: Map[X, Y] = p._1
            val y: Y = p._2
            newSetOfMaps + (map + (x->y)) 
          }
        }
      }  
    }
  }

Looks like a little bit too much, but I hope it to be kind of self-explanatory... is it? Is it not?

next scala wtf

Any explanation for scala implementation of iterable concatenation?

def ++ [B >: A](that: Iterable[B]): Collection[B] = {
  val buf = new ArrayBuffer[B]
  this copyToBuffer buf
  that copyToBuffer buf
  buf
}
 

And what's the reason? Why not lazy? Why return Collection? Why not something like the following?

def ++ [B >: A](that: Iterable[B]): Iterable[B] = new Iterable[B] {
  override def elements = this.elements ++ that.elements
}

простор для фантазии

(10x jzw)