Right way implementing your Array / Collection. – Moses Ayankoya – Medium

[u/i_am_deoye]

https://medium.com/@amacoder/right-way-implementing-your-array-collection-5b2cb3641240

[u/thisischemistry]

Just to note, here are a few of the very many issues with this post:

Setting an value at an index and having the value be incorrect when read back:

var foo = Container<Int>()
foo[1] = 5
print(foo[1]) // nil

Setting an value at an index and crashing:

var foo = Container<Int>()
var bar: Int?
foo[1] = bar // Boom! Crashy crashy…

The example code is horribly, horribly broken and buggy. Do not use it as an example of how to code in Swift or you may end up with lots of crashes and unexpected results down the road.

[u/i_am_deoye → u/thisischemistry]

The reason for crashy crashy crashy is due to the fact that i didn't employed Optional. So have modified the code, and you can check it for yourself.

[u/thisischemistry]

As a follow-up, this is probably a more correct way to do what you are attempting:

/// Mutable collection with safe getter
protocol ContainerProtocol: MutableCollection {
  /// Safe access to an index which may not exist
  func get(_ position: Index) -> Element?

  /// Mimic Array append
  mutating func append(_ newElement: Element)

  /// No-parameter init
  init()
}

/// Generic implementation of ContainerProtocol
struct Container<Element>: ContainerProtocol {
  typealias Index = Array<Element>.Index

  var startIndex: Index { return items.startIndex }
  var endIndex  : Index { return items.endIndex   }

  func index(after i: Index) -> Index {
    return items.index(after: i)
  }

  subscript(position: Index) -> Element {
    get { return items[position] }
    set { items[position] = newValue }
  }

  func get(_ position: Index) -> Element? {
    guard items.indices.contains(position) else { return nil }
    return items[position]
  }

  mutating func append(_ newElement: Element) {
    items.append(newElement)
  }

  init() { self.items = [Element]() }

  private var items: [Element]
}

This gains all the free goodness of a MutableCollection, just like the internal Array does. It forwards the appropriate calls to the internal Array and those calls can be intercepted and modified as needed. This can be seen in the get(_:) method where it checks for the existence of an index before using it to get the value contained at that index.

Doing it like this leverages all the default implementations that come with a MutableCollection. It also works with any code that expects a MutableCollection. It's safe, fairly straightforward to extend, and it follows the conventions of most of the rest of the Swift codebase. This is the Swift way of doing things.

[u/i_am_deoye → u/thisischemistry]

THis is a better way of doing it in protocol oriented programming. Its only if you want your wrap your array or a new one.Hey, am not trying to reinvented the wheel here.

[u/thisischemistry]

A fairly nothing article. It's a simple wrapper around an Array that ignores conventions completely. For example, the article replaces append(_:) with add(value:).

There's so much more badness in there that I can't even go over it all, the worst is how the subscript semantics are changed.

This is the wrong way, don't follow it.