how does he use the let keyowrd in the short downloadTaskWithRequest form?

Sorry, one never knows for sure what level someone's at!

Yes, there are other uses for let in Swift. Your example of an enum shows one of them. Optional binding is another.

Here's an excerpt from the Swift documentation about enums with associated values that might help explain what is going on in your enum example:

"In Swift, an enumeration to define product barcodes of either type [UPCA or QR] might look like this:

enum Barcode { case UPCA(Int, Int, Int, Int) case QRCode(String) } This can be read as:

“Define an enumeration type called Barcode, which can take either a value of UPCA with an associated value of type (Int, Int, Int, Int), or a value of QRCode with an associated value of type String.”

This definition does not provide any actual Int or String values—it just defines the type of associated values that Barcode constants and variables can store when they are equal to Barcode.UPCA or Barcode.QRCode.

New barcodes can then be created using either type:

 var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)

This example creates a new variable called productBarcode and assigns it a value of Barcode.UPCA with an associated tuple value of (8, 85909, 51226, 3).

The same product can be assigned a different type of barcode:

 productBarcode = .QRCode("ABCDEFGHIJKLMNOP")

At this point, the original Barcode.UPCA and its integer values are replaced by the new Barcode.QRCode and its string value. Constants and variables of type Barcode can store either a .UPCA or a .QRCode (together with their associated values), but they can only store one of them at any given time.

The different barcode types can be checked using a switch statement, as before. This time, however, the associated values can be extracted as part of the switch statement. You extract each associated value as a constant (with the let prefix) or a variable (with the var prefix) for use within the switch case’s body:

switch productBarcode { case .UPCA(let numberSystem, let manufacturer, let product, let check): print("UPC-A: (numberSystem), (manufacturer), (product), (check).") case .QRCode(let productCode): print("QR code: (productCode).") } // Prints "QR code: ABCDEFGHIJKLMNOP." If all of the associated values for an enumeration case are extracted as constants, or if all are extracted as variables, you can place a single var or let annotation before the case name, for brevity:

switch productBarcode { case let .UPCA(numberSystem, manufacturer, product, check): print("UPC-A: (numberSystem), (manufacturer), (product), (check).") case let .QRCode(productCode): print("QR code: (productCode).") } // Prints "QR code: ABCDEFGHIJKLMNOP."

But that's not what Pasan is doing in this video.

Re the 3 accent marks. If you don't leave a blank line before and after them your code won't display properly.

My apologies. I originally thought you were asking about the constant declarations Pasan was writing around 1:05 in the video. Now I see I was wrong. I didn't watch enough. You were asking about the two ways Pasan wrote the trailing closure around 5:20 of the video.

As I guess you already know, one way to write a trailing closure is:

{(parameters) -> (return type) in ... }

One of the examples in the Swift documentation, for example, is:

let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map {
    (number) -> String in  //number is a parameter
    var number = number
    var output = ""
    while number > 0 {
        output = digitNames[number % 10]! + output
        number /= 10
    }
    return output
}

The documentation explains the line var number = number by saying "In this example, the variable number is initialized with the value of the closure’s number parameter, so that the value can be modified within the closure body. (The parameters to functions and closures are always constants.)"

Adding let before number in the above example changes nothing when run in Xcode.

Pasan could have written { (url, response, error) in ... } but he chose to make their constant status explicit.

Bottom line, url, response, error are constant parameters for the closure.

Swift documentation: "You declare constants with the let keyword and variables with the var keyword."

Pasan may seem to be muddying the water a bit by saying:

"First, I'm going to create a session variable. 0:31 Next, I'll create a URL. 0:50 Then a request variable. 0:56 And we'll initialize it using the URL."

The three "variables" he creates are actually constants.

But he's in good company, as the Apple documentation also says: "Swift uses variables to store and refer to values by an identifying name. Swift also makes extensive use of variables whose values cannot be changed. These are known as constants, and are much more powerful than constants in C. Constants are used throughout Swift to make code safer and clearer in intent when you work with values that do not need to change."

So perhaps we should think of it this way: var creates variables that can be changed while let creates variables that cannot be changed (i.e., are not variable!).