स्कैला में आईनेमेरेबल LINQ समकक्षों का चार्ट?

Question

संभव डुप्लिकेट:
LINQ analogues in Scala

मैं चार्ट जो IEnumerable के लिए LINQ तरीकों में से स्काला में समकक्ष से पता चलता रहा हूँ:

• सबसे पहले है सिर
• चयन है मानचित्र
• 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) 
    } 
} 

---

नोट्स:

1. मुहावरेदार स्काला में कुल कार्यों आम तौर पर आंशिक कार्यों से अधिक पसंद कर रहे हैं। इसलिए, single और singleOrDefault का बेवकूफ कार्यान्वयन के बजाय 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 सी # के default मूल्य तंत्र के रूप में काफी ही नहीं हैं। विवरण के लिए, आप कुछ समय पहले इस विषय पर लिखे गए this पोस्ट का उल्लेख कर सकते हैं।

3. आप सी # के विस्तार विधियों के समान प्रभाव प्राप्त करने के लिए समृद्ध-पुस्तकालय पैटर्न का उपयोग कर सकते हैं। विवरण के लिए this और this देखें।

Answer 2

मुझे सी # या 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