In Swift – the new programming language introduced by Apple – functions are first class citizens. This basically means, that a function can be passed as a parameter, returned from another function or assigned to a value. It allows us to do a lot of useful stuff with them.<\/p>\n\n\n\n
Let’s use the concepts of function as a first class citizen to implement some basic function decorator.<\/p>\n\n\n\n
func greeting(firstName: String, lastName: String) -> String {\n return \"Hello, \" + firstName + \" \" + lastName + \"!\"\n}\nlet greetSomeone = greeting\nprintln(greetSomeone(\"John\", \"Doe\")) \/\/ => Hello, John Doe!\n\n<\/pre>\n\n\n\nFunctions can be passed as parameters to other functions<\/h4>\n\n\n\nfunc johnDoeFunction(function: (String, String) -> String) -> String {\n return function(\"John\", \"Doe\")\n}\nprintln(johnDoeFunction(greeting)) \/\/ => Hello, John Doe!\n\n<\/pre>\n\n\n\nFunctions can return other functions<\/h4>\n\n\n\nfunc composeHelloFunction() -> (String -> String) { \n func hello(name: String) -> String {\n return \"Hello, \" + name\n }\n return hello\n}\nlet helloFunc = composeHelloFunction()\nprintln(helloFunc(\"John\")) \/\/ => Hello, John\n\n<\/pre>\n\n\n\nThis concept allows us to implement function decorators in Swift.<\/p>\n\n\n\n
Function decorators work as wrappers to existing functions, modifying the behavior of the code before and after a target function, without the need to modify the function itself. They augment the original functionality, thus decorate it.<\/p>\n\n\n\n
Using the concepts above let’s write a simple decorator that wraps the String output of another function by some html tag.<\/p>\n\n\n\n
func hello(name: String) -> String {\n return \"Hello, \" + name\n}\n\nfunc bold(function: String -> String) -> (String -> String) {\n func decoratedBold(text: String) -> String {\n return \"\" + function(text) + \"<\/b>\"\n }\n return decoratedBold\n}\nlet boldHello = bold(hello)\nprintln(boldHello(\"Vladimir\")) \/\/ => Hello, Vladimir<\/b>\n\n<\/pre>\n\n\n\nWe wrote a function that takes another function as an argument, generates a new function, augmenting the work of the original function, and returns the generated function so we can use it anywhere. Decorating function also allows us to insert some behaviour before\/after function call or combine multiple functions into one.<\/p>\n\n\n\n
In the example above we had to explicitly specify the signature of the function to decorate: func bold(function: String -> String)<\/code>. We’ve implemented bold decorator so that it decorates a function from one String<\/code> value, which returns another String<\/code> value. But what if one would like to create bold decorator which accepts functions with different signatures?<\/p>\n\n\n\nAbstract Functor<\/h2>\n\n\n\n
Let’s define an abstract Functor class. By ‘Functor’ let’s assume a class, which wraps any function and allows to call that function.<\/p>\n\n\n\n
class F<T1, T2> {\n \n let f: T1 -> T2\n \n init(function: T1 -> T2) {\n self.f = function\n }\n \n func run(args: T1) -> T2 {\n return f(args)\n }\n}\n\n<\/pre>\n\n\n\nThis class allows us to wrap any function and call it somewhere:<\/p>\n\n\n\n
func logger(text: String) {\n println(\"LOG: \\(text)\")\n}\nlet loggerFunc = F(logger)\nloggerFunc.run(\"Hello\") \/\/ => LOG: Hello\n\n<\/pre>\n\n\n\nUsing the Functor class we can now rewrite bold decorator to accept functions with different number of parameters:<\/p>\n\n\n\n
func bold(function: F<T1, String>) -> F<T1, String> {\n func decoratedBold(args: T1) -> String {\n return \"\" + function.run(args) + \"<\/b>\"\n }\n return F(decoratedBold)\n}\n\nlet boldGreeting = bold(F(greeting))\nprintln(boldGreeting.run(\"John\", \"Doe\")) \/\/ => Hello, John Doe!<\/b>\n\nlet boldHello = bold(F(hello))\nprintln(boldHello.run(\"Vladimir\")) \/\/ => Hello, Vladimir<\/b>\n\n<\/pre>\n\n\n\nComposing functions<\/h2>\n\n\n\n
Another interesting approach of using function decorators is composing several functions into single one.<\/p>\n\n\n\n
Swift allows overloading basic operators. Let’s try to overload +<\/code> operator to accept two functions and compose them into one function.<\/p>\n\n\n\nfunc +<T1, T2>(beforeHook: F<(), ()>, function: F<T1, T2>) -> (T1 -> T2) {\n\n func composedFunc(args: T1) -> T2 {\n beforeHook.run()\n return function.run(args)\n }\n\n return composedFunc\n}\n\nfunc +<T1, T2>(function: F<T1, T2>, afterHook: F<T2, ()>) -> (T1 -> T2) { \n \n func composedFunc(args: T1) -> T2 {\n var result = function.run(args)\n afterHook.run(result)\n return result\n } \n \n return composedFunc\n}\n\n<\/pre>\n\n\n\nAbove you can see two overloads of +<\/code> operator which accept functors of different types and combine them into a single function.
The first overloaded version runs a Void -> Void<\/code> function before main function, and the second one runs main function,
then passes its result to another T2 -> Void<\/code> function and returns the result of the main function.<\/p>\n\n\n\nLet’s write an example of using this approach:<\/p>\n\n\n\n
func logger(text: String) {\n println(\"LOG: \\(text)\")\n}\n\nfunc request(url: String) -> String {\n return \"Success 200\"\n}\n\nlet logRequest = F(request) + F(logger)\nlogRequest(\"http:\/\/some.awesome.url\") \/\/ => \"LOG: Success 200\"\n\nlet composedRequest = F({ println(\"Request is fired!\") }) + F(request)\nprintln(composedRequest(\"http:\/\/some.awesome.url\"))\n\/\/ => Request is fired!\n\/\/ => Success 200 \n\n<\/pre>\n\n\n\nWe could also implement +<\/code> operator overload for plain functions, not for Functor type, but overloading operators for basic types may be a bad practice.<\/p>\n\n\n\n