Expand require extensions with features for collections and type casting, additional features for Bool

Author: insidegui

Sources/BuddyFoundation/Foundation/Bool+Require.swift

@@ -0,0 +1,50 @@
+public extension Bool {
+    /// Throws an error if the bool value is `false`.
+    /// - Parameter error: The error to throw if the value is `false`.
+    /// - Returns: `true` if the value was `true` (discardable result).
+    @discardableResult
+    func require<E: Error>(_ error: E) throws(E) -> Self {
+        guard self else { throw error }
+        return true
+    }
+
+    /// Throws an error if the bool value is `false`.
+    /// - Parameter error: The error to throw if the value is `false`.
+    /// - Returns: `true` if the value was true (discardable result).
+    @discardableResult
+    func requireTrue<E: Error>(_ error: E) throws(E) -> Self {
+        guard self else { throw error }
+        return true
+    }
+
+    /// Throws an error if the bool value is `true`.
+    /// - Parameter error: The error to throw if the value is `false`.
+    /// - Returns: `true` if the value was `false` (discardable result).
+    @discardableResult
+    func requireFalse<E: Error>(_ error: E) throws(E) -> Self {
+        guard !self else { throw error }
+        return true
+    }
+}
+
+public extension Optional where Wrapped == Bool {
+    /// Throws an error if the wrapped bool value is `false` or if the optional is `nil`.
+    /// - Parameter error: The error to throw if the wrapped value is `false` or the optional is `nil`.
+    /// - Returns: `true` if the wrapped value was `true` (discardable result).
+    @discardableResult
+    func requireTrue<E: Error>(_ error: E) throws(E) -> Bool {
+        guard let self else { throw error }
+        guard self else { throw error }
+        return true
+    }
+
+    /// Throws an error if the wrapped bool value is `true` or if the optional is `nil`.
+    /// - Parameter error: The error to throw if the wrapped value is `true` or the optional is `nil`.
+    /// - Returns: `true` if the wrapped value was `false` (discardable result).
+    @discardableResult
+    func requireFalse<E: Error>(_ error: E) throws(E) -> Bool {
+        guard let self else { throw error }
+        guard !self else { throw error }
+        return true
+    }
+}

Sources/BuddyFoundation/Foundation/Require/Bool+Require.swift

@@ -0,0 +1,19 @@
+public extension Collection {
+    /// Throws an error if the collection is empty.
+    /// - Parameter error: The error to throw if the collection is empty.
+    /// - Returns: The non-empty collection (discardable result).
+    @discardableResult
+    func requireNotEmpty<E: Error>(_ error: E) throws(E) -> Self {
+        try isEmpty.requireFalse(error)
+        return self
+    }
+
+    /// Throws an error if the collection has one or more elements.
+    /// - Parameter error: The error to throw if the collection has one or more elements.
+    /// - Returns: The empty collection (discardable result).
+    @discardableResult
+    func requireEmpty<E: Error>(_ error: E) throws(E) -> Self {
+        try isEmpty.requireTrue(error)
+        return self
+    }
+}

Sources/BuddyFoundation/Foundation/Require/Collection+Require.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+/// Attempts to cast a value to a specific type, throwing an error if casting fails.
+/// - Parameters:
+///   - value: The value to be cast.
+///   - type: The type ot attempt to cast the value to.
+///   - error: The error to throw if casting the value fails.
+/// - Throws: The specified error if casting fails.
+/// - Returns: The value cast to the specified type.
+///
+/// This overload is provided for use where the type can not be inferred by the compiler, allowing the type to be specified manually.
+@_disfavoredOverload
+@discardableResult
+public func cast<T, E: Error>(_ value: @autoclosure () -> Any?, as type: T.Type, _ error: E) throws(E) -> T {
+    try cast(value(), error: error)
+}
+
+/// Attempts to cast a value to the expected type, throwing an error if casting fails.
+/// - Parameters:
+///   - value: The value to be cast.
+///   - error: The error to throw if casting the value fails.
+/// - Throws: The specified error if casting fails.
+/// - Returns: The value cast to the expected type.
+///
+/// This overload is provided for use where the type can be inferred by the compiler.
+@discardableResult
+public func cast<T, E: Error>(_ value: @autoclosure () -> Any?, error: E) throws(E) -> T {
+    let rawValue = try value().require(error)
+    guard let cast = rawValue as? T else { throw error }
+    return cast
+}

Sources/BuddyFoundation/Foundation/Optional+Require.swift renamed to Sources/BuddyFoundation/Foundation/Require/Optional+Require.swift

@@ -0,0 +1,80 @@
+import Foundation
+import Testing
+@testable import BuddyFoundation
+
+private struct TestError: Error { }
+
+@Suite
+struct RequireTests {
+    @Test func testBoolRequireTrue() throws {
+        #expect(throws: TestError.self) {
+            try false.require(TestError())
+            try false.requireTrue(TestError())
+        }
+
+        #expect(try true.require(TestError()))
+        #expect(try true.requireTrue(TestError()))
+    }
+
+    @Test func testBoolRequireFalse() throws {
+        #expect(throws: TestError.self) {
+            try true.requireFalse(TestError())
+        }
+
+        #expect(try false.requireFalse(TestError()))
+    }
+
+    @Test func testOptionalBoolRequireTrue() throws {
+        #expect(throws: TestError.self) {
+            try Optional<Bool>.some(false).requireTrue(TestError())
+        }
+
+        #expect(try Optional<Bool>.some(true).requireTrue(TestError()))
+    }
+
+    @Test func testOptionalBoolRequireFalse() throws {
+        #expect(throws: TestError.self) {
+            try Optional<Bool>.some(true).requireFalse(TestError())
+        }
+
+        #expect(try Optional<Bool>.some(false).requireFalse(TestError()))
+    }
+
+    @Test func testOptionalRequire() throws {
+        #expect(throws: TestError.self) {
+            let string: String? = nil
+            try string.require(TestError())
+        }
+
+        let string: String? = "Hello"
+        #expect(try string.require(TestError()) == "Hello")
+    }
+
+    @Test func testCollectionRequireNotEmpty() throws {
+        #expect(throws: TestError.self) {
+            try Array<String>().requireNotEmpty(TestError())
+        }
+
+        let array: [String] = ["Hello"]
+        #expect(try array.requireNotEmpty(TestError()) == ["Hello"])
+    }
+
+    @Test func testCollectionRequireEmpty() throws {
+        #expect(throws: TestError.self) {
+            let array: [String] = ["Hello"]
+            try array.requireEmpty(TestError())
+        }
+
+        #expect(try Array<String>().requireEmpty(TestError()) == [])
+    }
+
+    @Test func testCastRequire() throws {
+        let erasedValue: Any? = "Hello"
+
+        #expect(throws: TestError.self) {
+            let _: Int = try cast(erasedValue, error: TestError())
+        }
+
+        #expect(try cast(erasedValue, error: TestError()) == "Hello")
+    }
+}