swift 可选的泛型类型和嵌套的可选解包

Question

I've got this piece of code

class MyObject<T> {

    func start(_ value: T?) {
        if let value = value {
            doSomething(value)
        }
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

MyObject<String>().start("some")
// prints "some"

MyObject<String?>().start(nil)
// doesn't print anything

I need doSomething() to be called for every valid value passed to start() . And when T is already an optional type like String? , then nil is a valid value.

Do I need to write two versions of start() in extensions of MyObject with conditions on the type of T ? And how to do it?

Answer 1

You can make your start function take a non-optional T and just always call doSomething instead of trying to unwrap it first. This would only allow you to call start(nil) if T itself was an optional type:

class MyObject<T> {

    func start(_ value: T) {
        doSomething(value)
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

MyObject<String>().start("some")
// prints "some"

MyObject<String?>().start(nil)
// prints "nil"

If you want to leave the parameter to start as optional then your original code will actually work, but you need to change the way you are passing your value in your second example.

Since T is String? , the parameter in your method is of type String?? and passing a nil String?? is different then passing one with a String? that happens to contain nil .

If you call it as:

MyObject<String?>().start(.some(nil))

or

let string: String? = nil
MyObject<String?>().start(string)

Then it will print "nil"

Answer 2

Since let value = value fails with the second input you need to handle that case separately.

func start(_ value: T?) {
    if let value = value {
        doSomething(value)
    }
    else
    {
        print("nil input")
    }
}

Answer 3

In case value is nil, when you unwrap the value will not enter in the if statement. Instead, you can do this:

class MyObject<T> {

    func start(_ value: T?) {
        if let value = value {
            doSomething(value)
        } else {
            print("nil")
        }
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

Answer 4

Optional in Swift is just a generic enum that have two cases:

enum Optional<T> {
    case some(T)
    case none
}

For example String? is the same thing of Optional<String> .

If you declare MyObject<String?> basically you're creating this MyObject<Optional<String>> , so your concrete start method will be

func start(_ value: Optional<Optional<String>>) { ... }

This means that if you call it like start(nil) , the whole object will be of course nil and the if let will fail. You can however call that function in this way

MyObject<String?>().start(Optional.some(Optional.none))
MyObject<String?>().start(.some(.none)) // -> shorter version with type inference

Basically now the outer optional exists and the unwrap works, but the inner one is nil .

However I still can't understand why would you need to do something like that