Özel Yüksek Seviyeli Fonksiyonlar

Coddy'nin Swift Journey'sinin Mantık ve Akış bölümünün bir parçası — ders 42 / 56.

Artık kendi yüksek mertebeli fonksiyonlarınızı yazabilirsiniz ve bunlar map ile filter'ın yanına tam olarak uyum sağlayacaktır. Kalıp her zaman aynıdır: bir closure parametresi alın, döngü içinde onu çağırın, sonucu döndürün.

extension Array {
    func myMap<T>(_ transform: (Element) -> T) -> [T] {
        var result: [T] = []
        for item in self {
            result.append(transform(item))
        }
        return result
    }
}

[1, 2, 3].myMap { $0 * 10 }       // [10, 20, 30]

Eğer extension'lar (genişletmeler) çok geliyorsa, bunun yerine serbest bir fonksiyon yazın; mantık aynıdır:

func count<T>(_ items: [T], where predicate: (T) -> Bool) -> Int {
    var n = 0
    for item in items where predicate(item) {
        n += 1
    }
    return n
}

Closure'ları bir yerlere aktarabildiğinizde, standart kütüphane sihir gibi görünmeyi bırakır ve kendi başınıza yazabileceğiniz bir dizi desen gibi görünmeye başlar.

Görev

Orta

Diziyi bir kez gezen ve bir demet (tuple) (matched, rest) döndüren bir partition(_ items: [Int], by predicate: (Int) -> Bool) -> ([Int], [Int]) serbest fonksiyonu yazın: koşulu sağlayan öğeler ve geri kalanlar, her ikisi de orijinal sırasıyla.

İki satır okuyun: bir tam sayı min, ardından virgülle ayrılmış bir tam sayı listesi. partition fonksiyonunuzu n > min kontrolü yapan bir koşul (predicate) ile kullanın. Şunları yazdırın:

matched: <...>
rest: <...>

Her liste , ile birleştirilmelidir (yazdırılacak bir şey yoksa boş bırakılmalıdır).

5 / 2,7,3,8,5 girişi için çıktı şöyledir:

matched: 7,8
rest: 2,3,5

Kopya kağıdı

Yüksek seviyeli fonksiyonlar (higher-order functions) tutarlı bir model izler: bir closure kabul eder, onu bir döngü içinde çağırır ve sonucu döndürür.

Bir extension (genişletme) olarak:

extension Array {
    func myMap<T>(_ transform: (Element) -> T) -> [T] {
        var result: [T] = []
        for item in self {
            result.append(transform(item))
        }
        return result
    }
}
[1, 2, 3].myMap { $0 * 10 }  // [10, 20, 30]

Serbest bir fonksiyon (free function) olarak:

func count<T>(_ items: [T], where predicate: (T) -> Bool) -> Int {
    var n = 0
    for item in items where predicate(item) {
        n += 1
    }
    return n
}

Eşleşen ve eşleşmeyen öğelerden oluşan bir tuple döndüren bir partition fonksiyonu:

func partition(_ items: [Int], by predicate: (Int) -> Bool) -> ([Int], [Int]) {
    var matched: [Int] = []
    var rest: [Int] = []
    for item in items {
        if predicate(item) { matched.append(item) }
        else { rest.append(item) }
    }
    return (matched, rest)
}

Kendin dene

let min = Int(readLine()!)!
let nums = readLine()!.components(separatedBy: ",").map { Int($0)! }

// YAPILACAK: partition(_:by:) -> ([Int], [Int]); eşleşenleri ve geri kalanları yazdır