Difference between normal function and function ending throw

Function ending with throw can throw error but normal function can not throw error it can just return value.

Lets take example :

1. Custom error enum

enum ErrorsToThrow: Error {

    case fileNotFound

    case fileNotReadable

    case fileSizeIsTooHigh

}

2. Make function which can throw error

func readFiles(path:String) throws  ->String {

        if path == "" {

            throw ErrorsToThrow.fileNotFound

        }

        return "Data from file"

    }

3. Calling readFiles function

   do {

            let dataFromString = try? readFiles(path: "")

            print(dataFromString)

        } catch ErrorsToThrow.fileNotFound {

            print("error generated1")

        } catch ErrorsToThrow.fileNotReadable {

            print("error generated2")

        } catch ErrorsToThrow.fileSizeIsTooHigh {

            print("error generated3")

        } catch {

                print("error")

        }

Now, let's analysis.

1. If in #2, function is not ending with throws can not throw error. But our function can throw error.
2. In #3, we have used try?, so if readFiles function return nil instead of throwing error. So in our case print(dataFromString) statement executed and it will nil means printing nil.

3. If try! is written and if function throw error, then fatal error will be occured and program will be crashed as we ensure that error will not occur by putting ! .
4. So if we want to execute catch statement then we have to use only try . try always used with do-catch.
5. try? and try! does not need do-catch block.

What is closure? Why we use closure instead of function sometime?

Ans : 

The two most used cases are completion blocks and higher order functions in Swift. 

Completion blocks: for example, when you have some time consuming task, you want to be notified when that task is finished. You can use closures for that, instead of a delegate (or many other things)

func longAction(completion: () -> ()) {

    for index in veryLargeArray {

        // do something with veryLargeArray, which is extremely time-consuming

    }

    completion() // notify the caller that the longAction is finished

}

//Or asynch version

func longAction(completion: () -> ()) {

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {

        

        for elem in veryLargeArray {

            // do something with veryLargeArray, which is extremely time-consuming

        }

        dispatch_async(dispatch_get_main_queue(), {

            completion() // notify the caller that the longAction is finished

        })

    }

}

longAction { print("work done") }

In the example above, when you have a time consuming task, you want to know when the for loop finishes iterating through the very large array. You put the closure { println("work done") } as an input parameter for the function which will be executed after the for loop finishes its work, and print "work done". And what happened is that you gave a function (closure) to longAction and name it to completion, and that function will be executed when you call completion in longAction.

Sorted method works using closure.

About how sorted (probably) works: So the idea is, that sorted will go through the array, and compare two consecutive elements (i, i + 1) with each other, and swap them, if needed. What does it mean "if needed"? You provided the closure { (s1: String, s2: String) -> Bool in return s1 > s2 }, which will return true if s1 is greater than s2. And if that closure returned true, the sorted algorithm will swap those two elements, and continues this with the next two elements (i + 1, i + 2, if the end of the array is not reached). So basically you have to provide a closure for sorted which will tell "when" to swap to elements.

Understand Closure

Some truths about protocol

Q1 : Can structure confirm protocol?

A1 : Yes

Q2 : Can enumeration confirm protocol?

A2 : Yes

Q3 : Can we declare variable in protocol?

A3 : Yes -> It must be var and it must be read-Only or readAndWrite . Property declaration is like following : 

protocol someprotocol {

     var gettable : Int { get }

      var setAndGettable : Int { get set }

} 

Q4 : Can we add function in the enumeration?

A4 : Yes

Q5 : Can protocol has own init method?

A5 : Yes

Q6 : Can protocol inherit another protocol?

A6 : Yes

protocol someprotocol : anotherprotocol {

}

Q7: Can we make a class-specific protocol?

A7: You can limit protocol adoption to class types (and not structures or enumerations) by adding the AnyObject or class protocol to a protocol’s inheritance list.

protocol someprotocol : AnyObject, Someanotherprotocol {

}

Now someprotocol can only be confirmed by class type. No structure or enum type can confirm this protocol.

Q8. Can we declare an optional protocol method in swift?

A8. Yes. In that protocol name and optional methods should be followed by @objc due to it consider as objective c code.

@objc protocol someprotocol {

        @objc optional func somemethod()

        @objc optional var someName : String { get set }

}

or 

We can make protocol extension and provide default body to protocol method. So any class or struct confirms that protocol doesn't require implementing that method.

Q.9 Can protocol be fileprivate?
A9. Yes. Protocol can be fileprivate, private, public. Private and fileprivate protocol can be confirmed only within current file.

Q.10 Can we define property in extension?
A10. Swift doesn’t support stored properties inside the extension. Computed property is allowed in extension.

Q.11 Can we define property in protocol?
A.11 Property in protocol must have explicit { get } or { get set } specifier. 

protocol VoiceAssistant {

        var s : String // Not allowed

        var name: String {get} // Allowed

        var voice: String {get set} // Allowed

    }

Q.12 Can we declare same name property in protocol and its extension with different datatype?
A.12 Yes. Extension declared property must have valid getter method.

protocol VoiceAssistant {

   

    var name: String {get}

    var voice: String {get set}

}

extension VoiceAssistant {

    var name: Int {get { return 5}}

}

Q.13 Can we define body in method in protocol? How?

A.13 Yes.

protocol VoiceAssistant {

    func makeMessage()

}

extension VoiceAssistant {

    func makeMessage() {

        print("Default make message method")

    }

}