✨ Nested NonEmpty now throws as expected

Author: RemiBardon

Sources/NonEmpty/NonEmpty+Error.swift

@@ -3,11 +3,14 @@ extension NonEmpty {
   enum Error: Swift.Error, CustomStringConvertible {
 
     case emptyCollection
-
+    case tooFewElements(expected: Int)
+    
     var description: String {
       switch self {
       case .emptyCollection:
         return "Non-empty collection expected"
+      case let .tooFewElements(expected):
+        return "Expected at least \(expected) element\(expected > 1 ? "s" : "")"
       }
     }
 

Sources/NonEmpty/NonEmpty+Nested.swift

@@ -69,6 +69,37 @@ public func AtLeast10<C: Swift.Collection>(_ c: C) throws -> _AtLeast10<C> {
   try NonEmpty(AtLeast9(c))
 }
 
+public func AtLeast1<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast1<NonEmpty<C>> {
+  try NonEmpty(nonEmpty)
+}
+public func AtLeast2<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast2<NonEmpty<C>> {
+  try NonEmpty(AtLeast1(nonEmpty))
+}
+public func AtLeast3<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast3<NonEmpty<C>> {
+  try NonEmpty(AtLeast2(nonEmpty))
+}
+public func AtLeast4<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast4<NonEmpty<C>> {
+  try NonEmpty(AtLeast3(nonEmpty))
+}
+public func AtLeast5<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast5<NonEmpty<C>> {
+  try NonEmpty(AtLeast4(nonEmpty))
+}
+public func AtLeast6<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast6<NonEmpty<C>> {
+  try NonEmpty(AtLeast5(nonEmpty))
+}
+public func AtLeast7<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast7<NonEmpty<C>> {
+  try NonEmpty(AtLeast6(nonEmpty))
+}
+public func AtLeast8<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast8<NonEmpty<C>> {
+  try NonEmpty(AtLeast7(nonEmpty))
+}
+public func AtLeast9<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast9<NonEmpty<C>> {
+  try NonEmpty(AtLeast8(nonEmpty))
+}
+public func AtLeast10<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws -> _AtLeast10<NonEmpty<C>> {
+  try NonEmpty(AtLeast9(nonEmpty))
+}
+
 fileprivate typealias _AtLeast11<C: Swift.Collection> = NonEmpty<_AtLeast10<C>>
 extension _AtLeast11 {
   public var drop10: NonEmpty<Collection.SubSequence> {

Sources/NonEmpty/NonEmpty.swift

@@ -6,12 +6,15 @@ public struct NonEmpty<Collection: Swift.Collection>: Swift.Collection {
   public var head: Collection.Element { self[self.startIndex] }
   public internal(set) var tail: Slice<Collection>
 
+  public let minimumCount: Int
+
   public init(from rawValue: Slice<Collection>) throws {
     guard !rawValue.isEmpty else {
       throw Self.Error.emptyCollection
     }
     let bounds = (rawValue.index(after: rawValue.startIndex))..<rawValue.endIndex
     self.tail = Slice(base: rawValue.base, bounds: bounds)
+    self.minimumCount = 1
   }
 
   public init(from rawValue: Collection) throws {
@@ -23,6 +26,10 @@ public struct NonEmpty<Collection: Swift.Collection>: Swift.Collection {
   }
 
   public init<C: Swift.Collection>(_ nonEmpty: NonEmpty<C>) throws where Collection == NonEmpty<C> {
+    self.minimumCount = nonEmpty.minimumCount + 1
+    guard !nonEmpty.tail.dropFirst(nonEmpty.minimumCount).isEmpty else {
+      throw Self.Error.tooFewElements(expected: self.minimumCount)
+    }
     let tail = try NonEmpty<C>(from: nonEmpty.tail)
     self.tail = Slice(base: nonEmpty, bounds: tail.startIndex..<tail.endIndex)
   }

Tests/NonEmptyTests/NonEmptyTests.swift

@@ -240,15 +240,38 @@ final class NonEmptyTests: XCTestCase {
     XCTAssertEqual(atLeast10.eighth,  8)
     XCTAssertEqual(atLeast10.ninth,   9)
     XCTAssertEqual(atLeast10.tenth,  10)
-
-    let exactly21 = try AtLeast10(AtLeast10([0] + digits + digits.map { $0 + 10 }))
+    
+    let nonEmpty = try NonEmpty(from: digits)
+    XCTAssertEqual(nonEmpty.minimumCount, 1)
+    
+    let atLeast2 = try AtLeast2(digits)
+    XCTAssertEqual(atLeast2.minimumCount, 2)
+    
+    let atLeast4 = try AtLeast2(AtLeast2(digits))
+    XCTAssertEqual(atLeast4.minimumCount, 4)
+
+    let exactly21 = try AtLeast10(AtLeast10(Array(0...20)))
     XCTAssertEqual(exactly21.count, 21)
     XCTAssertEqual(exactly21[12], 12)
 
     let atLeast42 = try AtLeast10(AtLeast10(AtLeast10(AtLeast10(AtLeast2(Array(1...100))))))
     XCTAssertEqual(atLeast42.count, 100)
     XCTAssertEqual(atLeast42.drop10.drop10.count, 80)
     XCTAssertEqual(atLeast42.drop10.drop10.drop10.drop10.second, 42)
+
+    XCTAssertThrowsError(try NonEmpty(NonEmpty(from: digits.prefix(1))))
+    XCTAssertThrowsError(try AtLeast2(digits.prefix(1)))
+    XCTAssertThrowsError(try AtLeast3(digits.prefix(2)))
+    XCTAssertThrowsError(try AtLeast4(digits.prefix(3)))
+    XCTAssertThrowsError(try AtLeast5(digits.prefix(4)))
+    XCTAssertThrowsError(try AtLeast6(digits.prefix(5)))
+    XCTAssertThrowsError(try AtLeast7(digits.prefix(6)))
+    XCTAssertThrowsError(try AtLeast8(digits.prefix(7)))
+    XCTAssertThrowsError(try AtLeast9(digits.prefix(8)))
+    XCTAssertThrowsError(try AtLeast10(digits.prefix(9)))
+    XCTAssertThrowsError(try AtLeast10(AtLeast10(Array(1...19))), (try! AtLeast10(AtLeast10(Array(1...19)))).minimumCount.description)
+
+    XCTAssertNoThrow(try AtLeast10(AtLeast10(Array(1...20))))
   }
 }