Возможный дубликат:
LINQ аналоги в Scala
Я ищу диаграмму, которая показывает эквиваленты в Scala методов LINQ для IEnumerable:
Кто-нибудь знает что-нибудь о такой таблице "translate"?
Я только перечисляю эквиваленты функций из 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)'
Не существует прямого эквивалента некоторых функций, но его довольно легко свернуть самостоятельно. Вот несколько таких функций.
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
}
Присоединиться:
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, полные функции обычно предпочтительнее частичных функций. Таким образом, идиоматическая реализация single и singleOrDefault значение типа Either[Exception, A] вместо 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)
}
Scalaz Zero/mzero не совсем то же самое, что и механизм значений по default в С#. Для получения подробной информации, вы можете обратиться к этому посту, который я написал по этой теме некоторое время назад.
Вы можете использовать шаблон enrich-my-library для достижения того же эффекта, что и методы расширения С#. Обратитесь к этому и этому для деталей.
Я ничего не знаю о С# или 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