blocks|key|246234|text|我对C#或LINQ一无所知，但这就是你要找的吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246235|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|code-block|syntax|javascript|246236|没有获取元素或缺省值的方法，但这是可行的：|246237|scala>+scala.util.control.Exception.allCatch.opt(l(5))+getOrElse+0
res4:+Int+=+0|246238|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

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

<pre><code>scala&gt; val l = List(1, 2, 3, 4, 5)
l: List[Int] = List(1, 2, 3, 4, 5)

scala&gt; l.head
res0: Int = 1

scala&gt; l.headOption
res1: Option[Int] = Some(1)

scala&gt; l.map(_.toString)
res2: List[java.lang.String] = List(1, 2, 3, 4, 5)

scala&gt; l(1)
res3: Int = 2
</code></pre>

There's no method to get an element or a default, but this will work:

<pre><code>scala&gt; scala.util.control.Exception.allCatch.opt(l(5)) getOrElse 0
res4: Int = 0
</code></pre>

blocks|key|3140238|text|我只列出了Enumerable<A>中的函数的等价物。到目前为止，这还不完整。稍后我会尝试更新更多内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3140239|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+%2B%2B+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+%2B+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)`|code-block|syntax|javascript|3140240|3140241|有些函数没有直接的等价物，但很容易编写自己的函数。下面是一些这样的函数。|3140242|单|BOLD|3140243|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
}|3140244|SingleOrDefault：|3140245|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
}|3140246|加入|3140247|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)
}|3140248|GroupJoin|3140249|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)
++}
}|3140250|3140251|笔记|3140252|3140253|在惯用的Scala中，总体函数通常优先于部分函数。因此，single和singleOrDefault的惯用实现将生成Either[Exception,+A]类型的值，而不是A类型的值。例如，下面是返回Either[Exception,+A]的single的改进实现。|ordered-list-item|3140254|3140255|定义单个序列:+EitherException，A={+if(xs.isEmpty)+A(新序列(“空序列！”))else+if(xs.size+>+1)+Left(新的RuntimeException(“多个元素！”))else+Right(xs.head)+}|3140256|Scalaz的Zero/mzero与C#的default值机制不完全相同。有关详细信息，请参阅我不久前就此主题所写的this文章。|unordered-list-item|3140257|
|3140258|您可以使用丰富我的库模式来实现与C#的扩展方法相同的效果。有关详细信息，请参阅this和C34。H235<代码>G236|3140259|3140260|entityMap|0|LINK|mutability|MUTABLE|url|xs:+Traversable[A]|1|http://missingfaktor.blogspot.com/2011/08/emulating-cs-default-keyword-in-scala.html|2|http://www.artima.com/weblogs/viewpost.jsp?thread=179766^0|5|D|0|0|0|0|0|1|0|0|0|F|0|0|0|2|0|0|0|9|0|0|0|0|2|0|0|S|6|Z|F|1M|K|2E|1|2S|K|3D|6|0|0|17|1|0|0|7|4|C|5|L|7|1M|4|1|0|0|13|4|2|0|0^^$0|@$1|2|3|4|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|21|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|23|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|24|8|@$9|25|A|26|B|P]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|27|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|28|8|@$9|29|A|2A|B|P]]|D|@]|E|$]]|$1|U|3|V|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|2C|8|@$9|2D|A|2E|B|P]]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|2F|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|2G|8|@$9|2H|A|2I|B|P]]|D|@]|E|$]]|$1|12|3|13|5|H|7|2J|8|@]|D|@]|E|$I|J]]|$1|14|3|-4|5|6|7|2K|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2L|8|@$9|2M|A|2N|B|P]]|D|@]|E|$]]|$1|17|3|-4|5|6|7|2O|8|@]|D|@]|E|$]]|$1|18|3|19|5|1A|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]|$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]]|D|@]|E|$]]|$1|1B|3|-4|5|6|7|32|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|33|8|@]|D|@$9|34|A|35|1|36]]|E|$]]|$1|1E|3|1F|5|1G|7|37|8|@$9|38|A|39|B|C]|$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]]|D|@$9|3E|A|3F|1|3G]]|E|$]]|$1|1H|3|1I|5|6|7|3H|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|1G|7|3I|8|@]|D|@$9|3J|A|3K|1|3L]]|E|$]]|$1|1L|3|-4|5|6|7|3M|8|@]|D|@]|E|$]]|$1|1M|3|-4|5|6|7|3N|8|@]|D|@]|E|$]]]|1N|$1O|$5|1P|1Q|1R|E|$1S|1T]]|1U|$5|1P|1Q|1R|E|$1S|1V]]|1W|$5|1P|1Q|1R|E|$1S|1X]]]]

I am only listing out the equivalents of functions from <code>Enumerable&lt;A&gt;</code>. This is incomplete as of now. I will try to update this later with more.

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

<hr>

There is no direct equivalent of some functions, but it's fairly easy to roll your own. Here are some such functions.

Single:

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

SingleOrDefault: 

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

Join:

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

GroupJoin:

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

<hr>

Notes:

<ol>
<li>In idiomatic Scala, total functions are generally preferred over partial functions. So, idiomatic implementation of <code>single</code> and <code>singleOrDefault</code> would produce a value of type <code>Either[Exception, A]</code> instead of <code>A</code>. For example, here is refined implementation of <code>single</code> that returns <code>Either[Exception, A]</code>.

<pre><code>def single[A](xs: Traversable[A]): Either[Exception, A] = {
 if(xs.isEmpty) Left(new RuntimeException("Empty sequence!"))
 else if(xs.size &gt; 1) Left(new RuntimeException("More than one elements!"))
 else Right(xs.head)
}
</code></pre></li>
<li>Scalaz's <code>Zero</code>/<code>mzero</code> are not quite same as C#'s <code>default</code> value mechanism. For details, you can refer to <a href="http://missingfaktor.blogspot.com/2011/08/emulating-cs-default-keyword-in-scala.html" rel="noreferrer">this</a> post I wrote on this topic some time back.</li>
<li>You can use enrich-my-library pattern to achieve the same effect as C#'s extension methods. Refer to <a href="http://www.artima.com/weblogs/viewpost.jsp?thread=179766" rel="noreferrer">this</a> and <a href="https://stackoverflow.com/questions/5410846/how-do-i-apply-the-pimp-my-library-pattern-to-scala-collections">this</a> for details. </li>
</ol>

<blockquote>
 Possible Duplicate: 
 <a href="https://stackoverflow.com/questions/3785413/linq-analogues-in-scala">LINQ analogues in Scala</a> 
</blockquote>



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

<ul>
<li>First is head</li>
<li>Select is map</li>
<li>SingleOrDefault is ... (I don't know)</li>
<li>... and so on</li>
</ul>

Does anyone know anything of such "translate" table?

Chart of IEnumerable LINQ equivalents in Scala?

 可能重复：我正在寻找一个图表，其中显示了用于IEnumerable的LINQ方法的Scala中的等价物：First is headSelect is mapSingleOrDefault is ...(我不知道)...等有人知道这样的“翻译”表吗？

问Scala中IEnumerable LINQ等效项的图表？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala中IEnumerable LINQ等效项的图表？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala中IEnumerable LINQ等效项的图表？
EN