effect-app 3.16.0 → 4.0.0-beta.1

package/src/Pure.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Chunk, Effect, Either, Layer } from "effect"
-import * as Context from "./Context.js"
+import { Chunk, Effect, Layer, Result } from "effect"
 import { tuple } from "./Function.js"
+import * as ServiceMap from "./ServiceMap.js"
 
 const S1 = Symbol()
 const S2 = Symbol()
@@ -86,54 +86,81 @@ export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR,
   ) => GMU_(get, modify, update)
 }
 
-const tagg = Context.GenericTag<{ env: PureEnv<never, unknown, never> }>("PureEnv")
+const tagg = ServiceMap.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
 function castTag<W, S, S2>() {
-  return tagg as any as Context.Tag<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
+  return tagg as any as ServiceMap.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
+}
+
+export const ServiceTag = Symbol()
+export type ServiceTag = typeof ServiceTag
+
+export abstract class PhantomTypeParameter<Identifier extends keyof any, InstantiatedType> {
+  protected abstract readonly [ServiceTag]: {
+    readonly [NameP in Identifier]: (_: InstantiatedType) => InstantiatedType
+  }
+}
+
+export type ServiceShape<T extends ServiceMap.ServiceClass.Shape<any, any>> = Omit<
+  T,
+  keyof ServiceMap.ServiceClass.Shape<any, any>
+>
+
+export abstract class ServiceTagged<ServiceKey> extends PhantomTypeParameter<string, ServiceKey> {}
+
+export function makeService<T extends ServiceTagged<any>>(_: Omit<T, ServiceTag>) {
+  return _ as T
 }
 
 export const PureEnvEnv = Symbol()
-export interface PureEnvEnv<W, S, S2> extends Context.ServiceTagged<typeof PureEnvEnv> {
+export interface PureEnvEnv<W, S, S2> extends ServiceTagged<typeof PureEnvEnv> {
   env: PureEnv<W, S, S2>
 }
 
 export function get<S>(): Pure<never, S, S, never, never, S> {
-  return Effect.map(castTag<never, S, S>(), (_) => _.env.state)
+  return (castTag<never, S, S>() as any).use((_: any) => _.env.state)
 }
 
 export function set<S>(s: S): Pure<never, S, S, never, never, void> {
-  return Effect.map(castTag<never, S, S>(), (_) => _.env.state = s)
+  return (castTag<never, S, S>() as any).use((_: any) => {
+    _.env.state = s
+  })
 }
 
 export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
 
 export function log<W>(w: W): PureLogT<W> {
-  return Effect.map(castTag<W, unknown, never>(), (_) => _.env.log = Chunk.append(_.env.log, w))
+  return (castTag<W, unknown, never>() as any).use((_: any) => {
+    _.env.log = Chunk.append(_.env.log, w)
+  })
 }
 
 export function logMany<W>(w: Iterable<W>): PureLogT<W> {
-  return Effect.map(castTag<W, unknown, never>(), (_) => _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w)))
+  return (castTag<W, unknown, never>() as any).use((_: any) => {
+    _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w))
+  })
 }
 
 export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ): Effect.Effect<
-  readonly [Chunk.Chunk<W3>, Either.Either<readonly [S3, A], E>],
+  readonly [Chunk.Chunk<W3>, Result.Result<readonly [S3, A], E>],
   never,
   Exclude<R, { env: PureEnv<W3, S1, S3> }>
 > {
   const a = Effect
     .flatMap(self, (x) =>
-      castTag<W3, S1, S3>()
+      (castTag<W3, S1, S3>() as any)
+        .use(
+          ({ env: _ }: any) => Effect.sync(() => ({ log: _.log, state: _.state }))
+        )
         .pipe(
-          Effect.flatMap(
-            ({ env: _ }) => Effect.sync(() => ({ log: _.log, state: _.state })) //            Ref.get(_.log).flatMap(log => Ref.get(_.state).map(state => ({ log, state })))
-          ),
+          Effect.flatMap((_: any) => Effect.succeed(_)),
           Effect.map(
-            ({ log, state }) => tuple(log, Either.right(tuple(state, x)))
+            ({ log, state }: any) => tuple(log, Result.succeed(tuple(state, x)))
           )
         ))
-    .pipe(Effect.catchAll((err) => Effect.map(tagg, (env) => tuple(env.env.log, Either.left(err)))))
+    .pipe(Effect.catch((err: any) => (tagg as any).use((env: any) => tuple(env.env.log, Result.fail(err)))))
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
@@ -141,14 +168,17 @@ export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Effect.map(r, ([s]) => s)))
+  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Result.map(r, ([s]) => s)))
 }
 
 export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.flatMap(runAll(self, s), ([evts, r]) => Effect.map(r, ([s3, a]) => tuple(s3, Chunk.toArray(evts), a)))
+  return Effect.flatMap(
+    runAll(self, s),
+    ([evts, r]) => Effect.map(Effect.fromResult(r), ([s3, a]) => tuple(s3, Chunk.toArray(evts), a))
+  )
 }
 
 export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
@@ -162,17 +192,17 @@ export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Effect.map(r, ([, a]) => a)))
+  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Result.map(r, ([, a]) => a)))
 }
 
 export function modify<S2, A, S3>(
   mod: (s: S2) => readonly [S3, A]
 ): Effect.Effect<A, never, { env: PureEnv<never, S2, S3> }> {
-  return Effect.map(castTag<never, S3, S2>(), (_) =>
-    Effect.map(Effect.sync(() => mod(_.env.state)), ([s, a]) => {
-      _.env.state = s as any
-      return a
-    })) as any
+  return (castTag<never, S3, S2>() as any).use((_: any) => {
+    const [s, a] = mod(_.env.state)
+    _.env.state = s as any
+    return a
+  }) as any
 }
 
 export function modifyM<W, R, E, A, S2, S3>(
@@ -180,8 +210,12 @@ export function modifyM<W, R, E, A, S2, S3>(
 ): Effect.Effect<A, E, FixEnv<R, W, S2, S3>> {
   // return serviceWithEffect(_ => Ref.modifyM_(_.state, mod))
   return Effect.flatMap(
-    castTag<W, S3, S2>(),
-    (_) => Effect.map(mod(_.env.state), ([s, a]) => Effect.map(Effect.sync(() => _.env.state = s as any), () => a))
+    (castTag<W, S3, S2>() as any).use((_: any) => _),
+    (_: any) =>
+      Effect.map(mod(_.env.state), ([s, a]: any) => {
+        _.env.state = s as any
+        return a
+      })
   ) as any
 }
 

package/src/Schema/Class.ts

@@ -1,22 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { pipe, Struct as Struct2 } from "effect"
-import type { Schema, Struct } from "effect/Schema"
+import type { Struct } from "effect/Schema"
 import * as S from "effect/Schema"
-import type { Simplify } from "effect/Types"
 
-type ClassAnnotations<Self, A> =
-  | S.Annotations.Schema<Self>
-  | readonly [
-    // Annotations for the "to" schema
-    S.Annotations.Schema<Self> | undefined,
-    // Annotations for the "transformation schema
-    (S.Annotations.Schema<Self> | undefined)?,
-    // Annotations for the "from" schema
-    S.Annotations.Schema<A>?
-  ]
+type ClassAnnotations<Self> = S.Annotations.Declaration<Self, readonly [any]>
 
-export interface EnhancedClass<Self, Fields extends Struct.Fields, I, R, C, Inherited, Proto>
-  extends S.Class<Self, Fields, I, R, C, Inherited, Proto>, /* Reason for enhancement */ PropsExtensions<Fields>
+export interface EnhancedClass<Self, SchemaS extends S.Top & { readonly fields: Struct.Fields }, Inherited>
+  extends S.Class<Self, SchemaS, Inherited>, /* Reason for enhancement */ PropsExtensions<SchemaS["fields"]>
 {
 }
 type MissingSelfGeneric<Usage extends string, Params extends string = ""> =
@@ -36,47 +26,13 @@ type HasFields<Fields extends Struct.Fields> = {
   readonly from: HasFields<Fields>
 }
 
-// const isPropertySignature = (u: unknown): u is PropertySignature.All =>
-//   Predicate.hasProperty(u, PropertySignatureTypeId)
-
-// const isField = (u: unknown) => S.isSchema(u) || S.isPropertySignature(u)
-
-// const isFields = <Fields extends Struct.Fields>(fields: object): fields is Fields =>
-//   ownKeys(fields).every((key) => isField((fields as any)[key]))
-
-// const getFields = <Fields extends Struct.Fields>(hasFields: HasFields<Fields>): Fields =>
-//   "fields" in hasFields ? hasFields.fields : getFields(hasFields.from)
-
-// const getSchemaFromFieldsOr = <Fields extends Struct.Fields>(fieldsOr: Fields | HasFields<Fields>): Schema.Any =>
-//   isFields(fieldsOr) ? Struct(fieldsOr) : S.isSchema(fieldsOr) ? fieldsOr : Struct(getFields(fieldsOr))
-
-// const getFieldsFromFieldsOr = <Fields extends Struct.Fields>(fieldsOr: Fields | HasFields<Fields>): Fields =>
-//   isFields(fieldsOr) ? fieldsOr : getFields(fieldsOr)
-
-// export function include<Fields extends S.Struct.Fields>(fields: Fields | HasFields<Fields>) {
-//   return <NewProps extends S.Struct.Fields>(
-//     fnc: (fields: Fields) => NewProps
-//   ) => include_(fields, fnc)
-// }
-
-// export function include_<
-//   Fields extends S.Struct.Fields,
-//   NewProps extends S.Struct.Fields
-// >(fields: Fields | HasFields<Fields>, fnc: (fields: Fields) => NewProps) {
-//   return fnc("fields" in fields ? fields.fields : fields)
-// }
-
 export const Class: <Self = never>(identifier: string) => <Fields extends S.Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self>
 ) => [Self] extends [never] ? MissingSelfGeneric<"Class">
   : EnhancedClass<
     Self,
-    Fields,
-    Simplify<Struct.Encoded<Fields>>,
-    Struct.Context<Fields>,
-    Simplify<S.Struct.Constructor<Fields>>,
-    {},
+    S.Struct<Fields>,
     {}
   > = (identifier) => (fields, annotations) => {
     const cls = S.Class as any
@@ -85,23 +41,19 @@ export const Class: <Self = never>(identifier: string) => <Fields extends S.Stru
         super(a, b)
       }
       // static readonly include = include(fields)
-      static readonly pick = (...selection: any[]) => pipe(this["fields"], Struct2.pick(...selection))
-      static readonly omit = (...selection: any[]) => pipe(this["fields"], Struct2.omit(...selection))
+      static readonly pick = (...selection: any[]) => pipe(this["fields"], Struct2.pick(selection))
+      static readonly omit = (...selection: any[]) => pipe(this["fields"], Struct2.omit(selection))
     } as any
   }
 
 export const TaggedClass: <Self = never>(identifier?: string) => <Tag extends string, Fields extends S.Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self>
 ) => [Self] extends [never] ? MissingSelfGeneric<"Class">
   : EnhancedClass<
     Self,
-    { readonly _tag: S.tag<Tag> } & Fields,
-    Simplify<{ readonly _tag: Tag } & Struct.Encoded<Fields>>,
-    Schema.Context<Fields[keyof Fields]>,
-    Simplify<S.Struct.Constructor<Fields>>,
-    {},
+    S.Struct<{ readonly _tag: S.tag<Tag> } & Fields>,
     {}
   > = (identifier) => (tag, fields, annotations) => {
     const cls = S.TaggedClass as any
@@ -110,21 +62,17 @@ export const TaggedClass: <Self = never>(identifier?: string) => <Tag extends st
         super(a, b)
       }
       // static readonly include = include(fields)
-      static readonly pick = (...selection: any[]) => pipe(this["fields"], Struct2.pick(...selection))
-      static readonly omit = (...selection: any[]) => pipe(this["fields"], Struct2.omit(...selection))
+      static readonly pick = (...selection: any[]) => pipe(this["fields"], Struct2.pick(selection))
+      static readonly omit = (...selection: any[]) => pipe(this["fields"], Struct2.omit(selection))
     } as any
   }
 
-export const ExtendedClass: <Self, SelfFrom>(identifier: string) => <Fields extends S.Struct.Fields>(
+export const ExtendedClass: <Self, _SelfFrom>(identifier: string) => <Fields extends S.Struct.Fields>(
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self>
 ) => EnhancedClass<
   Self,
-  Fields,
-  SelfFrom,
-  Schema.Context<Fields[keyof Fields]>,
-  Simplify<S.Struct.Constructor<Fields>>,
-  {},
+  S.Struct<Fields>,
   {}
 > = Class as any
 
@@ -132,11 +80,7 @@ export interface EnhancedTaggedClass<Self, Tag extends string, Fields extends St
   extends
     EnhancedClass<
       Self,
-      Fields,
-      SelfFrom,
-      Struct.Context<Fields>,
-      Struct.Constructor<Omit<Fields, "_tag">>,
-      {},
+      S.Struct<Fields> & { readonly Encoded: SelfFrom },
       {}
     >
 {
@@ -148,7 +92,7 @@ export const ExtendedTaggedClass: <Self, SelfFrom>(
 ) => <Tag extends string, Fields extends S.Struct.Fields>(
   tag: Tag,
   fieldsOr: Fields | HasFields<Fields>,
-  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
+  annotations?: ClassAnnotations<Self>
 ) => EnhancedTaggedClass<
   Self,
   Tag,

package/src/Schema/brand.ts

@@ -1,14 +1,12 @@
-/* eslint-disable import/no-duplicates */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import type { Option } from "effect"
 import * as B from "effect/Brand"
 import type * as Brand from "effect/Brand"
-import type * as Either from "effect/Either"
+import type * as Result from "effect/Result"
 import * as S from "effect/Schema"
 
 export interface Constructor<in out A extends B.Brand<any>> {
-  readonly [B.RefinedConstructorsTypeId]: B.RefinedConstructorsTypeId
   /**
    * Constructs a branded type from a value of type `A`, throwing an error if
    * the provided `A` is not valid.
@@ -20,10 +18,10 @@ export interface Constructor<in out A extends B.Brand<any>> {
    */
   option(args: Unbranded<A>): Option.Option<A>
   /**
-   * Constructs a branded type from a value of type `A`, returning `Right<A>`
-   * if the provided `A` is valid, `Left<BrandError>` otherwise.
+   * Constructs a branded type from a value of type `A`, returning `Result.succeed`
+   * if the provided `A` is valid, `Result.fail` otherwise.
    */
-  either(args: Unbranded<A>): Either.Either<A, Brand.Brand.BrandErrors>
+  result(args: Unbranded<A>): Result.Result<A, Brand.BrandError>
   /**
    * Attempts to refine the provided value of type `A`, returning `true` if
    * the provided `A` is valid, `false` otherwise.
@@ -31,18 +29,19 @@ export interface Constructor<in out A extends B.Brand<any>> {
   is(a: Unbranded<A>): a is Unbranded<A> & A
 }
 
-export const fromBrand = <C extends Brand.Brand<string | symbol>>(
+export const fromBrand = <C extends Brand.Brand<string>>(
   constructor: Constructor<C>,
-  options?: S.Annotations.Filter<Unbranded<C>>
+  options?: S.Annotations.Filter
 ) =>
-<R, I, A extends Unbranded<C>>(self: S.Schema<A, I, R>): S.Schema<A & C, I, R> => {
-  return S.fromBrand(constructor as any, options as any)(self as any) as any
+<Self extends S.Top>(self: Self): S.brand<Self["~rebuild.out"], Brand.Brand.Keys<C>> => {
+  const branded = S.fromBrand(options?.identifier ?? "Brand", constructor as any)(self as any)
+  return options ? (branded as any).pipe(S.annotate(options)) : branded as any
 }
 
-export type Brands<P> = P extends B.Brand<any> ? { readonly [B.BrandTypeId]: P[B.BrandTypeId] }
+export type Brands<P> = P extends B.Brand<any> ? Brand.Brand.Brands<P>
   : never
 
-export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P
+export type Unbranded<P> = P extends B.Brand<any> ? Brand.Brand.Unbranded<P> : P
 
 export const nominal: <A extends B.Brand<any>>() => Constructor<A> = <
   A extends B.Brand<any>

package/src/Schema/email.ts

@@ -12,11 +12,11 @@ export type Email = string & EmailBrand
 export const Email = S
   .String
   .pipe(
-    S.filter(isValidEmail as Refinement<string, Email>, {
+    S.refine(isValidEmail as Refinement<string, Email>, {
       identifier: "Email",
       title: "Email",
       description: "an email according to RFC 5322",
       jsonSchema: { format: "email", minLength: 3, /* a@b */ maxLength: 998 },
-      arbitrary: () => (fc) => fc.emailAddress().map((_) => _ as Email)
+      arbitrary: () => (fc: any) => fc.emailAddress().map((_: any) => _ as Email)
     })
   )