class Scala estende {}

Question

Per caso mi sono imbattuto in sintassi strano compilazione Scala:

class Some extends { 
    def hi = println("hi") 
} 

Ragazzi:

• E 'una Scala ufficiale supportato sintassi?
• Significa semplicemente estendere lo Object?
• Si riferisce in qualche modo a "digitazione anatra"?
• Conosci usi interessanti o complicati di questo?

Grazie.

Answer 1

Questa è in realtà una stranezza nella sintassi di Scala. È consentito un extends estraneo prima di iniziare il corpo della classe. Qui ci sono le parti rilevanti del Scala Syntax Summary:

ClassDef   ::= id [TypeParamClause] {ConstrAnnotation} [AccessModifier] 
         ClassParamClauses ClassTemplateOpt 
ClassTemplateOpt ::= ‘extends’ ClassTemplate | [[‘extends’] TemplateBody] 
ClassTemplate  ::= [EarlyDefs] ClassParents [TemplateBody] 

ClassTemplateOpt è tutto ciò che segue i parametri della classe, in questo caso tutto da extends in poi. L'uso normale di extends è la prima alternanza di ClassTemplateOpt, con extends seguita da un genitore o da un inizializzatore anticipato. Tuttavia, un inizializzatore non può contenere uno def e non è possibile interpretare il contenuto delle parentesi come genitore. Non può essere un tipo strutturale perché hi ha una definizione concreta.

La seconda alternanza consente ai parametri della classe di essere immediatamente seguiti dal corpo della classe, senza utilizzare extends. Tuttavia, è consentito un extends opzionale. Il extends nel codice di OP è un esempio di questo, ed è esattamente equivalente allo stesso codice senza opzionale estende:

class Some { 
    def hi = println("hi") 
} 

Answer 2

Sì, questa è la tipizzazione strutturale di Scala o più comunemente nota come digitazione anatra.

object LoudDuck { 
    def quack(): String = "QUACK" 
} 

object QuietDuck { 
    def quack(): String = "quack" 
} 

object CowDuck { 
    def quack(): String = "moo" 
} 

def quackMyDuck(duck: { def quack(): String }) { 
    println(duck.quack()) 
} 

scala>quackMyDuck(LoudDuck) 
QUACK 

scala> 

scala>quackMyDuck(QuietDuck) 
quack 

scala> 

scala>quackMyDuck(CowDuck) 
moo 

È anche possibile dichiarare i tipi di personale con la parola chiave "tipo".

type Duck = { def quack(): String } 

def quackMyDuck(duck: Duck) { 
    println(duck.quack()) 
} 

Answer 3

Questo è in realtà solo un incidente sintattico (credo). Scala consente early definitions che sembrano

class Some extends { 
    ... 
} with ATrait 

in modo che il parser accetta anche class Some extends { ... } che equivale a class Some { ... }(source).