コンパニオンオブジェクトのメソッドを汎用クラスでどのように参照できますか？

Question

私はスカラーにとって少し新しいです。

ケースクラスのコンパニオンオブジェクトのメソッドを一般的な方法で参照するには、どのようにスカラコードを記述しますか？私はいくつかのアプローチを試してみましたが、うまくいかないようです。

以下は動作するサンプルコードですが、手動で各サブクラスを構築する必要があります。例えば

：

class One extends Act[LetterA] { 
    val intro = LetterA.sayhi 
} 

私はむしろのようなものだろう：

class AllOfThem[T <: LettersClass, S <: LettersSingleton] extends Act[T] { 
    val intro = S.sayhi 
} 

を私の作品やコンパイルされ、構文を見つけるように見えることはできません。これを行う適切な方法は何ですか？また、言語でサポートされていないものを探していますか？クラスや特性をどのように構造化しているのかは少しはっきりしていると思いますが、このような行動にどのように取り組むべきかはわかりません。

さらに、私がActクラスのメソッド 'actionTwo'でコメントしたのと似たような方法がありますか？

サンプルコードのリスト：

trait LettersSingleton { 
    def sayhi() : String 
} 

trait LettersClass { 
    val id : Int 
} 

// trait Letters extends LettersClass with LettersSingleton { } 


object LetterA extends LettersSingleton { 
    def sayhi = "Hi I am A" 
} 

object LetterB extends LettersSingleton { 
    def sayhi = "Hi I am B" 
} 

case class LetterA(val id : Int) extends LettersClass { } 
case class LetterB(val id : Int, val name:String) extends LettersClass { } 


abstract class Act[ T <: LettersClass ] { 

    val intro : String 

    def actionOne(a : T) = { 
     println(a.id + " is my id") 
    } 

    def actionTwo() = { 
//  println(T.sayhi) 
    } 
} 

class One extends Act[LetterA] { 
    val intro = LetterA.sayhi 
} 

class Two extends Act[LetterB] { 
    val intro = LetterB.sayhi 
} 

Answer 1

だからあなたは何をしたい正確を行うことはできませんが、一般的に使用される型クラスのパターンと非常に近い得ることができますので、基本的に

//add a type parameter, now you have a typeclass 
trait LettersSingleton[T] { 
    def sayhi() : String 
} 

//LettersClass stays the same 

object Implicits { 
    //implicit classes/objects have to go inside an object 

    //create typeclass instances as implicit objects 
    implicit object LetterASingleton extends LettersSingleton[LetterA] { 
    def sayhi = "Hi I am A" 
    } 

    implicit object LetterBSingleton extends LettersSingleton[LetterB] { 
    def sayhi = "Hi I am B" 
    } 
} 

import Implicits._ 

//add an implicit parameter to the class 
abstract class Act[ T <: LettersClass ](implicit singleton: LettersSingleton[T]) { 

    def actionTwo() = { 
     println(singleton.sayhi) 
    } 
} 

(new Act[LetterA]).actionTwo() //prints "Hi I am A" 
(new Act[LetterB]).actionTwo() //prints "Hi I am B" 

何が起こるかは、新しいAct[T]を作成するたびに、コンパイラは、スコープ内の正しい型の暗黙のオブジェクトまたはvalを探すことによって暗黙のパラメータを埋めようとします。だから、

val a = new Act[LetterA] 

は実際に

val a = new Act[LetterA](LetterASingleton) 

になりますあなたは罰金である、シングルトンは、もはやケースクラスのコンパニオンオブジェクトであることがわかりませんよ。あなたはそれに関係なく、特性を定義しなければならないので、それがコンパニオンオブジェクトであるか、それを実装する他のオブジェクトであるかに大きな違いはありません。