Diagram of IEnumerable LINQ equivalents in Scala?

Question

Possible duplicate:
LINQ analogues in Scala

I am looking for a diagram that shows Scala equivalents of LINQ methods for IEnumerable:

• First it’s the head.
• Choose a card
• SingleOrDefault is ... (I don't know)
• ... etc.

Does anyone know anything about such a "translate" table?

Answer 1

I only list function equivalents from Enumerable<A> . This is incomplete at the moment. I will try to update this later with more.

 xs.Aggregate(accumFunc) -> xs.reduceLeft(accumFunc) xs.Aggregate(seed, accumFunc) -> xs.foldLeft(seed)(accumFunc) xs.Aggregate(seed, accumFunc, trans) -> trans(xs.foldLeft(seed)(accumFunc)) xs.All(pred) -> xs.forall(pred) xs.Any() -> xs.nonEmpty xs.Any(pred) -> xs.exists(pred) xs.AsEnumerable() -> xs.asTraversable // roughly xs.Average() -> xs.sum / xs.length xs.Average(trans) -> trans(xs.sum / xs.length) xs.Cast<A>() -> xs.map(_.asInstanceOf[A]) xs.Concat(ys) -> xs ++ ys xs.Contains(x) -> xs.contains(x) ////// xs.Contains(x, eq) -> xs.exists(eq(x, _)) xs.Count() -> xs.size xs.Count(pred) -> xs.count(pred) xs.DefaultIfEmpty() -> if(xs.isEmpty) List(0) else xs // Use 'mzero' (from Scalaz) instead of 0 for more genericity xs.DefaultIfEmpty(v) -> if(xs.isEmpty) List(v) else xs xs.Distinct() -> xs.distinct xs.ElementAt(i) -> xs(i) xs.ElementAtOrDefault(i) -> xs.lift(i).orZero // 'orZero' is from Scalaz xs.Except(ys) -> xs.diff(ys) xs.First() -> xs.head xs.First(pred) -> xs.find(pred) // returns an 'Option' xs.FirstOrDefault() -> xs.headOption.orZero xs.FirstOrDefault(pred) -> xs.find(pred).orZero xs.GroupBy(f) -> xs.groupBy(f) xs.GroupBy(f, g) -> xs.groupBy(f).mapValues(_.map(g)) xs.Intersect(ys) -> xs.intersect(ys) xs.Last() -> xs.last xs.Last(pred) -> xs.reverseIterator.find(pred) // returns an 'Option' xs.LastOrDefault() -> xs.lastOption.orZero xs.LastOrDefault(pred) -> xs.reverseIterator.find(pred).orZero xs.Max() -> xs.max xs.Max(f) -> xs.maxBy(f) xs.Min() -> xs.min xs.Min(f) -> xs.minBy(f) xs.OfType<A>() -> xs.collect { case x: A => x } xs.OrderBy(f) -> xs.sortBy(f) xs.OrderBy(f, comp) -> xs.sortBy(f)(comp) // 'comp' is an 'Ordering'. xs.OrderByDescending(f) -> xs.sortBy(f)(implicitly[Ordering[A]].reverse) xs.OrderByDescending(f, comp) -> xs.sortBy(f)(comp.reverse) Enumerable.Range(start, count) -> start until start + count Enumerable.Repeat(x, times) -> Iterator.continually(x).take(times) xs.Reverse() -> xs.reverse xs.Select(trans) -> xs.map(trans) // For indexed overload, first 'zipWithIndex' and then 'map'. xs.SelectMany(trans) -> xs.flatMap(trans) xs.SequenceEqual(ys) -> xs.sameElements(ys) xs.Skip(n) -> xs.drop(n) xs.SkipWhile(pred) -> xs.dropWhile(pred) xs.Sum() -> xs.sum xs.Sum(f) -> xs.map(f).sum // or 'xs.foldMap(f)'. Requires Scalaz. xs.Take(n) -> xs.take(n) xs.TakeWhile(pred) -> xs.takeWhile(pred) xs.OrderBy(f).ThenBy(g) -> xs.sortBy(x => (f(x), g(x))) // Or: xs.sortBy(f &&& g). '&&&' is from Scalaz. xs.ToArray() -> xs.toArray // Use 'xs.toIndexedSeq' for immutable indexed sequence. xs.ToDictionary(f) -> xs.map(f.first).toMap // 'first' is from Scalaz. When f = identity, you can just write 'xs.toMap'. xs.ToList() -> xs.toList // This returns an immutable list. Use 'xs.toBuffer' if you want a mutable list. xs.Union(ys) -> xs.union(ys) xs.Where(pred) -> xs.filter(pred) xs.Zip(ys, f) -> (xs, ys).zipped.map(f) // When f = identity, use 'xs.zip(ys)' 

---

There is no direct equivalent to some functions, but it is quite easy to collapse by yourself. Here are a few of these features.

Single :

 def single[A](xs: Traversable[A]): A = { if(xs.isEmpty) sys error "Empty sequence!" else if(xs.size > 1) sys error "More than one elements!" else xs.head } 

SingleOrDefault :

 def singleOrDefault[A : Zero](xs: Traversable[A]): A = { if(xs.isEmpty) mzero else if(xs.size > 1) sys error "More than one elements!" else xs.head } 

To join :

 def join[A, B, K, R](outer: Traversable[A], inner: Traversable[B]) (outKey: A => K, inKey: B => K, f: (A, B) => R): Traversable[R] = { for(o <- outer; i <- inner; if outKey(o) == inKey(i)) yield f(o, i) } 

GroupJoin :

 def groupJoin[A, B, K, R](outer: Traversable[A], inner: Traversable[B]) (outKey: A => K, inKey: B => K, f: (A, Traversable[B]) => R): Traversable[R] = { for(o <- outer) yield { val zs = for(i <- inner; if outKey(o) == inKey(i)) yield i f(o, zs) } } 

---

Notes :

1. In the idiomatic Scala, full functions are usually preferable to partial functions. Thus, the idiomatic implementation of single and singleOrDefault is of type Either[Exception, A] instead of A For example, the single implementation is refined here, which returns Either[Exception, A] .

    def single[A](xs: Traversable[A]): Either[Exception, A] = { if(xs.isEmpty) Left(new RuntimeException("Empty sequence!")) else if(xs.size > 1) Left(new RuntimeException("More than one elements!")) else Right(xs.head) } 

2. Scalaz Zero / mzero not quite the same as the default value mechanism in C #. For more information, you can refer to this post, which I wrote on this topic a while ago.

3. You can use the enrich-my-library template to achieve the same effect as the C # extension methods. Refer to this and this for details.

Answer 2

I don't know anything about C # or LINQ, but is that what you are looking for?

 scala> val l = List(1, 2, 3, 4, 5) l: List[Int] = List(1, 2, 3, 4, 5) scala> l.head res0: Int = 1 scala> l.headOption res1: Option[Int] = Some(1) scala> l.map(_.toString) res2: List[java.lang.String] = List(1, 2, 3, 4, 5) scala> l(1) res3: Int = 2 

There is no way to get the item or default value, but this will work:

 scala> scala.util.control.Exception.allCatch.opt(l(5)) getOrElse 0 res4: Int = 0