Swift3 什么'；斯威夫特&x27；s"；fromAfter“的缩写；调用数组切片？

Swift 3具有至和至

分别为非结论性和包容性

func前缀（最多：Int）
返回从集合开始到指定位置（但不包括）的子序列

func前缀（通过：Int）
返回从集合开始到指定位置的子序列

对于另一端，它具有来自的

func后缀（from:Int）
返回从指定位置到集合结尾的子序列

这似乎是包容性的

远端的非包容性呼叫是什么

    // sum the numbers before, and after, an index i...

    let lo = A.prefix(upTo: i).reduce(0,+)    // means noninclusive
    let hi = A.suffix(from: i+1).reduce(0,+)  // 'from' seems to mean inclusive

---

我不知道怎么回事？必须从+1开始写入非常糟糕。

目前，stdlib中的

集合
类型没有非包容性的
后缀
方法，但是对于这个用例，您可以通过将
后缀（from:）
与
dropFirst（:）
（与idx+1中的
相比，imho更能显示意图），例如

应用于您的示例（在给定分区编号（或，索引of）之前和之后分别求和编号，不包括分区编号）：

但是，我认为
拆分版本有点冗长，而且在显示代码意图方面语义也较差。
Swift标准库参考中没有包含非包容性签名，
后缀（\）
和
后缀（from:）
引用显示了包含性示例，因此在本版本中不可用。我也没有看到任何引用非包含性后缀的讨论，因此不太可能很快可用。啊-精彩的信息。也许应该粘贴它作为决定性的答案，@Gelliot181？我是一个短暂的swift用户，所以我通常更愿意留下一个实际的向能够提供细节的人发誓，就像@dfri制作的那样。壮观。我必须承认我不明白SubSequence==SubSequence.SubSequence在哪里，我也不可能在文档或任何教程中找到它的解释。也许你可以慷慨地添加一行解释它，供凡人阅读；）Tak@JoeBlow这并不像人们乍一看所想的那么棘手。
后缀（after:）
方法的返回类型是
Self.SubSequence
。现在，对于某些给定的序列，例如
seq
，现有的
后缀（from:）
方法（我们在方法的return子句中调用）返回。本身是类型
Self.SubSequence
的实例（其中
Self
是
seq
的类型：符合
序列的某些类型）。因此，如果
return
语句看起来像
return后缀（from:start）
，我们就不需要
其中SubSequence==SubSequence.SubSequence
规范，因为
return
子句的类型匹配。。。。。。我们在
后缀（after:）
方法中指定的返回类型，即
Self.SubSequence
。然而，在我们的例子中，我们对从
后缀（from:）
调用返回的
Self.SubSequence
实例应用
dropFirst（：）
方法。
dropFirst（:）
的返回类型也是
Self.SubSequence
，其中
Self
是调用方的类型。因为在我们的例子中，调用方是
Self.SubSequence
（其中
Self
是
seq
的类型），所以链式调用的类型是
后缀（from:start）。dropFirst（1）
是
Self.SubSequence.SubSequence
。由于该方法的返回类型为
Self.SubSequence
。。。。。。我们需要确定
Self.SubSequence
确实是与
Self.SubSequence.SubSequence
相同的类型，因此在扩展的“签名”中指定了
，其中SubSequence==SubSequence.SubSequence
。因此，最后，它简单地归结为确定我们返回了由
后缀（after:）
的方法签名指定的正确类型。希望这能把事情弄清楚！这需要一些思考：哦
extension Collection where SubSequence == SubSequence.SubSequence {
    public func suffix(after start: Index) -> SubSequence {
        return suffix(from: start).dropFirst(1)
    }
}

/* in this example, invalid indices will yield a full-array sum into
   lo or hi, depending on high or low index out of bounds, respectively */
func splitSum(of arr: [Int], at: Int) -> (Int, Int) {
    guard at < arr.count else { return (arr.reduce(0, +), 0) }
    guard at >= 0 else { return (0, arr.reduce(0, +)) }

    let lo = arr.prefix(upTo: at).reduce(0, +)
    let hi = arr.suffix(after: at).reduce(0, +)

    return (lo, hi)
}

// example usage
let arr = [Int](repeating: 1, count: 10)
print(splitSum(of: arr, at: 4)) // (4, 5)

func splitSum(of arr: [Int], at: Int) -> (Int, Int) {
    guard at < arr.count else { return (arr.reduce(0, +), 0) }
    guard at >= 0 else { return (0, arr.reduce(0, +)) }

    let sums = arr.enumerated()
        .split (omittingEmptySubsequences: false) { $0.0 == at }
        .map { $0.reduce(0) { $0 + $1.1 } }

    guard let lo = sums.first, let hi = sums.last else { fatalError() }

    return (lo, hi)
}

// example: same as above