L'applicazione parziale del metodo di protocollo non è consentita

Question

Qualcuno può spiegare questo errore e perché funziona con la chiusura?

Se si modifica "Test" in "A" all'interno della classe "B", tutto funziona in entrambi i casi.

beta 7

protocol Test { 
    func someFunc() -> String 
    var someClosure:() -> Int { get } 
} 

class A: Test { 
    func someFunc() -> String { 
     return "A String" 
    } 

    var someClosure:() -> Int { 
     return { 
      return 2 
     } 
    } 
} 

class B { 
    let a: Test 
    let aString:() -> String 
    let aInt:() -> Int 

    init(a: Test){ 
     self.a = a 

     aString = a.someFunc // Error: Partial application of protocol method is not allowed 
     aInt = a.someClosure // Works fine 
    } 
} 

UPDATE

Anche qui è la mia strana collezione segmentation fault https://gist.github.com/aleksgapp/795a2d428008bdfa4823

Non esitate a commentare, se si dispone di alcuni pensieri su qualsiasi.

Answer 1

Quindi, non posso parlare con perché si comporta in questo modo, ma ho trovato una soluzione alternativa. Prova questo:

aString = { return a.someFunc() } 

Answer 2

UPDATE (grazie a Laszlo Korte)

Da Xcode 7 Beta 2 con Swift 2.0 Note di rilascio: metodi non mutanti di struct, enumerazioni, e protocolli possono ora si applicano parzialmente al loro parametro "auto" .

Ad esempio:

let a: Set<Int> = [1, 2] 
let b: [Set<Int>] = [[1], [3]] 

b.map(a.union) // [[1, 2], [1, 2, 3]] 

RISPOSTA ORIGINALE (corretto per Xcode 6 con Swift 1.2)

protocollo può essere adottato per classe, struttura o censimento. Negli ultimi due casi l'applicazione parziale del metodo di struttura o enumerazione non è consentita e si ottiene "L'applicazione parziale del metodo di protocollo non è consentita" perché a: Test può essere struttura o enumerazione.

Il metodo o la funzione parzialmente applicata è in altre parole curried method or function. Pertanto, quando si scrive a.someFunc si tenta di applicare parzialmente questo metodo, ad esempio ottenere un riferimento alla chiusura che contiene implicitamente riferimento a a. Ma le strutture e le enumerazioni non sono tipi di riferimento, sono tipi di valore e non ci sono riferimenti a a.