Revert all unnecessary changes

There are a lot of things I changed which I could have avoided.
To make Pull Request more readable, I preferred to revert them.

Author: RemiBardon

Sources/NonEmpty/NonEmpty+Dictionary.swift

@@ -18,7 +18,6 @@ public protocol _DictionaryProtocol: Collection where Element == (key: Key, valu
 extension Dictionary: _DictionaryProtocol {}
 
 extension NonEmpty where Collection: _DictionaryProtocol {
-  @_disfavoredOverload
   public init(_ head: Element, _ tail: Collection) {
     guard !tail.keys.contains(head.key) else { fatalError("Dictionary contains duplicate key") }
     var tail = tail
@@ -88,13 +87,12 @@ extension NonEmpty where Collection: _DictionaryProtocol {
   }
 }
 
-// Commented to avoid "Ambiguous use of operator '=='", doesn't break the tests.
-//extension NonEmpty where Collection: _DictionaryProtocol, Collection.Value: Equatable {
-//  public static func == (lhs: NonEmpty, rhs: NonEmpty) -> Bool {
-//    return Dictionary(uniqueKeysWithValues: Array(lhs))
-//      == Dictionary(uniqueKeysWithValues: Array(rhs))
-//  }
-//}
+extension NonEmpty where Collection: _DictionaryProtocol, Collection.Value: Equatable {
+  public static func == (lhs: NonEmpty, rhs: NonEmpty) -> Bool {
+    return Dictionary(uniqueKeysWithValues: Array(lhs))
+      == Dictionary(uniqueKeysWithValues: Array(rhs))
+  }
+}
 
 extension NonEmpty where Collection: _DictionaryProtocol & ExpressibleByDictionaryLiteral {
   public init(_ head: Element) {

Sources/NonEmpty/NonEmpty+RangeReplaceableCollection.swift

@@ -15,25 +15,27 @@ extension NonEmptyProtocol where Collection: RangeReplaceableCollection {
   }
 
   public init?<S>(_ elements: S) where S: Sequence, Collection.Element == S.Element {
-    try? self.init(from: Collection(elements))
+    try? self.init(from: elements)
   }
+}
 
+extension NonEmpty where Collection: RangeReplaceableCollection {
   public mutating func append(_ newElement: Element) {
-    self.wrappedValue.append(newElement)
+    self.rawValue.append(newElement)
   }
 
   public mutating func append<S: Sequence>(contentsOf newElements: S) where Element == S.Element {
-    self.wrappedValue.append(contentsOf: newElements)
+    self.rawValue.append(contentsOf: newElements)
   }
 
   public mutating func insert(_ newElement: Element, at i: Index) {
-    self.wrappedValue.insert(newElement, at: i)
+    self.rawValue.insert(newElement, at: i)
   }
 
   public mutating func insert<S>(
     contentsOf newElements: S, at i: Index
   ) where S: Swift.Collection, Element == S.Element {
-    self.wrappedValue.insert(contentsOf: newElements, at: i)
+    self.rawValue.insert(contentsOf: newElements, at: i)
   }
 
   public static func += <S: Sequence>(lhs: inout Self, rhs: S) where Element == S.Element {

Sources/NonEmpty/NonEmpty.swift

@@ -1,6 +1,9 @@
 @dynamicMemberLookup
-public struct NonEmpty<Collection: Swift.Collection> {
-  public internal(set) var tail: Slice<Collection>
+public struct NonEmpty<Collection: Swift.Collection>: Swift.Collection, NonEmptyProtocol {
+  public typealias Element = Collection.Element
+  public typealias Index = Collection.Index
+
+  public internal(set) var rawValue: Collection
 
   public static var minimumCount: Int {
     if let T = Collection.self as? WithMinimumCount.Type {
@@ -10,50 +13,24 @@ public struct NonEmpty<Collection: Swift.Collection> {
     }
   }
 
-  public init(fromSlice slice: Slice<Collection>) throws {
-    guard !slice.dropFirst(Self.minimumCount - 1).isEmpty else {
+  public init(from rawValue: Collection) throws {
+    guard !rawValue.dropFirst(Self.minimumCount - 1).isEmpty else {
       if Self.minimumCount == 1 {
         throw NonEmptyError.emptyCollection
       } else {
         throw NonEmptyError.tooFewElements(expected: Self.minimumCount)
       }
     }
-    let bounds = (slice.index(after: slice.startIndex))..<slice.endIndex
-    self.tail = Slice(base: slice.base, bounds: bounds)
+    self.rawValue = rawValue
   }
 
-  public init(from wrappedValue: Collection) throws {
-    let slice = Slice(base: wrappedValue, bounds: wrappedValue.startIndex..<wrappedValue.endIndex)
-    try self.init(fromSlice: slice)
+  public init?(rawValue: Collection) {
+    try? self.init(from: rawValue)
   }
 
   public subscript<Subject>(dynamicMember keyPath: KeyPath<Collection, Subject>) -> Subject {
     self.rawValue[keyPath: keyPath]
   }
-}
-
-extension NonEmpty: NonEmptyProtocol {
-  public var wrappedValue: Collection {
-    get { self.rawValue }
-    set { self.rawValue = newValue }
-  }
-}
-
-extension NonEmpty: RawRepresentable {
-  public internal(set) var rawValue: Collection {
-    get { tail.base }
-    set {
-      self = try! Self.init(from: newValue)
-    }
-  }
-  public init?(rawValue: Collection) {
-    try? self.init(from: rawValue)
-  }
-}
-
-extension NonEmpty: Swift.Collection {
-  public typealias Element = RawValue.Element
-  public typealias Index = RawValue.Index
 
   public var startIndex: Index { self.rawValue.startIndex }
 
@@ -109,7 +86,7 @@ extension NonEmpty: Swift.Collection {
 
 extension NonEmpty: CustomStringConvertible {
   public var description: String {
-    String(describing: self.rawValue)
+    return String(describing: self.rawValue)
   }
 }
 
@@ -141,6 +118,8 @@ extension NonEmpty: Decodable where Collection: Decodable {
   }
 }
 
+extension NonEmpty: RawRepresentable {}
+
 extension NonEmpty where Collection.Element: Comparable {
   public func max() -> Element {
     self.rawValue.max()!
@@ -155,10 +134,10 @@ extension NonEmpty where Collection.Element: Comparable {
   }
 }
 
-extension NonEmpty: BidirectionalCollection where RawValue: BidirectionalCollection {
+extension NonEmpty: BidirectionalCollection where Collection: BidirectionalCollection {
   public var last: Element { self.rawValue.last! }
 }
-extension NonEmptyProtocol where RawValue: BidirectionalCollection {
+extension NonEmptyProtocol where Collection: BidirectionalCollection {
   public func index(before i: Index) -> Index {
     self.rawValue.index(before: i)
   }

Sources/NonEmpty/NonEmptyProtocol.swift

@@ -5,19 +5,14 @@ public protocol WithMinimumCount {
 }
 
 public protocol NonEmptyProtocol: Swift.Collection, RawRepresentable, WithMinimumCount
-where RawValue: Swift.Collection,
-      Element == RawValue.Element,
+where Element == RawValue.Element,
       Index == RawValue.Index,
-      Collection.Element == Element,
-      Collection.Index == Index
+      Collection == RawValue
 {
   associatedtype Collection: Swift.Collection
-  var tail: Slice<Collection> { get }
-  var wrappedValue: Collection { get set }
-  init(from wrappedValue: Collection) throws
+  init(from rawValue: Collection) throws
 }
 
 extension NonEmptyProtocol {
-  public var head: Element { self[self.startIndex] }
-  public var first: Element { head }
+  public var first: Element { self[self.startIndex] }
 }