swift4, general function : sequence(first:next:) issue - Out of bounds: index >= endIndex - swift4

Question

I am learning Ray Wenderlich's LinkedList of Algorithm and data Structure
The code is OK:
let nodes = sequence(first: lhs.node) { $0?.next }
The code is not OK:
let nodes = sequence(first: lhs.node, next: { aNode -> Node<Value>? in
aNode?.next
})// The question is here
I want to know how to right the Swift gramma
To operator the LinkedList, the issue is here:
public struct LinkedList<Value> {
public var head: Node<Value>?
public var tail: Node<Value>?
public init() {}
public var isEmpty: Bool {
return head == nil
}
public mutating func push(_ value: Value) {
copyNodes()
head = Node(value: value, next: head)
if tail == nil {
tail = head
}
}
public mutating func append(_ value: Value) {
copyNodes()
guard !isEmpty else {
push(value)
return
}
tail!.next = Node(value: value)
tail = tail!.next
}
public func node(at index: Int) -> Node<Value>? {
var currentNode = head
var currentIndex = 0
while currentNode != nil && currentIndex < index {
currentNode = currentNode!.next
currentIndex += 1
}
return currentNode
}
private mutating func copyNodes() {
guard !isKnownUniquelyReferenced(&head) else {
return
}
guard var oldNode = head else {
return
}
head = Node(value: oldNode.value)
var newNode = head
while let nextOldNode = oldNode.next {
newNode!.next = Node(value: nextOldNode.value)
newNode = newNode!.next
oldNode = nextOldNode
}
tail = newNode
}
}
extension LinkedList: CustomStringConvertible {
public var description: String {
guard let head = head else {
return "Empty list"
}
return String(describing: head)
}
}
extension LinkedList: Collection {
public struct Index: Comparable {
public var node: Node<Value>?
static public func ==(lhs: Index, rhs: Index) -> Bool {
switch (lhs.node, rhs.node) {
case let (left?, right?):
return left.next === right.next
case (nil, nil):
return true
default:
return false
}
}
static public func <(lhs: Index, rhs: Index) -> Bool {
guard lhs != rhs else {
return false
}
var nodes = sequence(first: lhs.node) { $0?.next }
nodes = sequence(first: lhs.node, next: { (aNode) -> Node<Value>? in
aNode?.next
})// The question is here
// I overwrite the code to test it
return nodes.contains { $0 === rhs.node }
}
}
public var startIndex: Index {
return Index(node: head)
}
public var endIndex: Index {
return Index(node: tail?.next)
}
public func index(after i: Index) -> Index {
return Index(node: i.node?.next)
}
public subscript(position: Index) -> Value {
return position.node!.value
}
}
To Use the code:
example(of: "using collection") {
var list = LinkedList<Int>()
for i in 0...9 {
list.append(i)
}
print("Array containing last 3 elements: \(Array(list.suffix(3)))")
}
The LinkedList data structure
public class Node<Value> {
public var value: Value
public var next: Node?
public init(value: Value, next: Node? = nil) {
self.value = value
self.next = next
}
}
extension Node: CustomStringConvertible {
public var description: String {
guard let next = next else {
return "\(value)"
}
return "\(value) -> " + String(describing: next) + " "
}
}
Language sugar:
public func example(of description: String, action: () -> Void) {
print("---Example of \(description)---")
action()
print()
}
I checked apple's doc , https://developer.apple.com/documentation/swift/2015879-sequence
And have not found any nice idea.