如何使用泛型类型的文字进行初始化？

Question

有protocols用字面量实现初始化。

示例：通过使用ExpressibleByStringLiteral，我们可以执行以下操作：

struct MyString: ExpressibleByStringLiteral {
    let value: String

    init(stringLiteral value: String) {
        self.value = value
    }
}

let str: MyString = "Hello World!" // It's the same as: `MyString(stringLiteral: "Hello World!")`
str.value // "Hello World!"

此外，通过使用ExpressibleByIntegerLiteral，我们可以执行以下操作：

struct MyInt: ExpressibleByIntegerLiteral {
    let value: Int

    init(integerLiteral value: Int) {
        self.value = value
    }
}

let int: MyInt = 101 // It's the same as: `MyInt(integerLiteral: 101)`
int.value // 101

我的问题是：

我们如何为具有泛型类型的结构应用相同的逻辑？考虑我有以下结构：

struct MyCustom<T> {
    let value: T
}

我想做的是：

let custom1: MyCustom = "Hello World!"
custom1.value // "Hello World!"
// OR (since its generic)
let custom2: MyCustom = 101
custom1.value // 101

在这种情况下要遵循什么适当的协议？

Answer 1

没有一种可以遵循的协议，但您可以基于T 的泛型类型为所有ExpressibleByXLiteral 协议创建条件一致性。

extension MyCustom: ExpressibleByUnicodeScalarLiteral, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringLiteral where T == String {
    init(unicodeScalarLiteral value: T) {
        self.value = value
    }

    init(extendedGraphemeClusterLiteral value: T) {
        self.value = value
    }

    init(stringLiteral value: T) {
        self.value = value
    }
}

extension MyCustom: ExpressibleByIntegerLiteral where T == Int {
    init(integerLiteral value: T) {
        self.value = value
    }
}

let myString: MyCustom<String> = "String"
let myInt: MyCustom<Int> = 21

Answer 2

这可以通过条件一致性实现：

extension MyCustom: ExpressibleByStringLiteral, ExpressibleByUnicodeScalarLiteral, ExpressibleByExtendedGraphemeClusterLiteral where T: ExpressibleByStringLiteral {
    init(stringLiteral value: T.StringLiteralType) {
        self.value = T(stringLiteral: value)
    }

    init(unicodeScalarLiteral value: T.UnicodeScalarLiteralType) {
        self.value = T(unicodeScalarLiteral: value)
    }

    init(extendedGraphemeClusterLiteral value: T.ExtendedGraphemeClusterLiteralType) {
        self.value = T(extendedGraphemeClusterLiteral: value)
    }
}

extension MyCustom: ExpressibleByIntegerLiteral where T: ExpressibleByIntegerLiteral {
    init(integerLiteral value: T.IntegerLiteralType) {
        self.value = T(integerLiteral: value)
    }
}

你可以这样做：

let custom1: MyCustom<String> = "Hello World!"
custom1.value // "Hello World!"
// OR (since its generic)
let custom2: MyCustom<Int> = 101
custom2.value // 101

不过，对于 ExpressibleByStringLiteral，您需要明确声明并实现继承的一致性。

此外，您需要告诉 Swift 您想要哪种泛型类型（MyCustom<Int> 和 MyCustom<String>），因为可能还有其他类型符合例如ExpressibleByIntegerLiteral。例如MyCustom 类型本身：

let custom3: MyCustom<MyCustom<Int>> = 101
custom3.value // MyCustom<Int>(value: 101)