filterElement to filter inner sequence ?

[npvisual]

I was wondering if we could add a new function in the SignalProtocol+Sequence.swift file that would allow to filter the elements of a sequence of a signal.

For example :

extension SignalProtocol where Element: Sequence {
    
    /// Filter inner sequence.
    public func filterElement(_ isIncluded: @escaping (Element.Iterator.Element) -> Bool) -> Signal<Element, Error> {
        return self.map { $0.filter(isIncluded) as! Self.Element }
    }
}

... or something along those lines.

Since we already have mapElement, it seems that filterElement is only appropriate (?).

[srdanrasic]

Sure, I think that would be a nice addition. I suggest a slightly different implementation to avoid the force unwrap though:

extension SignalProtocol where Element: Sequence {
    
    /// Filter inner sequence.
    public func filterElement(_ isIncluded: @escaping (Element.Iterator.Element) -> Bool) -> Signal<[Element.Iterator.Element], Error> {
        return self.map { $0.filter(isIncluded) }
    }
}

[npvisual]

Yes, I tried that before but I am getting a fairly complicated return type, rather than the initial Sequence-confirming type that was provided (which could be constrained even more to Collection, I guess).

For example, if I feed it a Dictionary<String, ParticipantDetails>, I get the following after I apply the filter :

'[Dictionary<String, ParticipantDetails>.Iterator.Element]' (aka 'Array<(key: String, value: ParticipantDetails)>')

I don't like the force unwrap either. However if we're trying to make this generic over the Sequence-conforming type shouldn't we return the same type (i.e. a [String: ParticipantDetails] in my case) ?

[srdanrasic]

Ah, good point. Looks like RangeReplaceableCollection declares a filter function that returns Self, so we could do:

extension SignalProtocol where Element: RangeReplaceableCollection {

    public func filterElement(_ isIncluded: @escaping (Element.Element) -> Bool) -> Signal<Element, Error> {
        return self.map { $0.filter(isIncluded) }
    }
}

Which is nice, but Dictionary and Set are not RangeReplaceableCollections. We could implement additional overloads that cover those collections:

extension SignalProtocol {

    public func filterElement<K, V>(_ isIncluded: @escaping (Element.Element) -> Bool) -> Signal<[K: V], Error> where Element == [K: V] {
        return self.map { $0.filter(isIncluded) }
    }
}

extension SignalProtocol {

    public func filterElement<V>(_ isIncluded: @escaping (Element.Element) -> Bool) -> Signal<Set<V>, Error> where Element == Set<V> {
        return self.map { $0.filter(isIncluded) }
    }
}