Cfrgtkky

New to Swift and I am currently getting around passing a function as an optional parameter in the following way:

import Foundation 



func foo()

{

    print("Foo")

}



func bar()

{

    print("Bar")

}



func dummy()

{

    return

}



func myFunc()

{

    myFunc(callBack: dummy())

}



func myFunc(callBack: (Void))

{

    foo()

    callBack

}



myFunc()

myFunc(callBack: bar())

i.e. exploiting polymorphism

This seems like an inelegant way to do this, is there a better way,

Thanks,
Tom

edit:

I am aware I could shorten this by doing:

import Foundation 



func foo()

{

    print("Foo")

}



func bar()

{

    print("Bar")

}



func dummy()

{

    return

}



func myFunc(callBack: (Void) = dummy())

{

    foo()

    callBack

}



myFunc()

myFunc(callBack: bar())

But I would still say this is an inelegant solution

You can easily define a default value for a function as parameter:

func foo(completion: () -> Void = { }) {

    completion()

}

You could also have it be nil by default:

func foo(completion: (() -> Void)? = nil) {

When it's an optional closure, you'll have to call it like this:

completion?()

Your are referring to default arguments:

You can define a default value for any parameter in a function by assigning a value to the parameter after that parameter’s type. If a default value is defined, you can omit that parameter when calling the function.

So you need something like:

func myfunc (callback: ()->void = dummy) {

LinusGeffarth notes that callbacks in Swift are called completion, or closure as avismara notes.

Umm, are you passing function as an optional parameter, though? It looks like you have written a method that accepts Void, you have a function that accepts Void and you are just calling that method. I don't see any trace of polymorphism here except probably that the myFunc has multiple signatures. This method is an inelegant solution not because it is inelegant, but because it isn't a solution.

Here is a correct example of polymorphism in functional systems:

func printA() {

    print("A")

}



func printB() {

    print("B")

}



//This method accepts a function as a parameter

func higherOrderPrinter(with print: () -> Void ) { 

    print() //Can be anything, depends on the method you send here. Polymorphism much? :)

}



higherOrderPrinter(with: printA) //Prints A. See carefully how I am NOT doing printA()

higherOrderPrinter(with: printB) //Prints B

//In fact...

higherOrderPrinter {

    print("C") 

} //Prints C

Full code with answer applied:

import Foundation 



func foo()

{

    print("Foo")

}



func bar()

{

    print("Bar")

}



func myFunc(completion: () -> Void = { })

{

    foo()

    completion()

}



myFunc()

myFunc(completion: bar)