Swiftエンジニアの高階関数実践 ref: http://qiita.com/shoheiyokoyama/items/8c855e8f5caf7d136027

file0.hs

applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

file1.txt

Prelude> applyTwice (+3) 10
16
Prelude> applyTwice (3:) [2]
[3, 3, 2]

file10.swift

let repeateString = curry { (count: Int, element: String) -> [String] in
    Array(repeating: element, count: count)
}

let threeArray = repeateString(3)

threeArray("Swift") // ["Swift", "Swift", "Swift"]
threeArray("Haskell") // ["Haskell", "Haskell", "Haskell"]

file2.hs

map :: (a -> b) -> [a] -> [b]
map _ [] = []
map f (x:xs) = f x : map f xs

file3.txt

Prelude> map (+2) [1, 2, 3, 4]
[3, 4, 5, 6]
Prelude>　map (replicate 3) [1..3]
[[1,1,1],[2,2,2][3,3,3]]

file4.hs

zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = f x y : zipWith' f xs ys

file5.txt

Prelude> zipWith' (+3) 10
16
Prelude> zipWith' (3:) [2]
[3, 3, 2]

file6.swift

func double(_ array: [Int]) -> [Int] { 
    var result: [Int] = [] 
    for x in array { 
        result.append( x * 2) 
    } 
    return result 
}

double([3, 4]) // [6, 8]

file7.swift

func map<Element, T>(_ array: [Element], transform: (Element) -> T) -> [T] {
    var result: [T] = []
    for x in array {
        result.append(transform(x))
    }
    return result
}

map([2, 3]) { $0 * 2 } // [4, 6]
map([8, 4]) { $0 / 2 } // [4, 2]
map(["Swit", "swif"]) { $0 + "t" } // ["Swift", "swift"]

file8.swift

func filter<Element>(_ array: [Element], includeElement: (Element) -> Bool) -> [Element] {
    var result: [Element] = []
    for x in array where includeElement(x) {
        result.append( x)
    }
    return result
}

filter([3, 4, 5]) { $0 > 3 } //[4, 5]

file9.swift

func curry<A, B, C>(_ f: @escaping (A, B) -> C) -> (A) -> (B) -> C {
    return { x in
        { y in f(x, y) }
    }
}