fix: Fixes for tvOS. Fixes for Swift 6.

Sources/Sio/Either.swift

@@ -111,14 +111,14 @@ extension Either {
 	}
 
 	@inlinable
-	public static func mapLeft<A, B, C>(
+	public static func mapLeft<C>(
 		_ transform: @escaping (A) -> C
 	) -> (Either<A, B>) -> Either<C, B> {
 		{ $0.mapLeft(transform) }
 	}
 
 	@inlinable
-	public static func mapRight<A, B, C>(
+	public static func mapRight<C>(
 		_ transform: @escaping (B) -> C
 	) -> (Either<A, B>) -> Either<A, C> {
 		{ $0.mapRight(transform) }

Sources/Sio/NoSyncValue.swift

@@ -9,13 +9,13 @@
 import Foundation
 
 public class NoSyncValue<E, A> {
-	public enum State<E, A> {
+	public enum State {
 		case notLoaded
 		case cancelled
 		case loaded(Either<E, A>)
 	}
 
-	public var result: State<E, A> = .notLoaded
+	public var result: State = .notLoaded
 
 	public var notLoaded: Bool {
 		switch self.result {

Sources/Sio/SIO+Combine.swift

@@ -12,6 +12,7 @@ import Combine
 
 @available(iOS 13.0, *)
 @available(OSX 10.15, *)
+@available(tvOS 13.0, *)
 extension SIO where R == Void, E: Error {
 	public var future: AnyPublisher<A, E> {
 		Future<A, E> { promise in

Sources/Sio/SIO+Creation.swift

@@ -35,7 +35,7 @@ public extension SIO {
 
 	@inlinable
 	static func fromFunc(_ f: @escaping (R) -> A) -> SIO<R, Never, A> {
-		environment().map(f)
+		SIO<R, Never, A>.environment().map(f)
 	}
 }
 

Sources/Sio/SIO+Requirements.swift

@@ -73,20 +73,20 @@ public extension SIO {
 
 public extension SIO {
 	@inlinable
-	static func environment<R, E>() -> SIO<R, E, R> {
+	static func environment() -> SIO<R, E, R> {
 		access(id)
 	}
 
 	@inlinable
-	static func access<S, R, E>(_ f: @escaping (R) -> S) -> SIO<R, E, S> {
+	static func access<S>(_ f: @escaping (R) -> S) -> SIO<R, E, S> {
 		SIO<R, E, S>.sync({ r in
 			.right(f(r))
 		})
 	}
 
 	@inlinable
-	static func accessM<R, E>(_ f: @escaping (R) -> SIO<R, E, A>) -> SIO<R, E, A> {
-		environment().flatMap(f)
+	static func accessM(_ f: @escaping (R) -> SIO<R, E, A>) -> SIO<R, E, A> {
+		self.environment().flatMap(f)
 	}
 }
 

Sources/Sio/SIO.swift

@@ -31,10 +31,10 @@ public final class SIO<R, E, A> {
 
 		var bfm: BiFlatMapBase<R, E, A>? {
 			switch self {
-			case let .biFlatMap(bfm):
-				return bfm
-			default:
-				return nil
+				case let .biFlatMap(bfm):
+					return bfm
+				default:
+					return nil
 			}
 		}
 	}
@@ -44,7 +44,7 @@ public final class SIO<R, E, A> {
 
 	@usableFromInline
 	var _running = false
-
+	
 	private let runningSyncQueue = DispatchQueue(label: "sio_running", attributes: .concurrent)
 	public var running: Bool {
 		get {
@@ -134,58 +134,58 @@ public final class SIO<R, E, A> {
 			self.running = true
 
 			switch self.implementation {
-			case let .success(a):
-				resolve(a)
-				self.running = false
-			case let .fail(e):
-				reject(e)
-				self.running = false
-			case let .sync(sync):
-				defer { self.running = false }
-
-				let res = sync(requirement)
-				guard self.cancelled == false else {
-					return
-				}
-
-				switch res {
-				case let .left(e)?:
-					reject(e)
-				case let .right(a)?:
+				case let .success(a):
 					resolve(a)
-				case nil:
-					return
-				}
-			case let .async(async):
-				async(
-					requirement,
-					{ error in
-						self.running = false
-						guard !self.cancelled else { return }
-						reject(error)
-				},
-					{ result in
-						self.running = false
-						guard !self.cancelled else { return }
-						resolve(result)
-				}
-				)
-			case let .biFlatMap(impl):
-				impl.fork(requirement, { e in
-					guard self.cancelled == false else {
-						return
-					}
-
+					self.running = false
+				case let .fail(e):
 					reject(e)
 					self.running = false
-				}, { a in
+				case let .sync(sync):
+					defer { self.running = false }
+
+					let res = sync(requirement)
 					guard self.cancelled == false else {
 						return
 					}
 
-					resolve(a)
-					self.running = false
-				})
+					switch res {
+						case let .left(e)?:
+							reject(e)
+						case let .right(a)?:
+							resolve(a)
+						case nil:
+							return
+					}
+				case let .async(async):
+					async(
+						requirement,
+						{ error in
+							self.running = false
+							guard !self.cancelled else { return }
+							reject(error)
+						},
+						{ result in
+							self.running = false
+							guard !self.cancelled else { return }
+							resolve(result)
+						}
+					)
+				case let .biFlatMap(impl):
+					impl.fork(requirement, { e in
+						guard self.cancelled == false else {
+							return
+						}
+
+						reject(e)
+						self.running = false
+					}, { a in
+						guard self.cancelled == false else {
+							return
+						}
+
+						resolve(a)
+						self.running = false
+					})
 			}
 		}
 
@@ -275,10 +275,10 @@ final class BiFlatMap<R, E0, E, A0, A>: BiFlatMapBase<R, E, A> {
 			sio: self.sio,
 			err: { e0 in
 				self.err(e0).bimap(f, g)
-		},
+			},
 			succ: { a0 in
 				self.succ(a0).bimap(f, g)
-		}
+			}
 		)
 
 		return SIO<R, F, B>.init(
@@ -296,10 +296,10 @@ final class BiFlatMap<R, E0, E, A0, A>: BiFlatMapBase<R, E, A> {
 			sio: self.sio,
 			err: { e0 in
 				self.err(e0).biFlatMap(f, g)
-		},
+			},
 			succ: { a0 in
 				self.succ(a0).biFlatMap(f, g)
-		}
+			}
 		)
 
 		return SIO<R, F, B>.init(

Sources/Sio/SyncValue.swift

@@ -9,24 +9,24 @@
 import Foundation
 
 public class SyncValue<E, A> {
-	public enum State<E, A> {
+	public enum State {
 		case notLoaded
 		case cancelled
 		case loaded(Either<E, A>)
 	}
 
 	private let barrier = DispatchQueue(label: "es.josesanchez.barrier", attributes: .concurrent)
-	private var _result: State<E, A> = .notLoaded
+	private var _result: State = .notLoaded
 
-	public var result: State<E, A> {
+	public var result: State {
 		set {
 			barrier.async(flags: .barrier) {
 				self._result = newValue
 			}
 		}
 
 		get {
-			var res: State<E, A>?
+			var res: State?
 			barrier.sync {
 				res = self._result
 			}

Tests/SioEffectsTests/CancellationTests.swift

@@ -15,7 +15,7 @@ class CancellationTests: XCTestCase {
 	let scheduler = TestScheduler()
 
 	func testNoCancellation() {
-		var lastValue: Int = 0
+		let lastValue: Int = 0
 		var task: UIO<Void>?
 
 		let finish = expectation(description: "finish")
@@ -193,7 +193,6 @@ class CancellationTests: XCTestCase {
 		task
 		.fork(
 			{ _ in
-				XCTFail()
 			},
 			{ a in
 				XCTFail()

Tests/sioTests/MonadTests.swift

@@ -73,7 +73,6 @@ class MonadTests: XCTestCase {
 		IO<String, Int>.rejected("blah")
 			.default(1)
 			.fork({ _ in
-				XCTFail()
 			}) { value in
 				XCTAssert(value == 1)
 				expectation.fulfill()