@fncts/test 0.0.12 → 0.0.13

package/_src/control/Gen/api.ts

@@ -14,7 +14,7 @@ import { Gen } from "./definition.js";
 /**
  * @tsplus static fncts.test.GenOps anyBigInt
  */
-export const anyBigInt: Gen<unknown, bigint> = fromIOSample(
+export const anyBigInt: Gen<never, bigint> = fromIOSample(
   Random.nextBigIntBetween(BigInt(-1) << BigInt(255), (BigInt(1) << BigInt(255)) - BigInt(1)).map(
     Sample.shrinkBigInt(BigInt(0)),
   ),
@@ -23,12 +23,12 @@ export const anyBigInt: Gen<unknown, bigint> = fromIOSample(
 /**
  * @tsplus static fncts.test.GenOps anyDouble
  */
-export const anyDouble: Gen<unknown, number> = Gen.fromIOSample(Random.nextDouble.map(Sample.shrinkFractional(0)));
+export const anyDouble: Gen<never, number> = Gen.fromIOSample(Random.nextDouble.map(Sample.shrinkFractional(0)));
 
 /**
  * @tsplus static fncts.test.GenOps anyInt
  */
-export const anyInt: Gen<unknown, number> = Gen.fromIOSample(Random.nextInt.map(Sample.shrinkIntegral(0)));
+export const anyInt: Gen<never, number> = Gen.fromIOSample(Random.nextInt.map(Sample.shrinkIntegral(0)));
 
 /**
  * @tsplus static fncts.test.GenOps bounded
@@ -40,14 +40,14 @@ export function bounded<R, A>(min: number, max: number, f: (n: number) => Gen<R,
 /**
  * @tsplus static fncts.test.GenOps constant
  */
-export function constant<A>(a: A): Gen<unknown, A> {
+export function constant<A>(a: A): Gen<never, A> {
   return new Gen(Stream.succeedNow(Just(Sample.noShrink(a))));
 }
 
 /**
  * @tsplus fluent fncts.test.Gen flatMap
  */
-export function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R & R1, B> {
+export function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R | R1, B> {
   return new Gen(
     Sample.flatMapStream(ma.sample, (sample) => {
       const values  = f(sample.value).sample;
@@ -67,7 +67,7 @@ export function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A> {
 /**
  * @tsplus static fncts.test.GenOps empty
  */
-export const empty: Gen<unknown, never> = new Gen(Stream.empty);
+export const empty: Gen<never, never> = new Gen(Stream.empty);
 
 /**
  * @tsplus fluent fncts.test.Gen filter
@@ -88,7 +88,7 @@ export function filterNot_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A> {
 /**
  * @tsplus getter fncts.test.Gen flatten
  */
-export function flatten<R, R1, A>(mma: Gen<R, Gen<R1, A>>): Gen<R & R1, A> {
+export function flatten<R, R1, A>(mma: Gen<R, Gen<R1, A>>): Gen<R | R1, A> {
   return mma.flatMap(identity);
 }
 
@@ -109,7 +109,7 @@ export function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>): Gen<R, A
 /**
  * @tsplus static fncts.test.GenOps int
  */
-export function int(constraints: NumberConstraints = {}): Gen<unknown, number> {
+export function int(constraints: NumberConstraints = {}): Gen<never, number> {
   return Gen.fromIOSample(
     IO.defer(() => {
       const min = constraints.min ?? -0x80000000;
@@ -133,7 +133,7 @@ export function map_<R, A, B>(self: Gen<R, A>, f: (a: A) => B): Gen<R, B> {
 /**
  * @tsplus fluent fncts.test.Gen mapIO
  */
-export function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R & R1, B> {
+export function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R | R1, B> {
   return new Gen(
     self.sample.mapIO((maybeSample) =>
       maybeSample.match(
@@ -147,17 +147,17 @@ export function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never,
 /**
  * @tsplus static fncts.test.GenOps exponential
  */
-export const exponential: Gen<unknown, number> = Gen.uniform.map((n) => -Math.log(1 - n));
+export const exponential: Gen<never, number> = Gen.uniform.map((n) => -Math.log(1 - n));
 
 /**
  * @tsplus static fncts.test.GenOps size
  */
-export const size: Gen<Has<Sized>, number> = Gen.fromIO(Sized.size);
+export const size: Gen<Sized, number> = Gen.fromIO(Sized.size);
 
 /**
  * @tsplus static fncts.test.GenOps medium
  */
-export function medium<R, A>(f: (n: number) => Gen<R, A>, min = 0): Gen<R & Has<Sized>, A> {
+export function medium<R, A>(f: (n: number) => Gen<R, A>, min = 0): Gen<R | Sized, A> {
   return Gen.size
     .flatMap((max) => Gen.exponential.map((n) => clamp(Math.round((n * max) / 10.0), min, max)))
     .reshrink(Sample.shrinkIntegral(min))
@@ -200,9 +200,9 @@ export function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_
 /**
  * @tsplus fluent fncts.test.Gen reshrink
  */
-export function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R & R1, B> {
+export function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R | R1, B> {
   return new Gen(
-    (gen.sample as Stream<R & R1, never, Maybe<Sample<R, A>>>).map((maybeSample) =>
+    (gen.sample as Stream<R | R1, never, Maybe<Sample<R, A>>>).map((maybeSample) =>
       maybeSample.map((sample) => f(sample.value)),
     ),
   );
@@ -211,14 +211,14 @@ export function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B
 /**
  * @tsplus static fncts.test.GenOps sized
  */
-export function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R & Has<Sized>, A> {
+export function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R | Sized, A> {
   return Gen.size.flatMap(f);
 }
 
 /**
  * @tsplus static fncts.test.GenOps small
  */
-export function small<R, A>(f: (size: number) => Gen<R, A>, min = 0): Gen<R & Has<Sized>, A> {
+export function small<R, A>(f: (size: number) => Gen<R, A>, min = 0): Gen<R | Sized, A> {
   return Gen.size
     .flatMap((max) => Gen.exponential.map((n) => clamp(Math.round((n * max) / 25), min, max)))
     .reshrink(Sample.shrinkIntegral(min))
@@ -228,7 +228,7 @@ export function small<R, A>(f: (size: number) => Gen<R, A>, min = 0): Gen<R & Ha
 /**
  * @tsplus static fncts.test.GenOps unfoldGen
  */
-export function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R & Has<Sized>, Conc<A>> {
+export function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R | Sized, Conc<A>> {
   return Gen.small((n) => Gen.unfoldGenN(n, s, f));
 }
 
@@ -243,12 +243,12 @@ export function unfoldGenN<S, R, A>(n: number, s: S, f: (s: S) => Gen<R, readonl
 /**
  * @tsplus static fncts.test.GenOps uniform
  */
-export const uniform: Gen<unknown, number> = Gen.fromIOSample(Random.nextDouble.map(Sample.shrinkFractional(0.0)));
+export const uniform: Gen<never, number> = Gen.fromIOSample(Random.nextDouble.map(Sample.shrinkFractional(0.0)));
 
 /**
  * @tsplus static fncts.test.GenOps unwrap
  */
-export function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R & R1, A> {
+export function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R | R1, A> {
   return Gen.fromIO(effect).flatten;
 }
 
@@ -271,6 +271,6 @@ export function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A>, numbe
 /**
  * @tsplus fluent fncts.test.Gen zipWith
  */
-export function zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R & R1, C> {
+export function zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R | R1, C> {
   return self.flatMap((a) => that.map((b) => f(a, b)));
 }

package/_src/control/Gen/definition.ts

@@ -5,5 +5,7 @@ import type { Sample } from "../Sample.js";
  * @tsplus companion fncts.test.GenOps
  */
 export class Gen<R, A> {
+  declare _R: () => R;
+  declare _A: () => A;
   constructor(readonly sample: Stream<R, never, Maybe<Sample<R, A>>>) {}
 }

package/_src/control/Live/definition.ts

@@ -13,7 +13,7 @@ export const LiveTag = Tag<Live>();
 export abstract class Live {
   abstract provide<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
 
-  static Default: Layer<IOEnv, never, Has<Live>> = Layer.fromIO(
+  static Default: Layer<IOEnv, never, Live> = Layer.fromIO(
     IO.environmentWith(
       (env) =>
         new (class extends Live {
@@ -25,7 +25,7 @@ export abstract class Live {
     LiveTag,
   );
 
-  static Live<R extends Has<Live>, E, A>(io: IO<R, E, A>): IO<R & Has<Live>, E, A> {
+  static Live<R extends Live, E, A>(io: IO<R, E, A>): IO<R | Live, E, A> {
     return IO.serviceWithIO((live) => live.provide(io), LiveTag);
   }
 }
@@ -35,13 +35,13 @@ export abstract class Live {
  */
 export function withLive_<R, E, A, E1, B>(
   io: IO<R, E, A>,
-  f: (_: IO<unknown, E, A>) => IO<IOEnv, E1, B>,
-): IO<Erase<R, Has<Live>>, E | E1, B> {
+  f: (_: IO<never, E, A>) => IO<IOEnv, E1, B>,
+): IO<Exclude<R, Live>, E | E1, B> {
   // @ts-expect-error
-  return IO.environment<R & Has<Live>>().flatMap((r) => Live.Live(f(io.provideEnvironment(r))));
+  return IO.environment<R | Live>().flatMap((r) => Live.Live(f(io.provideEnvironment(r))));
 }
 
-export function withLive<R extends Has<Live>, E, A>(io: IO<R, E, A>) {
-  return <E1, B>(f: (_: IO<R, E, A>) => IO<R, E1, B>): IO<R & Has<Live>, E1, B> =>
+export function withLive<R extends Live, E, A>(io: IO<R, E, A>) {
+  return <E1, B>(f: (_: IO<R, E, A>) => IO<R, E1, B>): IO<R | Live, E1, B> =>
     IOEnv.services.getWith((services) => Live.Live(f(IOEnv.services.locally(services)(io))));
 }

package/_src/control/RunnableSpec.ts

@@ -9,10 +9,10 @@ import { TestLogger } from "@fncts/test/control/TestLogger";
 
 export abstract class RunnableSpec<R, E> extends AbstractRunnableSpec<R, E> {
   readonly _tag = "RunnableSpec";
-  run(spec: Spec<R, E>): URIO<Has<TestLogger>, number> {
+  run(spec: Spec<R, E>): URIO<TestLogger, number> {
     const self = this;
-    return IO.gen(function* (_) {
-      const results     = yield* _(self.runSpec(spec));
+    return Do((_) => {
+      const results     = _(self.runSpec(spec));
       const hasFailures = results.exists(
         matchTag(
           {
@@ -22,7 +22,7 @@ export abstract class RunnableSpec<R, E> extends AbstractRunnableSpec<R, E> {
         ),
       );
       const summary = SummaryBuilder.buildSummary(results);
-      yield* _(TestLogger.logLine(summary.summary));
+      _(TestLogger.logLine(summary.summary));
       return hasFailures ? 1 : 0;
     });
   }

package/_src/control/Sample/api.ts

@@ -10,7 +10,7 @@ import { Sample } from "./definition.js";
 /**
  * @tsplus fluent fncts.test.Sample flatMap
  */
-export function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R & R1, B> {
+export function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R | R1, B> {
   const sample = f(ma.value);
   return new Sample(
     sample.value,
@@ -45,7 +45,7 @@ export function filter_<R, A>(ma: Sample<R, A>, f: Predicate<A>): Stream<R, neve
 export function foreach_<R, A, R1, B>(
   ma: Sample<R, A>,
   f: (a: A) => IO<R1, never, B>,
-): IO<R & R1, never, Sample<R & R1, B>> {
+): IO<R | R1, never, Sample<R | R1, B>> {
   return f(ma.value).map(
     (b) =>
       new Sample(
@@ -104,28 +104,28 @@ export function unfold<R, A, S>(s: S, f: (s: S) => readonly [A, Stream<R, never,
 /**
  * @tsplus fluent fncts.test.Sample zip
  */
-export function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R & R1, readonly [A, B]> {
+export function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R | R1, readonly [A, B]> {
   return ma.zipWith(mb, tuple);
 }
 
 /**
  * @tsplus fluent fncts.test.Sample zipWith
  */
-export function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R & R1, C> {
+export function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R | R1, C> {
   return ma.flatMap((a) => map_(mb, (b) => f(a, b)));
 }
 
 /**
  * @tsplus static fncts.test.SampleOps noShrink
  */
-export function noShrink<A>(a: A): Sample<unknown, A> {
+export function noShrink<A>(a: A): Sample<never, A> {
   return new Sample(a, Stream.empty);
 }
 
 /**
  * @tsplus static fncts.test.SampleOps shrinkFractional
  */
-export function shrinkFractional(smallest: number): (a: number) => Sample<unknown, number> {
+export function shrinkFractional(smallest: number): (a: number) => Sample<never, number> {
   return (a) =>
     Sample.unfold(a, (max) =>
       tuple(
@@ -155,7 +155,7 @@ function bigIntAbs(x: bigint): bigint {
 /**
  * @tsplus static fncts.test.SampleOps shrinkBigInt
  */
-export function shrinkBigInt(smallest: bigint): (a: bigint) => Sample<unknown, bigint> {
+export function shrinkBigInt(smallest: bigint): (a: bigint) => Sample<never, bigint> {
   return (a) =>
     Sample.unfold(a, (max) =>
       tuple(
@@ -177,7 +177,7 @@ export function shrinkBigInt(smallest: bigint): (a: bigint) => Sample<unknown, b
 /**
  * @tsplus static fncts.test.SampleOps shrinkIntegral
  */
-export function shrinkIntegral(smallest: number): (a: number) => Sample<unknown, number> {
+export function shrinkIntegral(smallest: number): (a: number) => Sample<never, number> {
   return (a) =>
     Sample.unfold(a, (max) =>
       tuple(
@@ -199,7 +199,7 @@ export function shrinkIntegral(smallest: number): (a: number) => Sample<unknown,
 /**
  * @tsplus static fncts.test.SampleOps shrinkArrayInt64
  */
-export function shrinkArrayInt64(target: ArrayInt64): (value: ArrayInt64) => Sample<unknown, ArrayInt64> {
+export function shrinkArrayInt64(target: ArrayInt64): (value: ArrayInt64) => Sample<never, ArrayInt64> {
   return (value) =>
     Sample.unfold(value, (max) =>
       tuple(
@@ -219,8 +219,8 @@ export function shrinkArrayInt64(target: ArrayInt64): (value: ArrayInt64) => Sam
 function mergeStream<R, A, R1, B>(
   left: Stream<R, never, Maybe<A>>,
   right: Stream<R1, never, Maybe<B>>,
-): Stream<R & R1, never, Maybe<A | B>> {
-  return flatMapStream(Stream.fromChunk(Conc(Just<Stream<R & R1, never, Maybe<A | B>>>(left), Just(right))), identity);
+): Stream<R | R1, never, Maybe<A | B>> {
+  return flatMapStream(Stream.fromChunk(Conc(Just<Stream<R | R1, never, Maybe<A | B>>>(left), Just(right))), identity);
 }
 
 /**
@@ -229,7 +229,7 @@ function mergeStream<R, A, R1, B>(
 export function flatMapStream<R, A, R1, B>(
   stream: Stream<R, never, Maybe<A>>,
   f: (a: A) => Stream<R1, never, Maybe<B>>,
-): Stream<R & R1, never, Maybe<B>> {
+): Stream<R | R1, never, Maybe<B>> {
   return new Stream(
     stream.rechunk(1).channel.concatMapWithCustom(
       (values) =>

package/_src/control/Sized/api.ts

@@ -3,12 +3,12 @@ import { Sized } from "./definition.js";
 /**
  * @tsplus static fncts.test.SizedOps size
  */
-export const size: URIO<Has<Sized>, number> = IO.serviceWithIO((sized) => sized.size, Sized.Tag);
+export const size: URIO<Sized, number> = IO.serviceWithIO((sized) => sized.size, Sized.Tag);
 
 /**
  * @tsplus static fncts.test.SizedOps withSize
  */
 export function withSize(size: number) {
-  return <R, E, A>(io: IO<R, E, A>): IO<R & Has<Sized>, E, A> =>
+  return <R, E, A>(io: IO<R, E, A>): IO<R | Sized, E, A> =>
     IO.serviceWithIO((sized) => sized.withSize(size)(io), Sized.Tag);
 }

package/_src/control/Sized/live.ts

@@ -3,7 +3,7 @@ import { Sized } from "./definition.js";
 /**
  * @tsplus static fncts.test.SizedOps Live
  */
-export function Live(size: number): Layer<unknown, never, Has<Sized>> {
+export function Live(size: number): Layer<never, never, Sized> {
   return Layer.scoped(
     FiberRef.make(size).map(
       (ref) =>

package/_src/control/Spec/api.ts

@@ -17,7 +17,7 @@ import { ExecCase, LabeledCase, MultipleCase, PSpec, ScopedCase, TestCase } from
 /**
  * @tsplus getter fncts.test.PSpec annotated
  */
-export function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R & Has<Annotations>, Annotated<E>, Annotated<T>> {
+export function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R | Annotations, Annotated<E>, Annotated<T>> {
   return spec.transform(
     matchTag(
       {
@@ -35,7 +35,7 @@ export function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R & Has<Annotati
 export function combine_<R, E, T, R1, E1, T1>(
   self: PSpec<R, E, T>,
   that: PSpec<R1, E1, T1>,
-): PSpec<R & R1, E | E1, T | T1> {
+): PSpec<R | R1, E | E1, T | T1> {
   if (self.caseValue.isMultiple() && that.caseValue.isMultiple()) {
     return MultipleCase(self.caseValue.specs.concat(that.caseValue.specs));
   }
@@ -45,7 +45,7 @@ export function combine_<R, E, T, R1, E1, T1>(
   if (that.caseValue.isMultiple()) {
     return MultipleCase(that.caseValue.specs.prepend(self));
   }
-  return MultipleCase(Conc<PSpec<R & R1, E | E1, T | T1>>(self, that));
+  return MultipleCase(Conc<PSpec<R | R1, E | E1, T | T1>>(self, that));
 }
 
 /**
@@ -60,8 +60,8 @@ export function contramapEnvironment_<R, E, T, R0>(
       {
         Scoped: ({ scoped }) =>
           new ScopedCase(
-            scoped.contramapEnvironment((r: Environment<R0 & Has<Scope>>) =>
-              Environment.empty.add(r.get(Scope.Tag), Scope.Tag).union(f(r)),
+            scoped.contramapEnvironment((r: Environment<R0 | Scope>) =>
+              Environment.empty.add(r.get(Scope.Tag), Scope.Tag).union(f(r as Environment<R0>)),
             ),
           ),
         Test: ({ test, annotations }) => new TestCase(test.contramapEnvironment(f), annotations),
@@ -74,7 +74,7 @@ export function contramapEnvironment_<R, E, T, R0>(
 /**
  * @tsplus fluent fncts.test.PSpec countTests
  */
-export function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R & Has<Scope>, E, number> {
+export function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R | Scope, E, number> {
   return spec.fold(
     matchTag({
       Exec: ({ spec }) => spec,
@@ -89,7 +89,7 @@ export function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean)
 /**
  * @tsplus static fncts.test.PSpecOps empty
  */
-export const empty: PSpec<unknown, never, never> = multipleCase(Conc.empty());
+export const empty: PSpec<never, never, never> = multipleCase(Conc.empty());
 
 /**
  * @tsplus static fncts.test.PSpecOps exec
@@ -105,8 +105,8 @@ export function exec<R, E, T>(spec: PSpec<R, E, T>, exec: ExecutionStrategy): PS
 export function execute<R, E, T>(
   self: PSpec<R, E, T>,
   defExec: ExecutionStrategy,
-): IO<R & Has<Scope>, never, PSpec<unknown, E, T>> {
-  return IO.environmentWithIO((r: Environment<R & Has<Scope>>) =>
+): IO<R | Scope, never, PSpec<never, E, T>> {
+  return IO.environmentWithIO((r: Environment<R | Scope>) =>
     self.provideEnvironment(r).foreachExec(IO.failCauseNow, IO.succeedNow, defExec),
   );
 }
@@ -186,9 +186,9 @@ export function fold_<R, E, T, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T,
  */
 export function foldScoped_<R, E, T, R1, E1, Z>(
   spec: PSpec<R, E, T>,
-  f: (_: SpecCase<R, E, T, Z>) => IO<R1 & Has<Scope>, E1, Z>,
+  f: (_: SpecCase<R, E, T, Z>) => IO<R1 | Scope, E1, Z>,
   defExec: ExecutionStrategy,
-): IO<R & R1 & Has<Scope>, E1, Z> {
+): IO<R | R1 | Scope, E1, Z> {
   return matchTag_(spec.caseValue, {
     Exec: ({ exec, spec }) => spec.foldScoped(f, exec).flatMap((z) => f(new ExecCase(exec, z))),
     Labeled: ({ label, spec }) => spec.foldScoped(f, defExec).flatMap((z) => f(new LabeledCase(label, z))),
@@ -213,7 +213,7 @@ export function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(
   failure: (c: Cause<E>) => IO<R1, E1, A>,
   success: (t: T) => IO<R2, E2, B>,
   defExec: ExecutionStrategy,
-): IO<R & R1 & R2 & Has<Scope>, never, PSpec<R & R1 & R2, E1 | E2, A | B>> {
+): IO<R | R1 | R2 | Scope, never, PSpec<R | R1 | R2, E1 | E2, A | B>> {
   return spec.foldScoped(
     matchTag({
       Exec: ({ exec, spec }) => IO.succeedNow(ExecCase(spec, exec)),
@@ -248,7 +248,7 @@ export function labeledCase<R, E, T>(spec: PSpec<R, E, T>, label: string): PSpec
  * @tsplus static fncts.test.PSpecOps scoped
  * @tsplus static fncts.test.PSpec.ScopedCaseOps __call
  */
-export function scoped<R, E, T>(managed: IO<R & Has<Scope>, E, PSpec<R, E, T>>): PSpec<R, E, T> {
+export function scoped<R, E, T>(managed: IO<R | Scope, E, PSpec<R, E, T>>): PSpec<R, E, T> {
   return new PSpec(new ScopedCase(managed));
 }
 
@@ -292,21 +292,21 @@ export function multipleCase<R, E, T>(specs: Conc<PSpec<R, E, T>>): PSpec<R, E,
 /**
  * @tsplus fluent fncts.test.PSpec provideEnvironment
  */
-export function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<unknown, E, T> {
+export function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<never, E, T> {
   return self.contramapEnvironment(() => r);
 }
 
 /**
  * @tsplus fluent fncts.test.PSpec provideLayer
  */
-export function provideLayer_<RIn, E, ROut extends Spreadable, R, E1, T>(
+export function provideLayer_<RIn, E, ROut, E1, T>(
   self: PSpec<ROut, E1, T>,
   layer: Layer<RIn, E, ROut>,
 ): PSpec<RIn, E | E1, T> {
   return self.transform(
     matchTag(
       {
-        Scoped: ({ scoped }) => new ScopedCase(scoped.provideLayer(Layer.environment<Has<Scope>>().and(layer))),
+        Scoped: ({ scoped }) => new ScopedCase(scoped.provideLayer(Layer.environment<Scope>().and(layer))),
         Test: ({ test, annotations }) => new TestCase(test.provideLayer(layer), annotations),
       },
       identity,
@@ -359,7 +359,7 @@ export function annotate_<R, E, T, V>(self: PSpec<R, E, T>, key: TestAnnotation<
 export function whenIO_<R, E, R1, E1>(
   self: PSpec<R, E, TestSuccess>,
   b: IO<R1, E1, boolean>,
-): PSpec<R & R1 & Has<Annotations>, E | E1, TestSuccess> {
+): PSpec<R | R1 | Annotations, E | E1, TestSuccess> {
   return matchTag_(self.caseValue, {
     Exec: (c) => exec(c.spec.whenIO(b), c.exec),
     Labeled: ({ label, spec }) => Spec.labeled(spec.whenIO(b), label),
@@ -376,9 +376,6 @@ export function whenIO_<R, E, R1, E1>(
 /**
  * @tsplus fluent fncts.test.PSpec when
  */
-export function when_<R, E>(
-  self: PSpec<R, E, TestSuccess>,
-  b: Lazy<boolean>,
-): PSpec<R & Has<Annotations>, E, TestSuccess> {
+export function when_<R, E>(self: PSpec<R, E, TestSuccess>, b: Lazy<boolean>): PSpec<R | Annotations, E, TestSuccess> {
   return self.whenIO(IO.succeed(b));
 }

package/_src/control/Spec/definition.ts

@@ -8,7 +8,7 @@ import type { _A, _E, _R } from "@fncts/base/types.js";
  * @tsplus companion fncts.test.PSpecOps
  */
 export class PSpec<R, E, T> {
-  readonly _R!: (_: R) => void;
+  readonly _R!: () => R;
   readonly _E!: () => E;
   readonly _A!: () => T;
 
@@ -56,7 +56,7 @@ export class LabeledCase<Spec> {
  */
 export class ScopedCase<R, E, Spec> {
   readonly _tag = SpecCaseTag.Scoped;
-  constructor(readonly scoped: IO<R & Has<Scope>, E, Spec>) {}
+  constructor(readonly scoped: IO<R | Scope, E, Spec>) {}
 }
 
 /**
@@ -71,7 +71,7 @@ export class MultipleCase<Spec> {
  * @tsplus companion fncts.test.PSpec.TestCaseOps
  */
 export class TestCase<R, E, T> {
-  readonly _R!: (_: R) => void;
+  readonly _R!: () => R;
   readonly _E!: () => E;
   readonly _A!: () => T;
   readonly _tag = SpecCaseTag.Test;

package/_src/control/TestAspect/api.ts

@@ -15,10 +15,10 @@ export type TestAspectPoly = TestAspect<unknown, never>;
 
 export const id: TestAspectPoly = Function.identity;
 
-export const ignore: TestAspectAtLeastR<Has<Annotations>> = (spec) => spec.when(false);
+export const ignore: TestAspectAtLeastR<Annotations> = (spec) => spec.when(false);
 
 export function perTest<R, E>(
-  f: <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>) => IO<R & R1, TestFailure<E | E1>, TestSuccess>,
+  f: <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>) => IO<R | R1, TestFailure<E | E1>, TestSuccess>,
 ): TestAspect<R, E> {
   return (spec) =>
     spec.transform(
@@ -41,8 +41,8 @@ export function after<R, E, A>(effect: IO<R, E, A>): TestAspect<R, E> {
   );
 }
 
-export function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R & R1, E> {
-  return perTest<R & R1, E>((test) =>
+export function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R | R1, E> {
+  return perTest<R | R1, E>((test) =>
     before.catchAllCause((c) => IO.fail(new RuntimeFailure(c))).bracket(() => test, after),
   );
 }
@@ -50,9 +50,9 @@ export function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1,
 export function aroundAll<R, E, A, R1>(
   before: IO<R, E, A>,
   after: (a: A) => IO<R1, never, any>,
-): TestAspect<R & R1, E> {
+): TestAspect<R | R1, E> {
   return <R0, E0>(spec: Spec<R0, E0>) =>
-    Spec.scoped<R & R1 & R0, TestFailure<E | E0>, TestSuccess>(
+    Spec.scoped<R | R1 | R0, TestFailure<E | E0>, TestSuccess>(
       IO.acquireRelease(before, after)
         .mapError((e) => TestFailure.fail(e))
         .as(spec),
@@ -69,12 +69,10 @@ export function beforeAll<R0, E0>(effect: IO<R0, E0, any>): TestAspect<R0, E0> {
 
 export const eventually = perTest((test) => test.eventually);
 
-export function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Has<Annotations>, never> {
-  return perTest<R0 & Has<Annotations>, never>(
-    <R1, E1>(
-      test: IO<R1, TestFailure<E1>, TestSuccess>,
-    ): IO<R0 & R1 & Has<Annotations>, TestFailure<E1>, TestSuccess> =>
-      IO.environmentWithIO((r: Environment<R0 & R1 & Has<Annotations>>) =>
+export function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Annotations, never> {
+  return perTest<R0 | Annotations, never>(
+    <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>): IO<R0 | R1 | Annotations, TestFailure<E1>, TestSuccess> =>
+      IO.environmentWithIO((r: Environment<R0 | R1 | Annotations>) =>
         test
           .provideEnvironment(r)
           .repeat(
@@ -88,9 +86,9 @@ export function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect
   );
 }
 
-export function timeoutWarning(duration: Duration): TestAspect<Has<Live>, any> {
+export function timeoutWarning(duration: Duration): TestAspect<Live, any> {
   return <R1, E1>(spec: Spec<R1, E1>) => {
-    const loop = (labels: Vector<string>, spec: Spec<R1, E1>): Spec<R1 & Has<Live>, E1> =>
+    const loop = (labels: Vector<string>, spec: Spec<R1, E1>): Spec<R1 | Live, E1> =>
       matchTag_(spec.caseValue, {
         Exec: ({ exec, spec }) => Spec.exec(loop(labels, spec), exec),
         Labeled: ({ label, spec }) => Spec.labeled(loop(labels.append(label), spec), label),

package/_src/control/TestAspect/definition.ts

@@ -1,3 +1,3 @@
 import type { Spec } from "@fncts/test/control/Spec";
 
-export type TestAspect<R, E> = <R1, E1>(spec: Spec<R1, E1>) => Spec<R & R1, E | E1>;
+export type TestAspect<R, E> = <R1, E1>(spec: Spec<R1, E1>) => Spec<R | R1, E | E1>;

package/_src/control/TestClock/api.ts

@@ -6,17 +6,17 @@ import { Data, Start, TestClock } from "@fncts/test/control/TestClock/definition
 /**
  * @tsplus static fncts.test.TestClockOps make
  */
-export function make(data: Data): Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>> {
+export function make(data: Data): Layer<Live | Annotations, never, TestClock> {
   return Layer.scoped(
-    IO.gen(function* (_) {
-      const live         = yield* _(IO.service(Live.Tag));
-      const annotations  = yield* _(IO.service(Annotations.Tag));
-      const ref          = yield* _(Ref.make(data));
-      const synchronized = yield* _(Ref.Synchronized.make(Start));
-      const test         = yield* _(
+    Do((_) => {
+      const live         = _(IO.service(Live.Tag));
+      const annotations  = _(IO.service(Annotations.Tag));
+      const ref          = _(Ref.make(data));
+      const synchronized = _(Ref.Synchronized.make(Start));
+      const test         = _(
         IO.acquireRelease(IO.succeed(new TestClock(ref, live, annotations, synchronized)), (tc) => tc.warningDone),
       );
-      yield* _(IOEnv.services.locallyScopedWith((_) => _.add(test, TestClock.Tag)));
+      _(IOEnv.services.locallyScopedWith((_) => _.add(test, TestClock.Tag)));
       return test;
     }),
     TestClock.Tag,
@@ -26,11 +26,11 @@ export function make(data: Data): Layer<Has<Live> & Has<Annotations>, never, Has
 /**
  * @tsplus static fncts.test.TestClockOps Live
  */
-export const live: Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>> = TestClock.make(new Data(0, Nil()));
+export const live: Layer<Live | Annotations, never, TestClock> = TestClock.make(new Data(0, Nil()));
 
 /**
  * @tsplus static fncts.test.TestClockOps adjust
  */
-export function adjust(duration: number): IO<Has<TestClock>, never, void> {
+export function adjust(duration: number): IO<TestClock, never, void> {
   return IO.serviceWithIO((service: TestClock) => service.adjust(duration), TestClock.Tag);
 }

package/_src/control/TestClock/definition.ts

@@ -114,7 +114,7 @@ export class TestClock extends Clock {
     );
   }
 
-  private get freeze(): IO<unknown, void, HashMap<FiberId, FiberStatus>> {
+  private get freeze(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.supervizedFibers.flatMap((fibers) =>
       IO.foldLeft(fibers, HashMap.makeDefault<FiberId, FiberStatus>(), (map, fiber) =>
         fiber.status.flatMap((status) => {
@@ -166,7 +166,7 @@ export class TestClock extends Clock {
     );
   }
 
-  private get suspended(): IO<unknown, void, HashMap<FiberId, FiberStatus>> {
+  private get suspended(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.freeze.zip(this.delay > this.freeze).flatMap(([first, last]) => {
       if (Equatable.strictEquals(first, last)) {
         return IO.succeedNow(first);
@@ -190,7 +190,7 @@ export class TestClock extends Clock {
         Start: () =>
           Just(this.live.provide(Clock.sleep((5).seconds) > Console.print(warning)).interruptible.fork.map(Pending)),
       },
-      () => Nothing<IO<unknown, never, WarningData>>(),
+      () => Nothing<IO<never, never, WarningData>>(),
     ),
   );
 }