FP.playground

//: FP Playground 

import UIKit

// Expressive Functions

func greeting(_ name: String) -> String {
    return "Greeting \(name)!"
}

// Curry function

func addAdapter(adapter: Int) -> (Int) -> Int {
    return {
        num in
        return adapter + num
    }
}

let addTwo = addAdapter(adapter: 2)
let result = addTwo(3)


// Generic Curry Function

func add<T: Integer>(_ add: T) -> (T) -> T {
    return { $0 + add }
}

let result2 = add(2)(3)



// Composite function

func compose<T>(funcA: @escaping (T) -> T, funcB: @escaping (T) -> T) -> (T) -> T {
    return { funcB(funcA($0)) }
}

let addDouble = { $0 * 2 }
let plusOne = { $0 + 1 }

let val = compose(funcA: addDouble, funcB: plusOne)
val(3)

func compose2<A,B,C>(funcA: @escaping (A) -> B, funcB: @escaping (B) -> C) -> (A) -> C {
    return { funcB(funcA($0)) }
}

let addNewPlus = { $0 + 2 }
let isBiggerThanTne = { $0 > 10 }

let val2 = compose2(funcA: addNewPlus, funcB: isBiggerThanTne)
val2(3)


// Chain Functions

let arr = [1,5,77,4,3,9,10,10]

func sortArray(_ arr:[Int]) -> [Int] {
    return arr.sorted()
}

func removeDuplicate(_ arr:[Int]) -> [Int] {
    return arr.removeDuplicates()
}

func removeFirst(_ arr:[Int]) -> [Int] {
    return Array(arr.dropFirst())
}

func reverseArray(_ arr:[Int]) -> [Int] {
    return arr.reversed()
}


extension Array where Element:Equatable {
    func removeDuplicates() -> [Element] {
        var result = [Element]()
        
        for value in self {
            if result.contains(value) == false {
                result.append(value)
            }
        }
        
        return result
    }
}


let newArray = reverseArray(removeFirst(removeDuplicate(sortArray(arr))))


// Doing chain function with custom operators

precedencegroup NewPrecedence {
    associativity: left
}

infix operator |> : NewPrecedence
func |> <T>(value: T, function: ((T) -> T)) -> T {
    return function(value)
}


let newArray2 = arr |> sortArray |> removeDuplicate |> removeFirst |> reverseArray