MCPcopy Create free account
hub / github.com/Effect-TS/effect / make

Function make

packages/effect/src/ManagedRuntime.ts:285–386  ·  view source on GitHub ↗
(
  layer: Layer.Layer<R, ER, never>,
  options?: {
    readonly memoMap?: Layer.MemoMap | undefined
  } | undefined
)

Source from the content-addressed store, hash-verified

283 * @since 2.0.0
284 */
285export const make = <R, ER>(
286 layer: Layer.Layer<R, ER, never>,
287 options?: {
288 readonly memoMap?: Layer.MemoMap | undefined
289 } | undefined
290): ManagedRuntime<R, ER> => {
291 const memoMap = options?.memoMap ?? Layer.makeMemoMapUnsafe()
292 const scope = Scope.makeUnsafe("parallel")
293 const layerScope = Scope.forkUnsafe(scope, "sequential")
294 const defaultRunOptions: Effect.RunOptions = {
295 onFiberStart: Fiber.runIn(scope)
296 }
297 const mergeRunOptions = <O extends Effect.RunOptions>(options?: O): O =>
298 options
299 ? {
300 ...options,
301 onFiberStart: options.onFiberStart ?
302 (fiber) => {
303 defaultRunOptions.onFiberStart!(fiber)
304 options.onFiberStart!(fiber)
305 } :
306 defaultRunOptions.onFiberStart
307 }
308 : defaultRunOptions as O
309 let buildFiber: Fiber.Fiber<Context.Context<R>, ER> | undefined
310 const contextEffect = Effect.withFiber<Context.Context<R>, ER>((fiber) => {
311 if (!buildFiber) {
312 buildFiber = Effect.runFork(
313 Effect.tap(
314 Layer.buildWithMemoMap(layer, memoMap, layerScope),
315 (context) =>
316 Effect.sync(() => {
317 self.cachedContext = context
318 })
319 ),
320 { ...defaultRunOptions, scheduler: fiber.currentScheduler }
321 )
322 }
323 return Effect.flatten(Fiber.await(buildFiber))
324 })
325 const self: ManagedRuntime<R, ER> = {
326 [TypeId]: TypeId,
327 memoMap,
328 scope,
329 contextEffect: contextEffect,
330 cachedContext: undefined,
331 context() {
332 return self.cachedContext === undefined ?
333 Effect.runPromise(self.contextEffect) :
334 Promise.resolve(self.cachedContext)
335 },
336 dispose(): Promise<void> {
337 return Effect.runPromise(self.disposeEffect)
338 },
339 [Symbol.asyncDispose](): Promise<void> {
340 return self.dispose()
341 },
342 disposeEffect: Effect.suspend(() => {

Callers

nothing calls this directly

Calls 3

awaitMethod · 0.65
closeMethod · 0.65
syncMethod · 0.45

Tested by

no test coverage detected