sto cercando di evitare di costrutti come questo:ternario Operatore simile a:?
val result = this.getClass.getSimpleName
if (result.endsWith("$")) result.init else result
Ok, in questo esempio il ramo then
e else
sono semplici, ma si può quelli complessi di immagine. ho costruito il seguente:
object TernaryOp {
class Ternary[T](t: T) {
def is[R](bte: BranchThenElse[T,R]) = if (bte.branch(t)) bte.then(t) else bte.elze(t)
}
class Branch[T](branch: T => Boolean) {
def ?[R] (then: T => R) = new BranchThen(branch,then)
}
class BranchThen[T,R](val branch: T => Boolean, val then: T => R)
class Elze[T,R](elze: T => R) {
def :: (bt: BranchThen[T,R]) = new BranchThenElse(bt.branch,bt.then,elze)
}
class BranchThenElse[T,R](val branch: T => Boolean, val then: T => R, val elze: T => R)
implicit def any2Ternary[T](t: T) = new Ternary(t)
implicit def fct2Branch[T](branch: T => Boolean) = new Branch(branch)
implicit def fct2Elze[T,R](elze: T => R) = new Elze(elze)
}
definito che, posso sostituire il semplice esempio di cui sopra con:
this.getClass.getSimpleName is {s: String => s.endsWith("$")} ? {s: String => s.init} :: {s: String => s}
Ma come posso liberarmi della s: String =>
? Voglio qualcosa del genere:
this.getClass.getSimpleName is {_.endsWith("$")} ? {_.init} :: {identity}
Immagino che il compilatore abbia bisogno di cose extra per inferire i tipi.
Dal momento che in realtà non ho questo nella mia risposta - la ragione per cui' avere problemi è che l'inferenza di tipo funziona meglio da sinistra a destra, ma vincoli i token insieme da destra a sinistra a causa della precedenza degli operatori. Se fai tutte le parole delle tue affermazioni (con la stessa precedenza) e cambi il modo in cui le cose si raggruppano, otterrai l'inferenza che desideri. (Cioè si dovrebbero avere classi 'HasIs',' IsWithCondition', 'ConditionAndTrueCase' che creerebbero parti dell'espressione da sinistra a destra.) –
Ho presumibilmente inconsciamente il modo di inferenza di tipo da sinistra a destra, ma bloccato con la precedenza degli operatori e associatività dei nomi dei metodi, specialmente iniziando con '?' prima di qualsiasi altro char alfanum come nome del metodo prima char e a ':' per associatività sinistra. Quindi devo ripensare ai nuovi nomi dei metodi per ottenere un'inferenza di tipo funzionante da sinistra a destra. Grazie! –