Return to Answer

var l1 = LinkedList([1, 2, 3])
let l2 = l1
_ = l1.popFirst()
_ = l1.popLast()

It also is not necessary to make the head and node properties of NodeChain implicitly unwrapped optionals (and does not make much sense for constant properties anyway). Simple non-optional constant properties will do:

    let head: Node<Element>
    let tail: Node<Element>

var l1 = LinkedList([1, 2, 3])
let l2 = l1
l1.removeFirst()
l1.removeLast()

Some return values can be ignored

If you add the @discardableResult attribute to the popFirst() and popLast() method then a user of the library has the option to remove elements

var l1 = LinkedList([1, 2, 3])
l1.popFirst()
l1.popLast()

without getting a “Result of call to ... is unused” warning.

Performance

Performance

can be simplified to

So these nested type do not need to be generic: They can simply use the Element type of of LinkedList, i.e.

The same applies to the other nested generic types listed above.

You have nice structured the code by using separate extensions for the various protocol conformances.

(This paragraph is surely opinion-based.) The guard statement was introduced to get rid of the “if-let pyramid of doom,” it allows to unwrap a variable without introducing another scope level.

can be shortened to

So these nested type do not need to be generic: They can simply use the Element type of LinkedList, i.e.

The same applies to the other nested generic types listed above. This allows to get rid of the distracting <T> placeholders and some type aliases. It becomes obvious that the same element type is used everywhere.

You have nicely structured the code by using separate extensions for the various protocol conformances.

(This paragraph is surely opinion-based.) The guard statement was introduced to get rid of the “if-let pyramid of doom,” it allows to unwrap a variable without introducing another scope/indentation level.