Swift: encapsulation paresseuse de chaînes de map, filter, flatMap

Vous pouvez appliquer les transformations de façon récursive si vous définissez la méthode sur le protocole Sequence (au lieu de Array ). De plus, la contrainte where Element == String n'est pas nécessaire si le paramètre de transformations est défini comme un tableau de (Element) -> [Element] .

extension Sequence {
    func transform(_ transforms: [(Element) -> [Element]]) -> AnySequence<Element> {
        if transforms.isEmpty {
            return AnySequence(self)
        } else {
            return lazy.flatMap(transforms[0]).transform(Array(transforms[1...]))
        }
    }
}

Une autre approche pour réaliser ce que vous voulez:

Modifier : j'ai essayé:

let animals = ["bear", "dog", "cat"]

typealias Transform<Element> = (Element) -> [Element]

let containsA: Transform<String> = { $0.contains("a") ? [$0] : [] }
let plural:    Transform<String> = { [$0 + "s"] }
let double:    Transform<String> = { [$0, $0] }

extension Sequence {
    func transform(_ transforms: [Transform<Element>]) -> AnySequence<Element> {
        return transforms.reduce(AnySequence(self)) {sequence, transform in
            AnySequence(sequence.lazy.flatMap(transform))
        }
    }
}

let transformed = animals.transform([containsA, plural, double])

print(Array(transformed))

Vous étiez très proche de votre objectif, si les deux types de la ligne Erreur étaient assignables, votre code aurait fonctionné.

Une petite modification:

var transformedSequence = transforms.reduce(AnySequence(self.lazy)) {sequence, transform in
    AnySequence(sequence.flatMap(transform))
}
var iterator = transformedSequence.makeIterator()

Ou vous pouvez utiliser réduire ici:

var lazySequence = AnySequence(self.lazy)
for transform in transforms {
    lazySequence = AnySequence(lazySequence.flatMap(transform))
}
var iterator = lazySequence.makeIterator()

Le code entier serait:

( EDIT Modifié pour inclure les suggestions de Martin R.)

var lazyCollection = self.lazy
for transform in transforms {
    lazyCollection = lazyCollection.flatMap(transform) //Error
}
var iterator = lazyCollection.makeIterator()

Pourquoi ne pas intégrer pleinement cela dans le monde fonctionnel? Par exemple, utiliser des chaînes (dynamiques) d'appels de fonction, comme filter (containsA) | map (pluriel) | flatMap (double) .

Avec un peu de code générique réutilisable, nous pouvons réaliser de belles choses.

Commençons par promouvoir certaines opérations de séquence et de séquence paresseuse vers des fonctions libres:

let animals = ["bear", "dog", "cat"]
let newAnimals = lazy(animals) | filter(containsA) | map(plural) | flatMap(double)
print(Array(newAnimals)) // ["bears", "bears", "cats", "cats"]

Notez que les homologues des séquences paresseuses sont plus verbeux que le Séquence , mais cela est dû à la verbosité des méthodes LazySequenceProtocol .

Avec ce qui précède, nous pouvons créer des fonctions génériques qui reçoivent des tableaux et renvoient des tableaux, et ceci type de fonctions sont extrêmement adaptés pour le pipelining, définissons donc un opérateur de pipeline:

typealias Transform<T, U> = (T) -> U

let containsA: Transform<String, Bool> = { $0.contains("a") }
let plural:    Transform<String, String> = { $0 + "s" }
let double:    Transform<String, [String]> = { [$0, $0] }

Maintenant, tout ce dont nous avons besoin est de fournir quelque chose à ces fonctions, mais pour y parvenir, nous besoin d'un peu de peaufinage sur le type Transform :

func |<T, U>(_ arg: T, _ f: (T) -> U) -> U {
    return f(arg)
}

Avec tout ce qui précède en place, les choses deviennent faciles et claires:

func lazy<S: Sequence>(_ arr: S) -> LazySequence<S> {
    return arr.lazy
}

func filter<S: Sequence>(_ isIncluded: @escaping (S.Element) throws -> Bool) -> (S) throws -> [S.Element] {
    return { try $0.filter(isIncluded) }
}

func filter<L: LazySequenceProtocol>(_ isIncluded: @escaping (L.Elements.Element) -> Bool) -> (L) -> LazyFilterSequence<L.Elements> {
    return { $0.filter(isIncluded) }
}

func map<S: Sequence, T>(_ transform: @escaping (S.Element) throws -> T) -> (S) throws -> [T] {
    return { try $0.map(transform) }
}

func map<L: LazySequenceProtocol, T>(_ transform: @escaping (L.Elements.Element) -> T) -> (L) -> LazyMapSequence<L.Elements, T> {
    return { $0.map(transform) }
}

func flatMap<S: Sequence, T: Sequence>(_ transform: @escaping (S.Element) throws -> T) -> (S) throws -> [T.Element] {
    return { try $0.flatMap(transform) }
}

func flatMap<L: LazySequenceProtocol, S: Sequence>(_ transform: @escaping (L.Elements.Element) -> S) -> (L) -> LazySequence<FlattenSequence<LazyMapSequence<L.Elements, S>>> {
    return { $0.flatMap(transform) }
}