@typed/fx 2.0.0-beta.1 → 2.0.0-beta.10

package/src/RefSubject/RefResult.ts

@@ -1,209 +0,0 @@
-/**
- * Extensions to RefSubject for working with Result values
- * @since 1.18.0
- */
-
-import type * as Effect from "effect/Effect";
-import * as Equivalence_ from "effect/Equivalence";
-import type { Equivalence } from "effect/Equivalence";
-import { dual } from "effect/Function";
-import * as Result from "effect/Result";
-import type * as Scope from "effect/Scope";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-/**
- * A RefResult is a RefSubject specialized over a Result value.
- * @since 1.18.0
- * @category models
- */
-export interface RefResult<
-  in out A,
-  in out E,
-  in out Err = never,
-  out R = never,
-> extends RefSubject.RefSubject<Result.Result<A, E>, Err, R> {}
-
-/**
- * Creates a new `RefResult` from a Result, `Effect`, or `Fx`.
- *
- * @example
- * ```ts
- * import { Effect, Result } from "effect"
- * import * as RefResult from "effect/typed/fx/RefSubject/RefResult"
- *
- * const program = Effect.gen(function* () {
- *   const value = yield* RefResult.make(Result.succeed(42))
- *   const current = yield* value
- *   console.log(current) // { _tag: "Success", success: 42 }
- * })
- * ```
- *
- * @since 1.18.0
- * @category constructors
- */
-export function make<A, E, Err = never, R = never>(
-  initial:
-    | Result.Result<A, E>
-    | Effect.Effect<Result.Result<A, E>, Err, R>
-    | Fx.Fx<Result.Result<A, E>, Err, R>,
-  successEq: Equivalence<A> = Equivalence_.strictEqual(),
-  failureEq: Equivalence<E> = Equivalence_.strictEqual(),
-): Effect.Effect<RefResult<A, E, Err, R>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq: Result.makeEquivalence(successEq, failureEq) });
-}
-
-/**
- * Set the current state of a RefResult to Success(value).
- * @since 1.18.0
- * @category combinators
- */
-export const setSuccess: {
-  <A>(value: A): <E, R>(ref: RefResult<A, E, R>) => Effect.Effect<Result.Result<A, E>, E, R>;
-  <A, E, R>(ref: RefResult<A, E, R>, value: A): Effect.Effect<Result.Result<A, E>, E, R>;
-} = dual(2, function setSuccess<A, E, R>(ref: RefResult<A, E, R>, value: A) {
-  return RefSubject.set(ref, Result.succeed(value));
-});
-
-/**
- * Set the current state of a RefResult to Failure(error).
- * @since 1.18.0
- * @category combinators
- */
-export const setFailure: {
-  <E>(error: E): <A, R>(ref: RefResult<A, E, R>) => Effect.Effect<Result.Result<A, E>, E, R>;
-  <A, E, R>(ref: RefResult<A, E, R>, error: E): Effect.Effect<Result.Result<A, E>, E, R>;
-} = dual(2, function setFailure<A, E, R>(ref: RefResult<A, E, R>, error: E) {
-  return RefSubject.set(ref, Result.fail(error));
-});
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Map the success value of a RefResult.
- * @since 1.18.0
- * @category computed
- */
-export const map: {
-  <A, B>(
-    f: (a: A) => B,
-  ): <E, R>(ref: RefResult<A, E, R>) => RefSubject.Computed<Result.Result<B, E>, E, R>;
-  <A, E, R, B>(
-    ref: RefResult<A, E, R>,
-    f: (a: A) => B,
-  ): RefSubject.Computed<Result.Result<B, E>, E, R>;
-} = dual(2, function map<A, E, R, B>(ref: RefResult<A, E, R>, f: (a: A) => B) {
-  return RefSubject.map(ref, (self) => Result.map(self, f));
-});
-
-/**
- * Map the error value of a RefResult.
- * @since 1.18.0
- * @category computed
- */
-export const mapError: {
-  <E, E2>(
-    f: (e: E) => E2,
-  ): <A, R>(ref: RefResult<A, E, R>) => RefSubject.Computed<Result.Result<A, E2>, E, R>;
-  <A, E, R, E2>(
-    ref: RefResult<A, E, R>,
-    f: (e: E) => E2,
-  ): RefSubject.Computed<Result.Result<A, E2>, E, R>;
-} = dual(2, function mapError<A, E, R, E2>(ref: RefResult<A, E, R>, f: (e: E) => E2) {
-  return RefSubject.map(ref, (self) => Result.mapError(self, f));
-});
-
-/**
- * FlatMap the success value of a RefResult.
- * @since 1.18.0
- * @category computed
- */
-export const flatMap: {
-  <A, B, E2>(
-    f: (a: A) => Result.Result<B, E2>,
-  ): <E, R>(ref: RefResult<A, E, R>) => RefSubject.Computed<Result.Result<B, E | E2>, E, R>;
-  <A, E, R, B, E2>(
-    ref: RefResult<A, E, R>,
-    f: (a: A) => Result.Result<B, E2>,
-  ): RefSubject.Computed<Result.Result<B, E | E2>, E, R>;
-} = dual(2, function flatMap<
-  A,
-  E,
-  R,
-  B,
-  E2,
->(ref: RefResult<A, E, R>, f: (a: A) => Result.Result<B, E2>) {
-  return RefSubject.map(ref, (self) => Result.flatMap(self, f));
-});
-
-/**
- * Check if the current state of a RefResult is Success.
- * @since 1.18.0
- * @category computed
- */
-export const isSuccess = <A, E, Err, R>(
-  ref: RefResult<A, E, Err, R>,
-): RefSubject.Computed<boolean, Err, R> => RefSubject.map(ref, Result.isSuccess);
-
-/**
- * Check if the current state of a RefResult is Failure.
- * @since 1.18.0
- * @category computed
- */
-export const isFailure = <A, E, Err, R>(
-  ref: RefResult<A, E, Err, R>,
-): RefSubject.Computed<boolean, Err, R> => RefSubject.map(ref, Result.isFailure);
-
-/**
- * Match on the Result value.
- * @since 1.18.0
- * @category computed
- */
-export const match: {
-  <A, E, B>(options: {
-    readonly onSuccess: (a: A) => B;
-    readonly onFailure: (e: E) => B;
-  }): <R>(ref: RefResult<A, E, R>) => RefSubject.Computed<B, E, R>;
-  <A, E, R, B>(
-    ref: RefResult<A, E, R>,
-    options: {
-      readonly onSuccess: (a: A) => B;
-      readonly onFailure: (e: E) => B;
-    },
-  ): RefSubject.Computed<B, E, R>;
-} = dual(
-  2,
-  function match<A, E, R, B>(
-    ref: RefResult<A, E, R>,
-    options: {
-      readonly onSuccess: (a: A) => B;
-      readonly onFailure: (e: E) => B;
-    },
-  ) {
-    return RefSubject.map(ref, (self) => Result.match(self, options));
-  },
-);
-
-// ========================================
-// Filtered
-// ========================================
-
-/**
- * Get the success value from the Result as a Filtered (fails if Failure).
- * @since 1.18.0
- * @category filtered
- */
-export const getSuccess = <A, E, Err, R>(
-  ref: RefResult<A, E, Err, R>,
-): RefSubject.Filtered<A, Err, R> => RefSubject.filterMap(ref, Result.getSuccess);
-
-/**
- * Get the failure value from the Result as a Filtered (fails if Success).
- * @since 1.18.0
- * @category filtered
- */
-export const getFailure = <A, E, Err, R>(
-  ref: RefResult<A, E, Err, R>,
-): RefSubject.Filtered<E, Err, R> => RefSubject.filterMap(ref, Result.getFailure);

package/src/RefSubject/RefString.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Effect } from "effect";
-import * as RefString from "./RefString.js";
-
-describe("RefString", () => {
-  it("creates and gets value", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("hello");
-      const current = yield* ref;
-      expect(current).toBe("hello");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("concatenates strings", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("hello");
-      const result = yield* RefString.concat(ref, " world");
-      expect(result).toBe("hello world");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("converts to uppercase", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("hello");
-      const result = yield* RefString.toUpperCase(ref);
-      expect(result).toBe("HELLO");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("converts to lowercase", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("HELLO");
-      const result = yield* RefString.toLowerCase(ref);
-      expect(result).toBe("hello");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("trims whitespace", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("  hello  ");
-      const result = yield* RefString.trim(ref);
-      expect(result).toBe("hello");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks if empty", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("");
-      const isEmpty = yield* RefString.isEmpty(ref);
-      expect(isEmpty).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks length", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("hello");
-      const length = yield* RefString.length(ref);
-      expect(length).toBe(5);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks startsWith", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefString.make("hello");
-      const startsWith = yield* RefString.startsWith(ref, "he");
-      expect(startsWith).toBe(true);
-    }).pipe(Effect.scoped, Effect.runPromise));
-});

package/src/RefSubject/RefString.ts

@@ -1,256 +0,0 @@
-/**
- * Extensions to RefSubject for working with string values
- * @since 1.18.0
- */
-
-import type * as Effect from "effect/Effect";
-import * as Equivalence_ from "effect/Equivalence";
-import type { Equivalence } from "effect/Equivalence";
-import { dual } from "effect/Function";
-import type * as Scope from "effect/Scope";
-import * as String_ from "effect/String";
-import type * as Fx from "../Fx/index.js";
-import * as RefSubject from "./RefSubject.js";
-
-const isRefStringDataFirst = (args: IArguments) => RefSubject.isRefSubject(args[0]);
-
-/**
- * A RefString is a RefSubject specialized over a string value.
- * @since 1.18.0
- * @category models
- */
-export interface RefString<in out E = never, out R = never> extends RefSubject.RefSubject<
-  string,
-  E,
-  R
-> {}
-
-/**
- * Creates a new `RefString` from a string, `Effect`, or `Fx`.
- *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import * as RefString from "effect/typed/fx/RefSubject/RefString"
- *
- * const program = Effect.gen(function* () {
- *   const value = yield* RefString.make("hello")
- *   const current = yield* value
- *   console.log(current) // "hello"
- * })
- * ```
- *
- * @since 1.18.0
- * @category constructors
- */
-export function make<E = never, R = never>(
-  initial: string | Effect.Effect<string, E, R> | Fx.Fx<string, E, R>,
-  eq: Equivalence<string> = Equivalence_.strictEqual(),
-): Effect.Effect<RefString<E>, never, R | Scope.Scope> {
-  return RefSubject.make(initial, { eq });
-}
-
-// ========================================
-// Computed
-// ========================================
-
-/**
- * Concatenate a string to the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const concat: {
-  (that: string): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<string, E, R>;
-  <E, R>(ref: RefString<E, R>, that: string): RefSubject.Computed<string, E, R>;
-} = dual(2, function concat<E, R>(ref: RefString<E, R>, that: string) {
-  return RefSubject.map(ref, (self) => String_.concat(self, that));
-});
-
-/**
- * Convert the current state of a RefString to uppercase.
- * @since 1.18.0
- * @category computed
- */
-export const toUpperCase = <E, R>(ref: RefString<E, R>): RefSubject.Computed<string, E, R> =>
-  RefSubject.map(ref, String_.toUpperCase);
-
-/**
- * Convert the current state of a RefString to lowercase.
- * @since 1.18.0
- * @category computed
- */
-export const toLowerCase = <E, R>(ref: RefString<E, R>): RefSubject.Computed<string, E, R> =>
-  RefSubject.map(ref, String_.toLowerCase);
-
-/**
- * Trim whitespace from both ends of the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const trim = <E, R>(ref: RefString<E, R>): RefSubject.Computed<string, E, R> =>
-  RefSubject.map(ref, String_.trim);
-
-/**
- * Trim whitespace from the start of the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const trimStart = <E, R>(ref: RefString<E, R>): RefSubject.Computed<string, E, R> =>
-  RefSubject.map(ref, String_.trimStart);
-
-/**
- * Trim whitespace from the end of the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const trimEnd = <E, R>(ref: RefString<E, R>): RefSubject.Computed<string, E, R> =>
-  RefSubject.map(ref, String_.trimEnd);
-
-/**
- * Replace the first occurrence of a substring or pattern in the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const replace: {
-  (
-    searchValue: string | RegExp,
-    replaceValue: string,
-  ): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<string, E, R>;
-  <E, R>(
-    ref: RefString<E, R>,
-    searchValue: string | RegExp,
-    replaceValue: string,
-  ): RefSubject.Computed<string, E, R>;
-} = dual(3, function replace<
-  E,
-  R,
->(ref: RefString<E, R>, searchValue: string | RegExp, replaceValue: string) {
-  return RefSubject.map(ref, String_.replace(searchValue, replaceValue));
-});
-
-/**
- * Replace all occurrences of a substring or pattern in the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const replaceAll: {
-  (
-    searchValue: string | RegExp,
-    replaceValue: string,
-  ): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<string, E, R>;
-  <E, R>(
-    ref: RefString<E, R>,
-    searchValue: string | RegExp,
-    replaceValue: string,
-  ): RefSubject.Computed<string, E, R>;
-} = dual(3, function replaceAll<
-  E,
-  R,
->(ref: RefString<E, R>, searchValue: string | RegExp, replaceValue: string) {
-  return RefSubject.map(ref, String_.replaceAll(searchValue, replaceValue));
-});
-
-/**
- * Check if the current state of a RefString is empty.
- * @since 1.18.0
- * @category computed
- */
-export const isEmpty = <E, R>(ref: RefString<E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, String_.isEmpty);
-
-/**
- * Check if the current state of a RefString is non-empty.
- * @since 1.18.0
- * @category computed
- */
-export const isNonEmpty = <E, R>(ref: RefString<E, R>): RefSubject.Computed<boolean, E, R> =>
-  RefSubject.map(ref, String_.isNonEmpty);
-
-/**
- * Get the length of the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const length = <E, R>(ref: RefString<E, R>): RefSubject.Computed<number, E, R> =>
-  RefSubject.map(ref, String_.length);
-
-/**
- * Check if the current state of a RefString starts with a substring.
- * @since 1.18.0
- * @category computed
- */
-export const startsWith: {
-  (
-    searchString: string,
-    position?: number,
-  ): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(
-    ref: RefString<E, R>,
-    searchString: string,
-    position?: number,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(isRefStringDataFirst, function startsWith<
-  E,
-  R,
->(ref: RefString<E, R>, searchString: string, position?: number) {
-  return RefSubject.map(ref, String_.startsWith(searchString, position));
-});
-
-/**
- * Check if the current state of a RefString ends with a substring.
- * @since 1.18.0
- * @category computed
- */
-export const endsWith: {
-  (
-    searchString: string,
-    position?: number,
-  ): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(
-    ref: RefString<E, R>,
-    searchString: string,
-    position?: number,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(isRefStringDataFirst, function endsWith<
-  E,
-  R,
->(ref: RefString<E, R>, searchString: string, position?: number) {
-  return RefSubject.map(ref, String_.endsWith(searchString, position));
-});
-
-/**
- * Check if the current state of a RefString includes a substring.
- * @since 1.18.0
- * @category computed
- */
-export const includes: {
-  (
-    searchString: string,
-    position?: number,
-  ): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<boolean, E, R>;
-  <E, R>(
-    ref: RefString<E, R>,
-    searchString: string,
-    position?: number,
-  ): RefSubject.Computed<boolean, E, R>;
-} = dual(isRefStringDataFirst, function includes<
-  E,
-  R,
->(ref: RefString<E, R>, searchString: string, position?: number) {
-  return RefSubject.map(ref, String_.includes(searchString, position));
-});
-
-/**
- * Extract a section of the current state of a RefString.
- * @since 1.18.0
- * @category computed
- */
-export const slice: {
-  (start?: number, end?: number): <E, R>(ref: RefString<E, R>) => RefSubject.Computed<string, E, R>;
-  <E, R>(ref: RefString<E, R>, start?: number, end?: number): RefSubject.Computed<string, E, R>;
-} = dual(isRefStringDataFirst, function slice<
-  E,
-  R,
->(ref: RefString<E, R>, start?: number, end?: number) {
-  return RefSubject.map(ref, String_.slice(start, end));
-});

package/src/RefSubject/RefStruct.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Effect } from "effect";
-import * as RefStruct from "./RefStruct.js";
-
-describe("RefStruct", () => {
-  it("creates and gets value", () =>
-    Effect.gen(function* () {
-      const value = { name: "John", age: 30 };
-      const ref = yield* RefStruct.make(value);
-      const current = yield* ref;
-      expect(current).toEqual(value);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("sets a property", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefStruct.make({ name: "John", age: 30 });
-      yield* RefStruct.set(ref, "age", 31);
-      const result = yield* ref;
-      expect(result.age).toBe(31);
-      expect(result.name).toBe("John");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("updates a property", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefStruct.make({ name: "John", age: 30 });
-      yield* RefStruct.update(ref, "age", (n) => n + 1);
-      const result = yield* ref;
-      expect(result.age).toBe(31);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("merges structs", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefStruct.make({ name: "John", age: 30 });
-      yield* RefStruct.merge(ref, { age: 31, city: "NYC" });
-      const result = yield* ref;
-      expect(result.age).toBe(31);
-      expect(result.name).toBe("John");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("gets a property", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefStruct.make({ name: "John", age: 30 });
-      const name = yield* RefStruct.get(ref, "name");
-      expect(name).toBe("John");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("gets keys", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefStruct.make({ name: "John", age: 30 });
-      const keys = yield* RefStruct.keys(ref);
-      expect(keys.sort()).toEqual(["age", "name"]);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-  it("checks size", () =>
-    Effect.gen(function* () {
-      const ref = yield* RefStruct.make({ name: "John", age: 30 });
-      const size = yield* RefStruct.size(ref);
-      expect(size).toBe(2);
-    }).pipe(Effect.scoped, Effect.runPromise));
-});