Scala tipi sınırları ve varyans

Question

Ben şu davranışın daha iyi anlamak için çalışıyorum:

scala> class C[-A, +B <: A] 
<console>:7: error: contravariant type A occurs in covariant position 
        in type >: Nothing <: A of type B 
     class C[-A, +B <: A] 
        ^

Ancak şu işleri:

scala> class C[-A, +B <% A] 
defined class C 

Ben gelen sorunlar olabileceğini görebilirsiniz Belirli sorunun ne olduğu konusunda net olmamam rağmen, sınırlayıcı ve sınırlı değişkenlerin tersi varyanstır. Bağlantılı bir görünüme bağlı türün neden değiştirilmesinin neden daha iyi olduğu konusunda daha net değilim. Uygulanabilir örtülü dönüşümlerin yokluğunda, iki tanımın büyük ölçüde aynı etkiye sahip olmasını beklerdim. Bir görüşün, bir görüntünün yanlış anlaşılma için daha fazla fırsat sunmasını beklerdim.

Ben fonksiyonları gibi bazı açılardan olan sınıfları tanımlayan Arka plan biraz için

ve ben Muhtemelen

CompositeFunc[-A, +B <: C, -C, +D] (f1 : BaseFunc[A, B], f2 : BaseFunc[C, D]) 
    extends BaseFunc[A, D] 

CompositeFunc[-A, +B <% C, -C, +D] (f1 : BaseFunc[A, B], f2 : BaseFunc[C, D]) 
    extends BaseFunc[A, D] 

gibi bir şey yapmak istedim aslında tercih edilir, ama yine de olur Burada neler olup bittiğini daha iyi anlamak istiyorum.

Answer 1

İlk kolay bir:

class C[-A, +B <% A] 

Bu A veya B varyansını sınırlamak verecek bir konumda değildir, kamuya iade edilmez view yana

class C[-A, +B](implicit view: B => A) 

eşdeğerdir. Örneğin. Başka bir deyişle

class C[-A, +B](val view: B => A) // error: B in contravariant position in view 

, C[-A, +B <% A] kısıtlamaları açısından C[-A, +B] daha, görünüm argüman şey değişmez farklı değil.

---

üst sınır dava C[-A, +B <: A] ben emin değilim. §4.5 Scala Dil Teknik

düşük olan bir tür bildirimi veya tip parametresinin bağlanmış varyansı konum türü beyanı veya parametre varyansı pozisyonunun tersidir belirtmektedir.

B varyansı dahil olmak görünmüyor, ancak genelde üst sınır eşdeğişkin olmalıdır:

trait C[-A, B <: A] // contravariant type A occurs in covariant position 

Bu şekilde bir sorun üretmek gerekir? Ama bu yapının belirli bir davada sağlam olmadığını ispatlayan bir örnekle gelemedim ....kompoze fonksiyonu gelince

---

, neden sadece

class Composite[-A, B, +C](g: A => B, h: B => C) extends (A => C) { 
    def apply(a: A) = h(g(a)) 
} 

DÜZENLEME değil: Örneğin:

import collection.LinearSeq 

def compose[A](g: Traversable[A] => IndexedSeq[A], h: Traversable[A] => LinearSeq[A]) = 
    new Composite(g, h)