IEnumerable的LINQ当量斯卡拉的走势？ [英] Chart of IEnumerable LINQ equivalents in Scala?

问题描述

可能重复：结果
的 LINQ类似物斯卡拉

我要寻找的图表，显示等值在LINQ方法斯卡拉的IEnumerable

I am looking for chart which shows equivalents in Scala of LINQ methods for IEnumerable:

• 首先是头部


• 选择是地图


• 的SingleOrDefault是...（我不知道）


• ...等

• First is head
• Select is map
• SingleOrDefault is ... (I don't know)
• ... and so on

有谁知道这样的翻译表中的东西吗？

Does anyone know anything of such "translate" table?

推荐答案

我只上市出的功能从可枚举<等同; A> 。这是不完整的，截至目前。我会尝试更新稍后有更多

I am only listing out the equivalents of functions from Enumerable<A>. This is incomplete as of now. 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 of some functions, but it's fairly easy to roll your own. Here are some such functions.

单：

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
}

加入

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)
}

群组加入

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)
  }
}

---

备注

1. 在惯用Scala中，总功能一般优于部分功能。因此，惯用的实施单和的SingleOrDefault 会产生类型的值为[例外， A] 而不是的。例如，这里是精致落实单返回为[例外，A] 。

1. In idiomatic Scala, total functions are generally preferred over partial functions. So, idiomatic implementation of single and singleOrDefault would produce a value of type Either[Exception, A] instead of A. For example, here is refined implementation of single that 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)
}

Scalaz的零 / mzero 都不如C＃的默认值机制不太一样。有关详细信息，您可以参考这文章中，我写了一篇关于这个话题有一段时间了。

Scalaz's Zero/mzero are not quite same as C#'s default value mechanism. For details, you can refer to this post I wrote on this topic some time back.

您可以使用丰富，我的图书馆模式，实现为C＃的扩展方法相同的效果。参阅这个并的这个了解详情。

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

这篇关于IEnumerable的LINQ当量斯卡拉的走势？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！