Tipo sicuro metodo di concatenamento che non consente repliche di operazioni

Question

che voglio implementare il metodo concatenamento come in queste domande:

Best practice to implement Scala trait which supports method chaining;

Scala DSL: method chaining with parameterless methods

Tuttavia, voglio che una volta che una "proprietà" è stato utilizzato, non può più essere utilizzato. Ad esempio, supponiamo di avere una classe "Myclass" per la quale voglio consentire l'uso della definizione "foo" e la definizione "bar" al massimo una volta e non mi interessa il tipo di ritorno finale. Così:

val c = new Myclass 
c foo //ok ! 
c foo bar // ok! 
c foo foo // refuse to compile 
c foo bar foo //refuse to compile 

sto lottando con questo problema per un po 'e la mia visione comincia a diventare sfocata! Ho provato a utilizzare le classi implicite, tuttavia, se hanno bisogno di analizzare gli oggetti che non hanno utilizzato la proprietà associata, e non riesco a trovare come, se hanno bisogno di "consumare" la proprietà rimuovendola dall'oggetto disponibile proprietà, e, ancora, non riesco a trovare come.

Sono attualmente alla ricerca nella API di riflessione, ma è ancora un po 'oscura per me.

L'aiuto sarebbe apprezzato! =)

Answer 1

Vedere Phantom Types In Haskell and Scala da James Iry.

Si potrebbe anche usare type-safe builder:

trait TTrue 
trait TFalse 

@annotation.implicitNotFound(msg = "Cannot call same method twice.") 
sealed abstract class =^=[From, To] 
object =^= { 
    private val singleton_=^= = new =^=[Any, Any]{} 
    implicit def tpEquals[A]: A =^= A = singleton_=^=.asInstanceOf[A =^= A] 
} 

class Myclass[TFoo, TBar, TBuz] private(){ 
    def foo(implicit e: TFoo =^= TFalse) = new Myclass[TTrue, TBar, TBuz] 
    def bar(implicit e: TBar =^= TFalse) = new Myclass[TFoo, TTrue, TBuz] 
    def buz(implicit e: TBuz =^= TFalse) = new Myclass[TFoo, TBar, TTrue] 
} 

object Myclass{ 
    def apply() = new Myclass[TFalse, TFalse, TFalse] 
} 

da utilizzare come questo

scala> Myclass().foo.bar.buz 
res0: Myclass[TTrue,TTrue,TTrue] = Myclass@12ac706a 

scala> Myclass().bar.buz.foo 
res1: Myclass[TTrue,TTrue,TTrue] = Myclass@1e69dff6 

scala> Myclass().foo.buz.foo 
<console>:12: error: Cannot call same method twice. 
       Myclass().foo.buz.foo 
           ^

Answer 2

qui si può ifnd una migliore soluzione:

http://jim-mcbeath.blogspot.fr/2009/09/type-safe-builder-in-scala-part-3.html

(che in realtà si basa sui tipi di fantasma)