ScalaのIEnumerable LINQに相当するチャート

Question

可能性の重複：

• 最初に選択しているヘッド
• です：
  LINQ analogues in Scala

私はIEnumerableをのためのLINQメソッドのScalaでは同等物を示すチャートを探しています地図

SingleOrDefaultは...（私は知らない）

です...ので、

上の誰もが、このような「翻訳」テーブルの何を知っていますか？

Answer 1

は私だけEnumerable<A>からの機能の同等物をリストアップしています。これは今のところ不完全です。私はこれを後でもっと更新しようとします。

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)`. 

---

は、いくつかの機能の直接対応はありませんが、それはあなた自身をロールバックすることはかなり簡単です。このような機能がいくつかあります。

シングル：

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

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

---

注意：慣用Scalaで

1. 、合計関数は、一般部分関数よりも好ましいです。だから、singleとsingleOrDefaultの慣用的な実装ではなくAの種類Either[Exception, A]の値を生成します。たとえば、singleの洗練された実装は、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は、C＃のdefault値メカニズムと全く同じではありません。詳細については、thisの記事を参照してください。

3. enrich-my-libraryパターンを使用すると、C＃の拡張メソッドと同じ効果を得ることができます。詳細は、thisおよびthisを参照してください。スカラ（フルAPIの再実装）のためにLINQ未満のもののために解決なぜ

Answer 2

私はC＃またはLINQについては何も知りませんが、これはあなたが探しているものでしょうか？

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 

は、要素またはデフォルト値を取得するには何の方法もありませんが、これは動作します：

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