Swift 1.1包含了〜＆gt;的声明。操作者：
infix operator ~> {
associativity left
precedence 255
}
Swift中使用的是什么？它似乎已声明，但没有定义利用它的函数。其他开发人员已经将它用于反应模式和队列之间的编组闭包，但我想知道为什么它在标准框架中定义。我推测它是为了保留开发人员使用的自定义运算符，因为它具有最高的优先级。
答案 0 :(得分：7)
看来，它的相关集合/序列/索引类型
protocol SequenceType : _Sequence_Type {
typealias Generator : GeneratorType
func generate() -> Generator
func ~>(_: Self, _: (_UnderestimateCount, ())) -> Int
func ~><R>(_: Self, _: (_PreprocessingPass, ((Self) -> R))) -> R?
func ~>(_: Self, _: (_CopyToNativeArrayBuffer, ())) -> _ContiguousArrayBuffer<Self.Generator.Element>
}
protocol CollectionType : _CollectionType, SequenceType {
subscript (position: Self.Index) -> Self.Generator.Element { get }
func ~>(_: Self, _: (_CountElements, ())) -> Self.Index.Distance
}
protocol ForwardIndexType : _ForwardIndexType {
func ~>(start: Self, _: (_Distance, Self)) -> Self.Distance
func ~>(start: Self, _: (_Advance, Self.Distance)) -> Self
func ~>(start: Self, _: (_Advance, (Self.Distance, Self))) -> Self
}
protocol SignedNumberType : _SignedNumberType {
prefix func -(x: Self) -> Self
func ~>(_: Self, _: (_Abs, ())) -> Self
}
func ~><T : _CollectionType>(x: T, _: (_CountElements, ())) -> T.Index.Distance
func ~><T : _CollectionType>(x: T, _: (_UnderestimateCount, ())) -> Int
func ~><T : _CollectionType, R>(s: T, args: (_PreprocessingPass, ((T) -> R))) -> R?
func ~><T : _SequenceType>(s: T, _: (_UnderestimateCount, ())) -> Int
func ~><T : _SequenceType, R>(s: T, _: (_PreprocessingPass, ((T) -> R))) -> R?
func ~><S : _Sequence_Type>(source: S, _: (_CopyToNativeArrayBuffer, ())) -> _ContiguousArrayBuffer<S.Generator.Element>
func ~><C : CollectionType where C._Element == C._Element>(source: C, _: (_CopyToNativeArrayBuffer, ())) -> _ContiguousArrayBuffer<C._Element>
func ~><T>(x: EmptyCollection<T>, _: (_CountElements, ())) -> Int
func ~><T : _ForwardIndexType>(start: T, rest: (_Distance, T)) -> T.Distance
func ~><T : _ForwardIndexType>(start: T, rest: (_Advance, T.Distance)) -> T
func ~><T : _ForwardIndexType>(start: T, rest: (_Advance, (T.Distance, T))) -> T
func ~><T : _BidirectionalIndexType>(start: T, rest: (_Advance, T.Distance)) -> T
func ~><T : _BidirectionalIndexType>(start: T, rest: (_Advance, (T.Distance, T))) -> T
func ~><T : _RandomAccessIndexType>(start: T, rest: (_Distance, (T))) -> T.Distance
func ~><T : _RandomAccessIndexType>(start: T, rest: (_Advance, (T.Distance))) -> T
func ~><T : _RandomAccessIndexType>(start: T, rest: (_Advance, (T.Distance, T))) -> T
func ~><T : _SignedNumberType>(x: T, _: (_Abs, ())) -> T
func ~><T : AbsoluteValuable>(x: T, _: (_Abs, ())) -> T
func ~><T>(x: CollectionOfOne<T>, _: (_CountElements, ())) -> Int
例如，
42 ~> _advance(12) // -> 54
42 ~> _distanceTo(23) // -> -19
我不知道如何使用这些： - /
答案 1 :(得分：7)
由于Swift是开源的，我们可以看到在{stdlib：as a workaround for method specialization in a child protocol in Swift 1.x中包含Animal.all的实际原因。
~>详细示例可在test/Prototypes/GenericDispatch.swift中找到。
注意：不要在Swift 2 +中使用// Workaround for <rdar://problem/14011860> SubTLF: Default
// implementations in protocols. Library authors should ensure
// that this operator never needs to be seen by end-users. See
// test/Prototypes/GenericDispatch.swift for a fully documented
// example of how this operator is used, and how its use can be hidden
// from users.
infix operator ~> { associativity left precedence 255 }
。这是一个历史性的解决方法。它不再需要。请继续阅读。
~>如何运作在Swift 2中，~>唯一剩下的实例是~>函数（也可能会消失）。我们可以看到abs实际上是如何工作的。从stdlib/public/core/IntegerArithmetic.swift.gyb开始，~>协议定义了SignedInteger运算符：
~>此处，箭头struct _Abs {}
protocol SignedNumber: Comparable {
prefix func -(_: Self) -> Self
func ~> (_: Self, _: (_Abs, ()) -> Self
}
func ~> <T: SignedNumber>(x: T, _: (_Abs, ()) -> T {
return x < 0 ? -x : x
}
的RHS指定可以将命令发送到对象。将~>视为p~>(cmd, args)。
然后，当给出p.cmd(args)时，我们提供_Abs的默认实现。
SignedNumber接下来，我们有一个子协议protocol AbsoluteValuable : SignedNumber {
static func abs(_: Self) -> Self
}
func ~> <T: AbsoluteValuable>(x: T, _: (_Abs, ())) -> T {
return T.abs(x)
}
，它可能比AbsoluteValuable更有效地计算绝对值。然后，我们将x < 0 ? -x : x的{{1}}运算符专门化。
~>最后，我们在公共包装器方法中隐藏AbsoluteValuable调用。如果func abs<T: SignedNumber>(_ x: T) -> T {
return x ~> (_Abs(), ())
}
实际上是~>，则会选择更专业且效率更高的T。
这也是我们AbsoluteValuable或~>得到@rintaro's answer所示的原因，因为42 ~> _advance(12)和42 ~> _distanceTo(23)方法是O（n）一般.advanceBy，但如果类型为.distanceTo，则可以在O（1）中实现。
ForwardIndexType 这种模式也可以在没有调用RandomAccessIndexType运算符的情况下完成，使用协议上的扩展：
~>特别是这就是除了~>之外的所有其他protocol SignedInteger: Comparable {
prefix func -(_: Self) -> Self
func genericAbs() -> Self
}
extension SignedInteger {
func genericAbs() -> Self {
return self < 0 ? -self : self
}
}
protocol AbsoluteValueable: SignedInteger {
static func abs(_: Self) -> Self
}
extension AbsoluteValueable {
func genericAbs() -> Self {
return Self.abs(self)
}
// normally you would allow subtypes to override
// genericAbs() directly, instead of overriding
// static abs().
}
func abs<T: SignedInteger>(x: T) -> T {
return x.genericAbs()
}
实现在Swift 2中消失的原因：使用这种技术的所有特化都已经改为使用更明显的协议扩展，例如。
~>
在commit 311baf73 (2015 Aug 4) abs，underestimateCount
注意：雷达问题14011860不公开，但我们可能会在OpenRadar上看到错误的重复范围：
答案 2 :(得分：0)
在SwiftDoc上，此运算符已从 Swift 3.0 的运算符章节中删除。