Swift中的泛型typealias

在haskell中，您可以执行以下操作：

type Parser a = String -> [(a, String)]

我试着用斯威夫特做些类似的东西。到目前为止，我写这些代码都不走运

typealias Parser<A> = String -> [(A, String)]
typealias Parser a = String -> [(a, String)]
typealias Parser = String -> [(A, String)]

---

typealias解析器当前不能与泛型一起使用。最好的选择可能是将解析器函数包装在结构中

struct Parser<A> {
    let f: String -> [(A, String)]
}

struct解析器{
设f:String->[（A，String）]
}

然后，您可以在创建解析器时使用尾部闭包语法，例如

let parser = Parser<Character> { string in return [head(string), tail(string)] }

let parser=parser{返回字符串[头（字符串），尾（字符串）]}
这里我为typealias演示示例，演示如何在协议定义中使用typealias：我希望这有助于您理解typealias

protocol NumaricType {
    typealias elementType
    func plus(lhs : elementType, _ rhs : elementType) -> elementType
    func minus(lhs : elementType, _ rhs : elementType) -> elementType
}

struct Arthamatic :NumaricType {

    func addMethod(element1 :Int, element2 :Int) -> Int {
       return plus(element1, element2)
    }
    func minusMethod(ele1 :Int, ele2 :Int) -> Int {
        return minus(ele1, ele2)
    }

    typealias elementType = Int

    func plus(lhs: elementType,  _ rhs: elementType) -> elementType {
        return lhs + rhs
    }
    func minus(lhs: elementType, _ rhs: elementType) -> elementType {
        return lhs - rhs
    }
}

输出：

let obj =  Arthamatic().addMethod(34, element2: 45) // 79

通用
typealias
可以从Swift 3.0开始使用。这应该适合您：

typealias Parser<A> = (String) -> [(A, String)]

typealias解析器

用法（来自@Calin Drule注释）：

func parse（stringToParse:String，parser:parser）
通用类型别名-
状态：已实施（Swift 3）

解决方案很简单：允许类型别名引入类型参数，这些参数在其定义范围内。这使得人们可以表达如下内容：

typealias StringDictionary=字典
typealias IntFunction=（T）->Int
typealias MatchingTriple=（T，T，T）
别名BackwardTriple=（T3、T2、T1）
@mustafa嗨，你能告诉我它的哪一部分表示拳击吗？你不是指Java意义上的拳击，是吗？另外，我的头在
[头（串）…
和
尾（串）]
周围也有问题。谢谢。@Unheilig-Boxing是指将一个类型包装在另一个类型上，以便利用仅在外部类型中才能找到的功能。您可能熟悉Objective-C中的概念，在Objective-C中，整数等原语如果不在NSNumber中“装箱”，就无法传递到NSArray中，例如，
@（1234）
。head/tail不是swift特有的，而是将数组拆分为第一项（head）和剩余项（tail）的一种常见模式。请看@clozach，谢谢你的解释。我将继续浏览您共享的链接。此答案不是最新的。您应该检查Hey@Narendra G这个解决方案是否也适用于其他数值类型？用法：>func parse（stringToParse:String，parser:parser）
func parse<A>(stringToParse: String, parser: Parser) 

typealias StringDictionary<T> = Dictionary<String, T>
typealias IntFunction<T> = (T) -> Int
typealias MatchingTriple<T> = (T, T, T)
alias BackwardTriple<T1, T2, T3> = (T3, T2, T1)