Swift - Przypisywanie funkcji przeładowanej do zmiennej

Question

Otrzymuję błąd czasu kompilacji, którego odwołanie myFunc jest niejednoznaczne.

func f (s: String) -> String { return "version 1: " + s } 
func f(sourceString s: String) -> String { return "version 2: " + s } 
var myFunc: (String)-> String = f as (sourceString : String)->String 

Jak mogę wyraźnie wskazać każdą wersję przeciążonej funkcji, f, w powyższym przykładzie? Jeśli skomentuję albo deklarację func f, to się skompiluje i będzie działać. Ale chciałbym wiedzieć, jak odwołać się do każdej z funkcji, jeśli obie są zadeklarowane. Dzięki.

Answer 1

Ciekawe to. Nie sądzę, żeby było to możliwe bez robienia czegoś na wzór sugestii @ marcos. Problem ty to możesz „cast away” nazwiska w krotek:

let named_pair = (s: "hello", i: 1) 
named_pair.s // hello 

let anon_pair = named_pair as (String,Int) 
// or anon_pair: (String,Int) = named_pair, if you prefer 
anon_pair.s // no such member 's' 

Teraz załóżmy zdefiniować dwie funkcje identyczne z wyjątkiem jednego nazwał argumenty

func f(s: String, i: Int) { println("_: \(s)") } 
func f(#s: String, #i: Int) { println("s: \(s)") } 

Można połączyć go poprzez krotki z imieniem vs nienazwanych argumenty

f(named_pair) // prints s: hello 
f(anon_pair) // prints _: hello 

// but if you try to call a named argument function with unnamed tuples: 
func g(# s: String, # i: Int) { println("s: \(s)") } 
g(anon_pair) // compiler error 

let h = g 
h(anon_pair) // compiler error 
h(named_pair) // works 

Ale ponieważ można wyrzucać tych nazw można to zrobić:

// compiles and runs just fine... 
(g as (String,Int)->())(anon_pair) 
let k: (String,Int)->() = g 
// as does this 
k(anon_pair) 

I ta możliwość zrobienia tego oznacza, że ​​nie można użyć typu do rozróżnienia funkcji przeciążonej tylko nazwami argumentów, o ile mogę to stwierdzić.

Answer 2

• Liczba argumentów powinna być różna.
• Jeśli liczba argumentów jest taka sama, ich typy danych powinny różnić się od siebie o .

Przykład

 
func f(x : String) -> NSString { 
     return a 
    } 
func f(x : UInt) -> NSString { 
      return "{\(x)}" 
     } 

Answer 3

Nie sądzę, jest to możliwe. Można zadzwonić jeden lub drugi:

println(f("test")) // version 1: test 
println(f(sourceString: "test")) // version 2: test 

Answer 4

nie wiem jak to zrobić dokładnie to, co chcesz, ale może to pomoże:

var myFunc1: (String)-> String = { s in f(sourceString: s) } 
var myFunc2: (String)-> String = { s in f(s) } 

Teraz można nazwać:

let s1 = myFunc1("one") // returns "version 2: one" 
let s2 = myFunc2("two") // returns "version 1: two"