@fncts/test 0.0.1 → 0.0.4

package/_src/control/TestClock/definition.ts

@@ -58,13 +58,13 @@ export class TestClock extends Clock {
   ) {
     super();
   }
-  sleep = (ms: number) => {
+  sleep = (ms: Lazy<Duration>) => {
     const self = this;
     return IO.gen(function* (_) {
       const promise = yield* _(Future.make<never, void>());
       const wait    = yield* _(
         self.clockState.modify((data) => {
-          const end = data.duration + ms;
+          const end = data.duration + ms().milliseconds;
           if (end > data.duration) {
             return [true, new Data(data.duration, data.sleeps.prepend([end, promise]))];
           } else {
@@ -135,12 +135,12 @@ export class TestClock extends Clock {
   }
 
   private get delay(): UIO<void> {
-    return this.live.provide(Clock.sleep(5));
+    return this.live.provide(Clock.sleep((5).milliseconds));
   }
 
   private get awaitSuspended(): UIO<void> {
     return this.suspended
-      .zipWith(this.live.provide(Clock.sleep(10)) > this.suspended, Equatable.strictEquals)
+      .zipWith(this.live.provide(Clock.sleep((10).milliseconds)) > this.suspended, Equatable.strictEquals)
       .filterOrFail(Function.identity, (): void => undefined).eventually.asUnit;
   }
 
@@ -149,7 +149,7 @@ export class TestClock extends Clock {
       this.awaitSuspended >
       this.clockState.modify((data) => {
         const end    = f(data.duration);
-        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare_(x, y));
+        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare(x, y));
         return sorted.head
           .flatMap(([duration, promise]) =>
             duration <= end
@@ -188,7 +188,7 @@ export class TestClock extends Clock {
     matchTag(
       {
         Start: () =>
-          Just(this.live.provide(Clock.sleep(5000) > Console.print(warning)).interruptible.fork.map(Pending)),
+          Just(this.live.provide(Clock.sleep((5).seconds) > Console.print(warning)).interruptible.fork.map(Pending)),
       },
       () => Nothing<IO<unknown, never, WarningData>>(),
     ),

package/_src/data/FreeBooleanAlgebra/api.ts

@@ -34,22 +34,28 @@ export function failures<A>(self: FreeBooleanAlgebra<A>): Maybe<FreeBooleanAlgeb
   return self
     .fold<A, Either<FreeBooleanAlgebra<A>, FreeBooleanAlgebra<A>>>({
       Value: (a) => Either.right(FreeBooleanAlgebra.success(a)),
-      And: (l, r) =>
-        l.isRight()
+      And: (l, r) => {
+        Either.concrete(l);
+        Either.concrete(r);
+        return l.isRight()
           ? r.isRight()
             ? Either.right(l.right && r.right)
             : r
           : r.isRight()
           ? l
-          : Either.left(l.left && r.left),
-      Or: (l, r) =>
-        l.isRight()
+          : Either.left(l.left && r.left);
+      },
+      Or: (l, r) => {
+        Either.concrete(l);
+        Either.concrete(r);
+        return l.isRight()
           ? r.isRight()
             ? Either.right(l.right || r.right)
             : l
           : r.isRight()
           ? r
-          : Either.left(l.left || r.left),
+          : Either.left(l.left || r.left);
+      },
       Not: (v) => v.swap,
     })
     .match(Maybe.just, () => Nothing());

package/control/Assertion/api.d.ts

@@ -52,11 +52,15 @@ export declare function deepEqualTo<A>(expected: A): Assertion<A>;
 export declare function equals<A>(expected: A, E: Eq<A>): Assertion<A>;
 export declare const isFalse: Assertion<boolean>;
 export declare const isInterrupted: Assertion<Exit<any, any>>;
+export declare const isOnlyInterrupted: Assertion<Exit<any, any>>;
 export declare function isLeft<A>(assertion: Assertion<A>): Assertion<Either<A, any>>;
 export declare function isJust<A>(assertion: Assertion<A>): Assertion<Maybe<A>>;
 export declare const isNothing: Assertion<Maybe<any>>;
 export declare function isRight<A>(assertion: Assertion<A>): Assertion<Either<any, A>>;
 export declare const isTrue: Assertion<boolean>;
+export declare const isEmpty: Assertion<Iterable<any>>;
+export declare const isUnit: Assertion<void>;
+export declare function isLessThanOrEqualTo(n: number): Assertion<number>;
 /**
  * @tsplus fluent fncts.test.Assertion label
  * @tsplus location "@fncts/test/control/Assertion/api"

package/control/Gen/api/conc.d.ts

@@ -20,7 +20,7 @@ export declare function concN_<R, A>(g: Gen<R, A>, n: number): Gen<R, Conc<A>>;
  */
 export declare function uniqueConc_<R, A>(self: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Has<Sized> & R, Conc<A>>;
 /**
- * @tsplus getter fncts.test.Gen uniqueConcN
+ * @tsplus fluent fncts.test.Gen uniqueConcN
  * @tsplus location "@fncts/test/control/Gen/api/conc"
  */
-export declare function uniqueConcN_<R, A>(self: Gen<R, A>): (E: Eq<A>) => (n: number) => Gen<R, Conc<A>>;
+export declare function uniqueConcN_<R, A>(self: Gen<R, A>, n: number, /** @tsplus auto */ E: Eq<A>): Gen<R, Conc<A>>;

package/control/TestAspect/api.d.ts

@@ -2,6 +2,7 @@ import { Has } from "@fncts/base/typeclass";
 import { IO } from "@fncts/io/IO";
 import { Schedule } from "@fncts/io/Schedule/definition";
 import { Environment } from "@fncts/base/data/Environment";
+import { Duration } from "@fncts/base/data/Duration";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import type { TestAspect } from "@fncts/test/control/TestAspect/definition";
 import type { TestSuccess } from "@fncts/test/data/TestSuccess";
@@ -20,4 +21,4 @@ export declare function before<R0>(effect: IO<R0, never, any>): TestAspect<R0, n
 export declare function beforeAll<R0, E0>(effect: IO<R0, E0, any>): TestAspect<R0, E0>;
 export declare const eventually: TestAspect<unknown, unknown>;
 export declare function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Has<Annotations>, never>;
-export declare function timeoutWarning(duration: number): TestAspect<Has<Live>, any>;
+export declare function timeoutWarning(duration: Duration): TestAspect<Has<Live>, any>;

package/control/TestClock/definition.d.ts

@@ -3,6 +3,8 @@ import { Future } from "@fncts/io/Future";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Fiber } from "@fncts/io/Fiber";
 import { Ref } from "@fncts/io/Ref";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration";
 import { UIO, IO } from "@fncts/io/IO";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap";
@@ -48,7 +50,7 @@ export declare class TestClock extends Clock {
     readonly annotations: Annotations;
     readonly warningState: Ref.Synchronized<WarningData>;
     constructor(clockState: Ref<Data>, live: Live, annotations: Annotations, warningState: Ref.Synchronized<WarningData>);
-    sleep: (ms: number) => import("@fncts/io/IO").IO<unknown, never, void>;
+    sleep: (ms: Lazy<Duration>) => import("@fncts/io/IO").IO<unknown, never, void>;
     currentTime: import("@fncts/io/IO").IO<unknown, never, number>;
     adjust(duration: number): UIO<void>;
     setDate(date: Date): UIO<void>;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@fncts/test",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "dependencies": {
-    "@fncts/base": "0.0.1",
-    "@fncts/io": "0.0.1",
-    "@fncts/typelevel": "0.0.1"
+    "@fncts/base": "0.0.4",
+    "@fncts/io": "0.0.4",
+    "@fncts/typelevel": "0.0.4"
   },
   "exports": {
     "./*": {
-      "import": "./_mjs/*",
-      "require": "./_cjs/*"
+      "import": "./_mjs/*.mjs",
+      "require": "./_cjs/*.cjs"
     }
   },
   "publishConfig": {

package/runTests.d.ts

@@ -0,0 +1 @@
+export {};