Rewrite code in functional programming

pop.swift

// source : https://github.com/TerryCK/Protocol-Oriented-Programming

extension Collection where Iterator.Element == Int {
    func countOddEven() -> (odd: Int, even: Int) {
        return self.reduce((0, 0)) { (tuple, number) -> (odd: Int, even: Int) in
            return (number % 2 == 0) ?
                                      (tuple.0,    tuple.1 + 1) :
                                      (tuple.0 + 1,tuple.1)
        }
        
        var odd: Int = 0
        var even: Int = 0

        for number in self {
            if number % 2 == 0 {
                even += 1
            } else {
                odd += 1
            }
            
        }
        return (odd, even)
    }
}


// Exercise 3
extension Equatable {
    func matches(array: [Self]) -> Bool {
        return array.filter{$0 == self}.count == array.count

        for element in array where element != self {
            return false
        }
        
        return true
    }
}

// Exercise 4
extension Comparable {
    func lessThan(array: [Self]) -> Bool {
        return array.filter{self < $0}.count == array.count
        for element in array where element <= self {
            return false
        }
        
        return true
    }
}

// Exercise 5
extension Collection where Iterator.Element: Equatable {   
    func myContain(element: Iterator.Element) -> Bool {
        return self.filter{element == $0}.count > 0
        for item in self where item == element {
            return true
        }
        return false
    }
}

// Exercise 8
extension Collection where Self.Element: BinaryInteger {
    func number(of element: Self.Element) -> Int {
        return self.filter{$0 == element}.count
        var count = 0
        for item in self where item == element {
            count += 1
        }
        return count
    }
}

// Exercise 8-2
extension BinaryInteger {
    func countInterger(of elements: [Self]) -> Int {
        let ref: Character = Character(String(describing: self))
        
        return elements.map {(element) -> Int in
            return String(describing: element).reduce(0, { (count, char) -> Int in
                return (ref == char) ? count + 1 : count
            })
        }.reduce(0, +)
        
        var count = 0
        for element in elements {
            String(describing: element).forEach { (charater) in
                count += charater == ref ? 1 : 0
            }
        }
        return count
    }
}