Scalaに抽象型をアップキャストしないように指示するにはどうすればよいですか？ブルドッグを考慮

Question

：

trait Animal { 
    type Food 

    def defaultFood(): Food 
} 
class Bulldog extends Animal { 
    type Food = Steak 

    ... implementations ... 
} 

（私のシンタックスハイライトがエラーを与えたものの、これは大したことないです）コンパイラのためだけで正常に動作しBulldog.defaultFood()機能：しかし

val bulldog = new Bulldog() 
val df: bulldog.Food = bulldog.defaultFood() 

ブルドッグが別の内部に封入されている場合は、クラスは、すべての地獄が緩んで破る：

class Kennel(val animal: Animal) { 
} 
def getSupply(kennel: Kennel): kennel.animal.Food = { 
    ... implementation ... 
} 

val kennel = new Kennel(bulldog) 
val df2: bulldog.Food = getSupply(kennel) 

Scalaのコンパイラは、コンパイルエラーがスローされます：

type mismatch; 
found : Option[kennel.animal.V] where val kennel: Kennel 
required: bulldog.Food 

現在、この機能はScalaにはありませんか？それを動作させる方法はありますか？

Answer 1

Kennelはパブリックフィールドとしてanimalを公開していないため、コードにコンパイルの問題があります。kennel.animalは解決できません。これはの前にvalを追加することで簡単に解決されます。

Kennelは、Animal以外の、基礎となる動物についての知識がないにもかかわらず、気になるようなことがあるようです。ブルドッグを渡すことは、いくつかの動物を渡すように見えます。

Kennelにいくつかのより多くの種類の情報を追加してみてください：今すぐ

class Kennel[A <: Animal](val animal: A) { } 

def getSupply[A <: Animal](kennel: Kennel[A]): kennel.animal.Food 

val kennel = new Kennel(bulldog) 
val df2: bulldog.Food = getSupply(kennel) 

をKennelはanimal（例えばBulldog）とgetSupplyの正確な種類は、その動物のための食品の正確な型を返すことができる知っています。

trait Steak { 
    override def toString() = "steak" 
} 

trait Animal { 
    type Food 
    def defaultFood(): Food 
} 

class Bulldog extends Animal { 
    type Food = Steak 
    def defaultFood() = new Steak {} 
} 

class Kennel[A <: Animal](val animal: A) 

object Test extends App { 

    def getSupply[A <: Animal](kennel: Kennel[A]): kennel.animal.Food = kennel.animal.defaultFood() 

    val bulldog = new Bulldog() 
    val kennel = new Kennel(bulldog) 
    val df2: bulldog.Food = getSupply(kennel) 

    println(df2) // prints "steak" 
} 

Answer 2

パラメトリック多型（すなわち、型クラス） これをモデル化するためのより良い方法がある：

は、ここにあなたが試すことができる完全に動作するコードです。ここでの主な操作は、あなたが動物を持っており、 にその好きな食べ物のインスタンスを取得する必要があるということです。これをtypeclass にして、特定の動物やその好きな食べ物のインスタンスを提供します。 は、例えば：これはKennelクラスに前方ジェネリック型を伝播するが、理由はScalaの型推論の

@annotation.implicitNotFound(
    "Couldn't confirm that ${Animal}'s favourite food is ${Food}") 
trait DefaultFood[Animal, Food] { def apply(animal: Animal): Food } 
object DefaultFood { 
    /** Helper to easily implement typeclass instances. */ 
    class Impl[Animal, Food](getFood: Animal => Food) 
    extends DefaultFood[Animal, Food] { 
    override def apply(animal: Animal): Food = getFood(animal) 
    } 
} 

class Bulldog 
object Bulldog { 
    type Steak = String // Or whatever. 

    implicit val defaultFood: DefaultFood[Bulldog, Steak] = 
    new DefaultFood.Impl(_ => "Steak") 
} 

class Kennel[Animal, Food](
    animal: Animal)(implicit defaultFood: DefaultFood[Animal, Food]) { 
    def getSupply: Food = defaultFood(animal) 
} 

object Test { 
    val kennel = new Kennel(new Bulldog) // Kennel[Bulldog, Bulldog.Steak] 
} 

、あなたが実際に 種類を綴るする必要はありません。また、特定の 動物とその食べ物についての型クラスインスタンスがない場合、@implicitNotFound注釈は素晴らしい コンパイルエラーメッセージを表示します。 AnimalとFood種類が実際に 動物や食べ物である必要はありませんこと

注意。それはここで使用しているセマンティクスです。 最も一般的な方法で見てみると、このタイプクラフトは実際にはAとBの場合はA => Bタイプの関数の です。