Scala literatürde sık sık, "ibaresi" ama ben amacını anlamadım. üzerinde soyut karşılaşma Örneğin (http://www.artima.com/scalazine/articles/scalas_type_system.html), Martin Odersky yazar

Yöntemleri iletebilirsiniz (veya "fonksiyonlar") parametre olarak verebilirsinizüzerinde soyutonlara. Parametre türleri olarak belirtebilir yaüzerinde soyutonlara.

Başka bir örnek (http://lamp.epfl.ch/~imaier/pub/DeprecatingObserversTR2010.pdf), "Gözlemci Deseni" kağıt, . Küçümseyen gibi

Akarsu birinci sınıf olma değerleri bizim olaydan bir sonucu olabilirüzerinde soyutonlara.

İlk sipariş jenerik okudum "tip", monadlar ise"". Özet yazın kurucular Özet Ve biz de Kek Kalıbı gazetede bu gibi ifadeler görürsünüz. http://www.scala-lang.org/sites/default/files/odersky/ScalableComponent.pdf birçok tür örnekler bir alıntı

Soyut tip üyeleri için esnek bir yol sağlarüzerinde soyutbileşenleri beton türleri.

Hatta taşma ilgili sorular bu terimleri kullanır yığını. [Scala] "can't existentially abstract over parameterized type..."

Yani... ne" gerçekten? "soyut mu

Gündelik kavram oluşumu gibi Cebir, soyut bazı temel özelliklerine göre gruplandırarak birimleri tarafından kurulan ve belirli diğer özellikleri ihmal edilir. Soyutlama, tek bir sembol veya bir sözcüğün benzerlik gösteren altında birleştirilmiş. Bunu biz söylemiyoruzüzerinde soyutfarklılıklar, ama bu gerçekten hareket edeceğizentegrebenzerlikler ile.

Örneğin, sayıları 1, 2 3 toplam alan bir program düşünün:

val sumOfOneTwoThree = 1   2   3

Bu program çok soyut değil, çünkü bu çok ilginç değil. Biz de böyleceüzerinde soyutözel numaralar, tek bir sembol altında sayılar listeler entegre ederek ns:

def sumOf(ns: List[Int]) = ns.foldLeft(0)(_   _)

Ve bir Listesi de özellikle umurumuzda değil. Liste belirli tür bir yapıcı (bir tür alır ve bir tür verir), ama bizüzerinde soyutbizim istediğimiz belirterek, katlanabilir () kurucu:

trait Foldable[F[_]] {
  def foldl[A, B](as: F[A], z: B, f: (B, A) => B): B
}

def sumOf[F[_]](ns: F[Int])(implicit ff: Foldable[F]) =
  ff.foldl(ns, 0, (x: Int, y: Int) => x   y)

List Foldable örtülü örnekleri ve kat biz başka bir şey yapabiliriz.

implicit val listFoldable = new Foldable[List] {
  def foldl[A, B](as: List[A], z: B, f: (B, A) => B) = as.foldLeft(z)(f)
}

val sumOfOneTwoThree = sumOf(List(1,2,3))

Daha fazla ne yapabilirizüzerinde soyuther iki operasyon ve işlenen türü:

trait Monoid[M] {
  def zero: M
  def add(m1: M, m2: M): M
}

trait Foldable[F[_]] {
  def foldl[A, B](as: F[A], z: B, f: (B, A) => B): B
  def foldMap[A, B](as: F[A], f: A => B)(implicit m: Monoid[B]): B =
    foldl(as, m.zero, (b: B, a: A) => m.add(b, f(a)))
}

def mapReduce[F[_], A, B](as: F[A], f: A => B)
                         (implicit ff: Foldable[F], m: Monoid[B]) =
  ff.foldMap(as, f)

Şimdi çok genel bir şey var. Yöntemi mapReduce F katlanabilir ve A bir monoid olduğunu kanıtlamak ya da bir eşlenebilir biz bu verilen F[A] herhangi bir kat olacak. Örneğin:

case class Sum(value: Int)
case class Product(value: Int)

implicit val sumMonoid = new Monoid[Sum] {
  def zero = Sum(0)
  def add(a: Sum, b: Sum) = Sum(a.value   b.value)
}

implicit val productMonoid = new Monoid[Product] {
  def zero = Product(1)
  def add(a: Product, b: Product) = Product(a.value * b.value)
}

val sumOf123 = mapReduce(List(1,2,3), Sum)
val productOf456 = mapReduce(List(4,5,6), Product)

Variçinde soyutlanmışmonoids ve foldables.