effect 2.0.0-next.44 → 2.0.0-next.46

package/src/internal/dataSource.ts

@@ -0,0 +1,258 @@
+import * as Cause from "../Cause"
+import * as Chunk from "../Chunk"
+import type * as Context from "../Context"
+import * as Effect from "../Effect"
+import type * as Either from "../Either"
+import { dual, pipe } from "../Function"
+import * as core from "../internal/core"
+import { invokeWithInterrupt, zipWithOptions } from "../internal/fiberRuntime"
+import { complete } from "../internal/request"
+import * as RA from "../ReadonlyArray"
+import type * as Request from "../Request"
+import type * as RequestResolver from "../RequestResolver"
+
+/** @internal */
+export const make = <R, A>(
+  runAll: (requests: Array<Array<A>>) => Effect.Effect<R, never, void>
+): RequestResolver.RequestResolver<A, R> =>
+  new core.RequestResolverImpl((requests) => runAll(requests.map((_) => _.map((_) => _.request))))
+
+/** @internal */
+export const makeWithEntry = <R, A>(
+  runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<R, never, void>
+): RequestResolver.RequestResolver<A, R> => new core.RequestResolverImpl((requests) => runAll(requests))
+
+/** @internal */
+export const makeBatched = <R, A extends Request.Request<any, any>>(
+  run: (requests: Array<A>) => Effect.Effect<R, never, void>
+): RequestResolver.RequestResolver<A, R> =>
+  new core.RequestResolverImpl<R, A>(
+    (requests) =>
+      requests.length > 1 ?
+        core.forEachSequentialDiscard(requests, (block) =>
+          invokeWithInterrupt(
+            run(
+              block
+                .filter((_) => !_.state.completed)
+                .map((_) => _.request)
+            ),
+            block
+          )) :
+        (requests.length === 1 ?
+          run(
+            requests[0]
+              .filter((_) => !_.state.completed)
+              .map((_) => _.request)
+          ) :
+          core.unit)
+  )
+
+/** @internal */
+export const around = dual<
+  <R2, A2, R3, _>(
+    before: Effect.Effect<R2, never, A2>,
+    after: (a: A2) => Effect.Effect<R3, never, _>
+  ) => <R, A>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
+  <R, A, R2, A2, R3, _>(
+    self: RequestResolver.RequestResolver<A, R>,
+    before: Effect.Effect<R2, never, A2>,
+    after: (a: A2) => Effect.Effect<R3, never, _>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>
+>(3, (self, before, after) =>
+  new core.RequestResolverImpl(
+    (requests) =>
+      core.acquireUseRelease(
+        before,
+        () => self.runAll(requests),
+        after
+      ),
+    Chunk.make("Around", self, before, after)
+  ))
+
+/** @internal */
+export const batchN = dual<
+  (n: number) => <R, A>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R>,
+  <R, A>(
+    self: RequestResolver.RequestResolver<A, R>,
+    n: number
+  ) => RequestResolver.RequestResolver<A, R>
+>(2, <R, A>(
+  self: RequestResolver.RequestResolver<A, R>,
+  n: number
+): RequestResolver.RequestResolver<A, R> =>
+  new core.RequestResolverImpl(
+    (requests) => {
+      return n < 1
+        ? core.die(Cause.IllegalArgumentException("RequestResolver.batchN: n must be at least 1"))
+        : self.runAll(
+          Array.from(Chunk.map(
+            RA.reduce(
+              requests,
+              Chunk.empty<Chunk.Chunk<Request.Entry<A>>>(),
+              (acc, chunk) => Chunk.appendAll(acc, Chunk.chunksOf(Chunk.unsafeFromArray(chunk), n))
+            ),
+            (chunk) => Array.from(chunk)
+          ))
+        )
+    },
+    Chunk.make("BatchN", self, n)
+  ))
+
+/** @internal */
+export const mapInputContext = dual<
+  <R0, R>(
+    f: (context: Context.Context<R0>) => Context.Context<R>
+  ) => <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R0>,
+  <R, A extends Request.Request<any, any>, R0>(
+    self: RequestResolver.RequestResolver<A, R>,
+    f: (context: Context.Context<R0>) => Context.Context<R>
+  ) => RequestResolver.RequestResolver<A, R0>
+>(2, <R, A extends Request.Request<any, any>, R0>(
+  self: RequestResolver.RequestResolver<A, R>,
+  f: (context: Context.Context<R0>) => Context.Context<R>
+) =>
+  new core.RequestResolverImpl<R0, A>(
+    (requests) =>
+      core.mapInputContext(
+        self.runAll(requests),
+        (context: Context.Context<R0>) => f(context)
+      ),
+    Chunk.make("MapInputContext", self, f)
+  ))
+
+/** @internal */
+export const eitherWith = dual<
+  <
+    A extends Request.Request<any, any>,
+    R2,
+    B extends Request.Request<any, any>,
+    C extends Request.Request<any, any>
+  >(
+    that: RequestResolver.RequestResolver<B, R2>,
+    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<A>, Request.Entry<B>>
+  ) => <R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<C, R | R2>,
+  <
+    R,
+    A extends Request.Request<any, any>,
+    R2,
+    B extends Request.Request<any, any>,
+    C extends Request.Request<any, any>
+  >(
+    self: RequestResolver.RequestResolver<A, R>,
+    that: RequestResolver.RequestResolver<B, R2>,
+    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<A>, Request.Entry<B>>
+  ) => RequestResolver.RequestResolver<C, R | R2>
+>(3, <
+  R,
+  A extends Request.Request<any, any>,
+  R2,
+  B extends Request.Request<any, any>,
+  C extends Request.Request<any, any>
+>(
+  self: RequestResolver.RequestResolver<A, R>,
+  that: RequestResolver.RequestResolver<B, R2>,
+  f: (_: Request.Entry<C>) => Either.Either<Request.Entry<A>, Request.Entry<B>>
+) =>
+  new core.RequestResolverImpl<R | R2, C>(
+    (batch) =>
+      pipe(
+        core.forEachSequential(batch, (requests) => {
+          const [as, bs] = pipe(
+            requests,
+            RA.partitionMap(f)
+          )
+          return zipWithOptions(
+            self.runAll(Array.of(as)),
+            that.runAll(Array.of(bs)),
+            () => void 0,
+            { concurrent: true }
+          )
+        })
+      ),
+    Chunk.make("EitherWith", self, that, f)
+  ))
+
+/** @internal */
+export const fromFunction = <A extends Request.Request<never, any>>(
+  f: (request: A) => Request.Request.Success<A>
+): RequestResolver.RequestResolver<A> =>
+  makeBatched((requests: Array<A>) =>
+    core.forEachSequentialDiscard(
+      requests,
+      (request) => complete(request, core.exitSucceed(f(request)) as any)
+    )
+  ).identified("FromFunction", f)
+
+/** @internal */
+export const fromFunctionBatched = <A extends Request.Request<never, any>>(
+  f: (chunk: Array<A>) => Array<Request.Request.Success<A>>
+): RequestResolver.RequestResolver<A> =>
+  makeBatched((as: Array<A>) =>
+    Effect.forEach(
+      f(as),
+      (res, i) => complete(as[i], core.exitSucceed(res) as any),
+      { discard: true }
+    )
+  ).identified("FromFunctionBatched", f)
+
+/** @internal */
+export const fromFunctionEffect = <R, A extends Request.Request<any, any>>(
+  f: (a: A) => Effect.Effect<R, Request.Request.Error<A>, Request.Request.Success<A>>
+): RequestResolver.RequestResolver<A, R> =>
+  makeBatched((requests: Array<A>) =>
+    Effect.forEach(
+      requests,
+      (a) => Effect.flatMap(Effect.exit(f(a)), (e) => complete(a, e as any)),
+      { concurrency: "unbounded", discard: true }
+    )
+  ).identified("FromFunctionEffect", f)
+
+/** @internal */
+export const never: RequestResolver.RequestResolver<never> = make(() => Effect.never).identified("Never")
+
+/** @internal */
+export const provideContext = dual<
+  <R>(
+    context: Context.Context<R>
+  ) => <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A>,
+  <R, A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>,
+    context: Context.Context<R>
+  ) => RequestResolver.RequestResolver<A>
+>(2, (self, context) =>
+  mapInputContext(
+    self,
+    (_: Context.Context<never>) => context
+  ).identified("ProvideContext", self, context))
+
+/** @internal */
+export const race = dual<
+  <R2, A2 extends Request.Request<any, any>>(
+    that: RequestResolver.RequestResolver<A2, R2>
+  ) => <R, A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A | A2, R | R2>,
+  <R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A, R>,
+    that: RequestResolver.RequestResolver<A2, R2>
+  ) => RequestResolver.RequestResolver<A | A2, R | R2>
+>(2, <R, A, R2, A2>(
+  self: RequestResolver.RequestResolver<A, R>,
+  that: RequestResolver.RequestResolver<A2, R2>
+) =>
+  new core.RequestResolverImpl((requests) =>
+    Effect.race(
+      self.runAll(requests as Array<Array<Request.Entry<A>>>),
+      that.runAll(requests as Array<Array<Request.Entry<A2>>>)
+    )
+  ).identified("Race", self, that))

package/src/internal/defaultServices/console.ts

@@ -0,0 +1,97 @@
+import type * as Console from "../../Console"
+import * as Context from "../../Context"
+import * as core from "../../internal/core"
+
+/** @internal */
+export const TypeId: Console.TypeId = Symbol.for("effect/Console") as Console.TypeId
+
+/** @internal */
+export const consoleTag: Context.Tag<Console.Console, Console.Console> = Context.Tag<Console.Console>(TypeId)
+
+/** @internal */
+export const defaultConsole: Console.Console = {
+  [TypeId]: TypeId,
+  assert(condition, ...args) {
+    return core.sync(() => {
+      console.assert(condition, ...args)
+    })
+  },
+  clear: core.sync(() => {
+    console.clear()
+  }),
+  count(label) {
+    return core.sync(() => {
+      console.count(label)
+    })
+  },
+  countReset(label) {
+    return core.sync(() => {
+      console.countReset(label)
+    })
+  },
+  debug(...args) {
+    return core.sync(() => {
+      console.debug(...args)
+    })
+  },
+  dir(item, options) {
+    return core.sync(() => {
+      console.dir(item, options)
+    })
+  },
+  dirxml(...args) {
+    return core.sync(() => {
+      console.dirxml(...args)
+    })
+  },
+  error(...args) {
+    return core.sync(() => {
+      console.error(...args)
+    })
+  },
+  group(options) {
+    return options?.collapsed ?
+      core.sync(() => console.groupCollapsed(options?.label)) :
+      core.sync(() => console.group(options?.label))
+  },
+  groupEnd: core.sync(() => {
+    console.groupEnd()
+  }),
+  info(...args) {
+    return core.sync(() => {
+      console.info(...args)
+    })
+  },
+  log(...args) {
+    return core.sync(() => {
+      console.log(...args)
+    })
+  },
+  table(tabularData, properties) {
+    return core.sync(() => {
+      console.table(tabularData, properties)
+    })
+  },
+  time(label) {
+    return core.sync(() => console.time(label))
+  },
+  timeEnd(label) {
+    return core.sync(() => console.timeEnd(label))
+  },
+  timeLog(label, ...args) {
+    return core.sync(() => {
+      console.timeLog(label, ...args)
+    })
+  },
+  trace(...args) {
+    return core.sync(() => {
+      console.trace(...args)
+    })
+  },
+  warn(...args) {
+    return core.sync(() => {
+      console.warn(...args)
+    })
+  },
+  unsafe: console
+}

package/src/internal/defaultServices.ts

@@ -0,0 +1,140 @@
+import type * as Chunk from "../Chunk"
+import type * as Clock from "../Clock"
+import type * as Config from "../Config"
+import type * as ConfigProvider from "../ConfigProvider"
+import * as Context from "../Context"
+import type * as DefaultServices from "../DefaultServices"
+import * as Duration from "../Duration"
+import type * as Effect from "../Effect"
+import { dual, pipe } from "../Function"
+import { globalValue } from "../GlobalValue"
+import * as clock from "../internal/clock"
+import * as configProvider from "../internal/configProvider"
+import * as core from "../internal/core"
+import * as console_ from "../internal/defaultServices/console"
+import * as random from "../internal/random"
+import * as tracer from "../internal/tracer"
+import type * as Random from "../Random"
+import type * as Tracer from "../Tracer"
+
+/** @internal */
+export const liveServices: Context.Context<DefaultServices.DefaultServices> = pipe(
+  Context.empty(),
+  Context.add(clock.clockTag, clock.make()),
+  Context.add(console_.consoleTag, console_.defaultConsole),
+  Context.add(random.randomTag, random.make((Math.random() * 4294967296) >>> 0)),
+  Context.add(configProvider.configProviderTag, configProvider.fromEnv()),
+  Context.add(tracer.tracerTag, tracer.nativeTracer)
+)
+
+/**
+ * The `FiberRef` holding the default `Effect` services.
+ *
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+export const currentServices = globalValue(
+  Symbol.for("effect/DefaultServices/currentServices"),
+  () => core.fiberRefUnsafeMakeContext(liveServices)
+)
+
+// circular with Clock
+
+/** @internal */
+export const sleep = (duration: Duration.DurationInput): Effect.Effect<never, never, void> => {
+  const decodedDuration = Duration.decode(duration)
+  return clockWith((clock) => clock.sleep(decodedDuration))
+}
+
+/** @internal */
+export const clockWith = <R, E, A>(f: (clock: Clock.Clock) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+  core.fiberRefGetWith(currentServices, (services) => f(Context.get(services, clock.clockTag)))
+
+/** @internal */
+export const currentTimeMillis: Effect.Effect<never, never, number> = clockWith((clock) => clock.currentTimeMillis)
+
+/** @internal */
+export const currentTimeNanos: Effect.Effect<never, never, bigint> = clockWith((clock) => clock.currentTimeNanos)
+
+/** @internal */
+export const withClock = dual<
+  <A extends Clock.Clock>(value: A) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A extends Clock.Clock>(effect: Effect.Effect<R, E, A>, value: A) => Effect.Effect<R, E, A>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(clock.clockTag, value)
+  )(effect))
+
+// circular with ConfigProvider
+
+/** @internal */
+export const withConfigProvider = dual<
+  (value: ConfigProvider.ConfigProvider) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, value: ConfigProvider.ConfigProvider) => Effect.Effect<R, E, A>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(configProvider.configProviderTag, value)
+  )(effect))
+
+/** @internal */
+export const configProviderWith = <R, E, A>(
+  f: (configProvider: ConfigProvider.ConfigProvider) => Effect.Effect<R, E, A>
+): Effect.Effect<R, E, A> =>
+  core.fiberRefGetWith(
+    currentServices,
+    (services) => f(Context.get(services, configProvider.configProviderTag))
+  )
+
+/** @internal */
+export const config = <A>(config: Config.Config<A>) => configProviderWith((_) => _.load(config))
+
+/** @internal */
+export const configOrDie = <A>(config: Config.Config<A>) => core.orDie(configProviderWith((_) => _.load(config)))
+
+// circular with Random
+
+/** @internal */
+export const randomWith = <R, E, A>(f: (random: Random.Random) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+  core.fiberRefGetWith(
+    currentServices,
+    (services) => f(Context.get(services, random.randomTag))
+  )
+
+/** @internal */
+export const next: Effect.Effect<never, never, number> = randomWith((random) => random.next())
+
+/** @internal */
+export const nextInt: Effect.Effect<never, never, number> = randomWith((random) => random.nextInt())
+
+/** @internal */
+export const nextBoolean: Effect.Effect<never, never, boolean> = randomWith((random) => random.nextBoolean())
+
+/** @internal */
+export const nextRange = (min: number, max: number): Effect.Effect<never, never, number> =>
+  randomWith((random) => random.nextRange(min, max))
+
+/** @internal */
+export const nextIntBetween = (min: number, max: number): Effect.Effect<never, never, number> =>
+  randomWith((random) => random.nextIntBetween(min, max))
+
+/** @internal */
+export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<never, never, Chunk.Chunk<A>> =>
+  randomWith((random) => random.shuffle(elements))
+
+// circular with Tracer
+
+/** @internal */
+export const tracerWith = <R, E, A>(f: (tracer: Tracer.Tracer) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+  core.fiberRefGetWith(currentServices, (services) => f(Context.get(services, tracer.tracerTag)))
+
+/** @internal */
+export const withTracer = dual<
+  (value: Tracer.Tracer) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, value: Tracer.Tracer) => Effect.Effect<R, E, A>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(tracer.tracerTag, value)
+  )(effect))

package/src/internal/deferred.ts

@@ -0,0 +1,44 @@
+import type * as Deferred from "../Deferred"
+import type * as Effect from "../Effect"
+import * as OpCodes from "../internal/opCodes/deferred"
+
+/** @internal */
+const DeferredSymbolKey = "effect/Deferred"
+
+/** @internal */
+export const DeferredTypeId: Deferred.DeferredTypeId = Symbol.for(
+  DeferredSymbolKey
+) as Deferred.DeferredTypeId
+
+/** @internal */
+export const deferredVariance = {
+  _E: (_: never) => _,
+  _A: (_: never) => _
+}
+
+/** @internal */
+export type State<E, A> = Pending<E, A> | Done<E, A>
+
+/** @internal */
+export interface Pending<E, A> {
+  readonly _tag: "Pending"
+  readonly joiners: Array<(effect: Effect.Effect<never, E, A>) => void>
+}
+
+/** @internal */
+export interface Done<E, A> {
+  readonly _tag: "Done"
+  readonly effect: Effect.Effect<never, E, A>
+}
+
+/** @internal */
+export const pending = <E, A>(
+  joiners: Array<(effect: Effect.Effect<never, E, A>) => void>
+): State<E, A> => {
+  return { _tag: OpCodes.OP_STATE_PENDING, joiners }
+}
+
+/** @internal */
+export const done = <E, A>(effect: Effect.Effect<never, E, A>): State<E, A> => {
+  return { _tag: OpCodes.OP_STATE_DONE, effect }
+}