Aspect Oriented Swift

Aspect.swift

struct Aspect<T,V> {
    let backing: T -> V
    
    init(_ function: T -> V) {
        backing = function    
    }
    
    var preceedingActions = Array<(T, V) -> ()>()
    mutating func doAfter(action: (input: T, output: V) -> ()) {
        preceedingActions.append(action)
    }
    
    func call(input: T) -> V {
        let result = backing(input)
        
        for action in preceedingActions {
            action(input, result)
        }
        
        return result
    }
}

// Example

var square = Aspect { (x: Int) -> Int in x * x }
square.doAfter { input, output in
    println("The square of \(input) is \(output).")
}

var sum = 0
for x in 0...5 {
    sum += square.call(x)
}

println("The sum of square from 0 to 5 is \(sum).")