Implement array function used foldl

foldl.swift

import Foundation

extension Array {
    var empty: Bool {
        return  count == 0
    }

    var nonEmpty: Bool {
        return !empty
    }

    var head: Element? {
        return first
    }

    var tail: [Element]? {
        guard nonEmpty else { return nil }
        return Array(dropFirst())
    }

    /// stack.push
    func push(elem: Element) -> [Element] {
        return self + [elem]
    }

    /// stack.pop
    func pop() -> [Element] {
        return Array(dropLast())
    }

    /// queue.enqueue
    func unshift(elem: Element) -> [Element] {
        return [elem] + self
    }
}

func foldl<A, B>(acc: A, xs: [B], f: (A, B) -> A) -> A {
    if xs.empty {
        return acc
    } else {
        return foldl(f(acc, xs.head!), xs: xs.tail!, f: f)
    }
}

func sum(xs: [Int]) -> Int {
    return foldl(0, xs: xs, f: (+))
}

func maximum(xs: [Int]) -> Int {
    return foldl(0, xs: xs, f: max)
}

func fac(n: Int) -> Int {
    return foldl(1, xs: Array(1...n), f: (*))
}

func reverse<T>(xs: [T]) -> Array<T> {
    return foldl(Array<T>(), xs: xs) { (acc: [T], x: T) -> [T] in
        acc.unshift(x)
    }
}

func filter<T>(xs: [T], predicate: T -> Bool) -> [T] {
    return foldl(Array<T>(), xs: xs) { (acc: [T], x: T) -> [T] in
        if predicate(x) {
            return acc.push(x)
        } else {
            return acc
        }
    }
}

func map<A, B>(xs: [A], f: A -> B) -> [B] {
    return foldl(Array<B>(), xs: xs) { (acc: [B], x: A) -> [B] in
        acc.push(f(x))
    }
}

func flatMap<A, B>(xs: [A], f: A -> [B]) -> [B] {
    return foldl(Array<B>(), xs: xs) { (acc: [B], x: A) -> [B] in
        acc + f(x)
    }
}

/// ---- test

let arr = Array(1...5)

reverse(arr)

filter(arr) {
    $0 % 2 == 0
}

map(arr) {
    "\($0)"
}

flatMap(arr) { (n: Int) -> [Int] in
    [n, n+n]
}

foldr.swift

func foldr<A, B>(xs: [A], acc: B, f: (A, B) -> B) -> B {
    if xs.isEmpty {
        return acc
    } else {
        return f(xs.head!, foldr(xs.tail!, acc: acc, f: f))
    }
}


foldl(0, xs: arr, f: +)
foldr(arr, acc: 0, f: +)