Add Writable

packages/effect-fc/src/Writable.ts

@@ -0,0 +1,112 @@
+import { Effect, Function, Pipeable, Predicate, Readable } from "effect"
+import type { NoInfer } from "effect/Types"
+
+
+/**
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for("@effect-fc/Writable")
+
+/**
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * Represents a value that can be written to.
+ *
+ * Dual to `Readable`, which represents a value that can be read.
+ * A `Writable<A, E, R>` exposes a `set` operation that accepts a value of type
+ * `A` and returns an `Effect<void, E, R>`.
+ *
+ * @category models
+ */
+export interface Writable<in A, E = never, R = never> extends Pipeable.Pipeable {
+    readonly [TypeId]: TypeId
+    readonly set: (value: A) => Effect.Effect<void, E, R>
+}
+
+/**
+ * A `ReadWritable` is both `Readable` and `Writable` — it can be both read
+ * from and written to.
+ *
+ * @category models
+ */
+export interface ReadWritable<in out A, E = never, R = never>
+    extends Readable.Readable<A, E, R>, Writable<A, E, R> {}
+
+/**
+ * @category refinements
+ */
+export const isWritable = (u: unknown): u is Writable<unknown, unknown, unknown> =>
+    Predicate.hasProperty(u, TypeId)
+
+const Proto: Pick<Writable<unknown, unknown, unknown>, typeof TypeId | "pipe"> = {
+    [TypeId]: TypeId,
+    pipe(...args: Array<unknown>) {
+        return Pipeable.pipeArguments(this, args as any)
+    },
+}
+
+/**
+ * Construct a `Writable` from a `set` function.
+ *
+ * @category constructors
+ */
+export const make = <A, E, R>(set: (value: A) => Effect.Effect<void, E, R>): Writable<A, E, R> => {
+    const self = Object.create(Proto) as Writable<A, E, R>
+    ;(self as any).set = set
+    return self
+}
+
+/**
+ * Construct a `ReadWritable` from a `get` effect and a `set` function.
+ *
+ * @category constructors
+ */
+export const makeReadWritable = <A, E, R>(options: {
+    readonly get: Effect.Effect<A, E, R>
+    readonly set: (value: A) => Effect.Effect<void, E, R>
+}): ReadWritable<A, E, R> => {
+    const self = Object.create(Proto) as ReadWritable<A, E, R>
+    ;(self as any).get = options.get
+    ;(self as any).set = options.set
+    ;(self as any)[Readable.TypeId] = Readable.TypeId
+    return self
+}
+
+/**
+ * Transform the input of a `Writable` using a pure function.
+ * The resulting `Writable` accepts values of type `B`, maps them to `A` with
+ * `f`, and then forwards them to the original `set`.
+ *
+ * @category combinators
+ */
+export const contramap: {
+    <B, A>(f: (b: NoInfer<B>) => A): <E, R>(self: Writable<A, E, R>) => Writable<B, E, R>
+    <A, E, R, B>(self: Writable<A, E, R>, f: (b: NoInfer<B>) => A): Writable<B, E, R>
+} = Function.dual(2, <A, E, R, B>(self: Writable<A, E, R>, f: (b: B) => A): Writable<B, E, R> =>
+    make((b: B) => self.set(f(b)))
+)
+
+/**
+ * Transform the input of a `Writable` using an effectful function.
+ *
+ * @category combinators
+ */
+export const contramapEffect: {
+    <B, A, E2, R2>(f: (b: NoInfer<B>) => Effect.Effect<A, E2, R2>): <E, R>(self: Writable<A, E, R>) => Writable<B, E | E2, R | R2>
+    <A, E, R, B, E2, R2>(self: Writable<A, E, R>, f: (b: NoInfer<B>) => Effect.Effect<A, E2, R2>): Writable<B, E | E2, R | R2>
+} = Function.dual(2, <A, E, R, B, E2, R2>(self: Writable<A, E, R>, f: (b: B) => Effect.Effect<A, E2, R2>): Writable<B, E | E2, R | R2> =>
+    make((b: B) => Effect.flatMap(f(b), (a) => self.set(a)))
+)
+
+/**
+ * Unwrap a `Writable` that is wrapped in an `Effect`.
+ *
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+    effect: Effect.Effect<Writable<A, E, R>, E1, R1>,
+): Writable<A, E | E1, R | R1> =>
+    make((value: A) => Effect.flatMap(effect, (w) => w.set(value)))

packages/effect-fc/src/index.ts

@@ -15,3 +15,4 @@ export * as Stream from "./Stream.js"
 export * as Subscribable from "./Subscribable.js"
 export * as SubscriptionRef from "./SubscriptionRef.js"
 export * as SubscriptionSubRef from "./SubscriptionSubRef.js"
+export * as Writable from "./Writable.js"