effect 2.0.0-next.47 → 2.0.0-next.49

package/src/internal/core-effect.ts

@@ -22,7 +22,6 @@ import * as metricLabel from "../internal/metric/label"
 import * as runtimeFlags from "../internal/runtimeFlags"
 import * as SingleShotGen from "../internal/singleShotGen"
 import * as List from "../List"
-import type * as Logger from "../Logger"
 import * as LogLevel from "../LogLevel"
 import * as LogSpan from "../LogSpan"
 import type * as Metric from "../Metric"
@@ -38,14 +37,14 @@ import * as Tracer from "../Tracer"
 /* @internal */
 export const annotateLogs = dual<
   {
-    (key: string, value: Logger.AnnotationValue): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+    (key: string, value: unknown): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
     (
-      values: Record<string, Logger.AnnotationValue>
+      values: Record<string, unknown>
     ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
   },
   {
-    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: Logger.AnnotationValue): Effect.Effect<R, E, A>
-    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, Logger.AnnotationValue>): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: unknown): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, unknown>): Effect.Effect<R, E, A>
   }
 >(
   (args) => core.isEffect(args[0]),
@@ -57,7 +56,7 @@ export const annotateLogs = dual<
       typeof args[1] === "string"
         ? HashMap.set(args[1], args[2])
         : (annotations) =>
-          Object.entries(args[1] as Record<string, Logger.AnnotationValue>).reduce(
+          Object.entries(args[1] as Record<string, unknown>).reduce(
             (acc, [key, value]) => HashMap.set(acc, key, value),
             annotations
           )
@@ -942,7 +941,7 @@ export const withLogSpan = dual<
     )))
 
 /* @internal */
-export const logAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, Logger.AnnotationValue>> = core
+export const logAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, unknown>> = core
   .fiberRefGet(
     core.currentLogAnnotations
   )
@@ -1897,8 +1896,8 @@ export const serviceMembers = <I, S>(tag: Context.Tag<I, S>): {
 
 /* @internal */
 export const annotateCurrentSpan: {
-  (key: string, value: Tracer.AttributeValue): Effect.Effect<never, never, void>
-  (values: Record<string, Tracer.AttributeValue>): Effect.Effect<never, never, void>
+  (key: string, value: unknown): Effect.Effect<never, never, void>
+  (values: Record<string, unknown>): Effect.Effect<never, never, void>
 } = function(): Effect.Effect<never, never, void> {
   const args = arguments
   return core.flatMap(
@@ -1921,14 +1920,14 @@ export const annotateCurrentSpan: {
 /* @internal */
 export const annotateSpans = dual<
   {
-    (key: string, value: Tracer.AttributeValue): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+    (key: string, value: unknown): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
     (
-      values: Record<string, Tracer.AttributeValue>
+      values: Record<string, unknown>
     ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
   },
   {
-    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: Tracer.AttributeValue): Effect.Effect<R, E, A>
-    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, Tracer.AttributeValue>): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: unknown): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, unknown>): Effect.Effect<R, E, A>
   }
 >(
   (args) => core.isEffect(args[0]),
@@ -1940,7 +1939,7 @@ export const annotateSpans = dual<
       typeof args[1] === "string"
         ? HashMap.set(args[1], args[2])
         : (annotations) =>
-          Object.entries(args[1] as Record<string, Tracer.AttributeValue>).reduce(
+          Object.entries(args[1] as Record<string, unknown>).reduce(
             (acc, [key, value]) => HashMap.set(acc, key, value),
             annotations
           )
@@ -1971,12 +1970,12 @@ export const currentTimeNanosTracing = core.fiberRefGetWith(
 export const linkSpans = dual<
   (
     span: Tracer.ParentSpan,
-    attributes?: Record<string, Tracer.AttributeValue>
+    attributes?: Record<string, unknown>
   ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
   <R, E, A>(
     self: Effect.Effect<R, E, A>,
     span: Tracer.ParentSpan,
-    attributes?: Record<string, Tracer.AttributeValue>
+    attributes?: Record<string, unknown>
   ) => Effect.Effect<R, E, A>
 >(
   (args) => core.isEffect(args[0]),
@@ -1998,10 +1997,11 @@ export const linkSpans = dual<
 export const makeSpan = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ) =>
@@ -2031,6 +2031,7 @@ export const makeSpan = (
                         parent,
                         options?.context ?? Context.empty(),
                         linksArray,
+                        options?.sampled ?? (parent._tag === "Some" ? parent.value.sampled : true),
                         startTime
                       )
                       HashMap.forEach(annotations, (value, key) => span.attribute(key, value))
@@ -2044,7 +2045,7 @@ export const makeSpan = (
   )
 
 /* @internal */
-export const spanAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, Tracer.AttributeValue>> = core
+export const spanAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, unknown>> = core
   .fiberRefGet(core.currentTracerSpanAnnotations)
 
 /* @internal */
@@ -2055,10 +2056,11 @@ export const spanLinks: Effect.Effect<never, never, Chunk.Chunk<Tracer.SpanLink>
 export const useSpan: {
   <R, E, A>(name: string, evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
   <R, E, A>(name: string, options: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }, evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
 } = <R, E, A>(
@@ -2069,10 +2071,11 @@ export const useSpan: {
   ]
 ) => {
   const options: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   } | undefined = args.length === 1 ? undefined : args[0]
   const evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A> = args[args.length - 1]
@@ -2102,17 +2105,19 @@ export const withParentSpan = dual<
 /** @internal */
 export const withSpan = dual<
   (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
   <R, E, A>(self: Effect.Effect<R, E, A>, name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }) => Effect.Effect<R, E, A>
 >(

package/src/internal/core.ts

@@ -28,7 +28,6 @@ import * as DeferredOpCodes from "../internal/opCodes/deferred"
 import * as OpCodes from "../internal/opCodes/effect"
 import * as _runtimeFlags from "../internal/runtimeFlags"
 import * as List from "../List"
-import type * as Logger from "../Logger"
 import type * as LogLevel from "../LogLevel"
 import type * as LogSpan from "../LogSpan"
 import type * as MetricLabel from "../MetricLabel"
@@ -1846,7 +1845,7 @@ export const currentMaxOpsBeforeYield: FiberRef.FiberRef<number> = globalValue(
 )
 
 /** @internal */
-export const currentLogAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, Logger.AnnotationValue>> = globalValue(
+export const currentLogAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, unknown>> = globalValue(
   Symbol.for("effect/FiberRef/currentLogAnnotation"),
   () => fiberRefUnsafeMake(HashMap.empty())
 )
@@ -1945,11 +1944,10 @@ export const currentTracerTimingEnabled: FiberRef.FiberRef<boolean> = globalValu
 )
 
 /** @internal */
-export const currentTracerSpanAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, Tracer.AttributeValue>> =
-  globalValue(
-    Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"),
-    () => fiberRefUnsafeMake(HashMap.empty())
-  )
+export const currentTracerSpanAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, unknown>> = globalValue(
+  Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"),
+  () => fiberRefUnsafeMake(HashMap.empty())
+)
 
 /** @internal */
 export const currentTracerSpanLinks: FiberRef.FiberRef<Chunk.Chunk<Tracer.SpanLink>> = globalValue(

package/src/internal/fiberRuntime.ts

@@ -17,6 +17,7 @@ import * as FiberRefsPatch from "../FiberRefsPatch"
 import * as FiberStatus from "../FiberStatus"
 import type { LazyArg } from "../Function"
 import { dual, identity, pipe } from "../Function"
+import * as HashMap from "../HashMap"
 import * as HashSet from "../HashSet"
 import * as _RequestBlock from "../internal/blockedRequests"
 import * as internalCause from "../internal/cause"
@@ -1382,7 +1383,7 @@ export const tracerLogger = internalLogger.makeLogger<unknown, void>(({
     return
   }
 
-  const attributes = Object.fromEntries(annotations)
+  const attributes = Object.fromEntries(HashMap.map(annotations, (value) => internalLogger.serializeUnknown(value)))
   attributes["effect.fiberId"] = FiberId.threadName(fiberId)
   attributes["effect.logLevel"] = logLevel.label
 
@@ -3429,13 +3430,14 @@ export const interruptWhenPossible = dual<
 // circular Tracer
 
 /** @internal */
-export const useSpanScoped = (
+export const makeSpanScoped = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ): Effect.Effect<Scope.Scope, never, Tracer.Span> =>
@@ -3449,23 +3451,20 @@ export const useSpanScoped = (
   )
 
 /* @internal */
-export const withSpanScoped = (
+export const setSpan = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ): Effect.Effect<Scope.Scope, never, void> =>
-  core.flatMap(
-    useSpanScoped(name, options),
-    (span) =>
-      fiberRefLocallyScopedWith(
-        core.currentTracerSpan,
-        List.prepend(span)
-      )
+  core.tap(
+    makeSpanScoped(name, options),
+    (span) => setParentSpan(span)
   )
 
 /* @internal */
@@ -3473,5 +3472,32 @@ export const withTracerScoped = (value: Tracer.Tracer): Effect.Effect<Scope.Scop
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value))
 
 /* @internal */
-export const withParentSpanScoped = (span: Tracer.ParentSpan): Effect.Effect<Scope.Scope, never, void> =>
+export const setParentSpan = (span: Tracer.ParentSpan): Effect.Effect<Scope.Scope, never, void> =>
   fiberRefLocallyScopedWith(core.currentTracerSpan, List.prepend(span))
+
+/** @internal */
+export const withSpanScoped = dual<
+  (name: string, options?: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly sampled?: boolean
+    readonly context?: Context.Context<never>
+  }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | Scope.Scope, E, A>,
+  <R, E, A>(self: Effect.Effect<R, E, A>, name: string, options?: {
+    readonly attributes?: Record<string, unknown>
+    readonly links?: ReadonlyArray<Tracer.SpanLink>
+    readonly parent?: Tracer.ParentSpan
+    readonly root?: boolean
+    readonly sampled?: boolean
+    readonly context?: Context.Context<never>
+  }) => Effect.Effect<R | Scope.Scope, E, A>
+>(
+  (args) => typeof args[0] !== "string",
+  (self, name, options) =>
+    core.flatMap(
+      makeSpanScoped(name, options),
+      (span) => core.fiberRefLocallyWith(self, core.currentTracerSpan, List.prepend(span))
+    )
+)

package/src/internal/groupBy.ts

@@ -35,6 +35,10 @@ const groupByVariance = {
   _V: (_: never) => _
 }
 
+/** @internal */
+export const isGroupBy = (u: unknown): u is GroupBy.GroupBy<unknown, unknown, unknown, unknown> =>
+  typeof u === "object" && u != null && GroupByTypeId in u
+
 /** @internal */
 export const evaluate = dual<
   <K, E, V, R2, E2, A>(
@@ -47,7 +51,7 @@ export const evaluate = dual<
     options?: { readonly bufferSize?: number }
   ) => Stream.Stream<R2 | R, E | E2, A>
 >(
-  3,
+  (args) => isGroupBy(args[0]),
   <R, K, E, V, R2, E2, A>(
     self: GroupBy.GroupBy<R, E, K, V>,
     f: (key: K, stream: Stream.Stream<never, E, V>) => Stream.Stream<R2, E2, A>,
@@ -122,7 +126,7 @@ export const groupBy = dual<
     options?: { readonly bufferSize?: number }
   ) => GroupBy.GroupBy<R2 | R, E2 | E, K, V>
 >(
-  (args) => typeof args[0] !== "function",
+  (args) => stream.isStream(args[0]),
   <R, E, A, R2, E2, K, V>(
     self: Stream.Stream<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, readonly [K, V]>,
@@ -240,7 +244,7 @@ export const mapEffectOptions = dual<
     if (options?.key) {
       return evaluate(
         groupByKey(self, options.key, { bufferSize: options.bufferSize }),
-        (_, s) => pipe(s, stream.mapEffectSequential(f))
+        (_, s) => stream.mapEffectSequential(s, f)
       )
     }
 

package/src/internal/layer/circular.ts

@@ -1,6 +1,7 @@
 import type * as ConfigProvider from "../../ConfigProvider"
 import type * as Context from "../../Context"
 import type * as Effect from "../../Effect"
+import type * as Exit from "../../Exit"
 import { dual } from "../../Function"
 import * as HashSet from "../../HashSet"
 import * as core from "../../internal/core"
@@ -9,7 +10,7 @@ import * as layer from "../../internal/layer"
 import * as runtimeFlags from "../../internal/runtimeFlags"
 import * as runtimeFlagsPatch from "../../internal/runtimeFlagsPatch"
 import * as _supervisor from "../../internal/supervisor"
-import * as Layer from "../../Layer"
+import type * as Layer from "../../Layer"
 import type * as Logger from "../../Logger"
 import type * as LogLevel from "../../LogLevel"
 import type { Scope } from "../../Scope"
@@ -50,7 +51,7 @@ export const addLogger = <A>(logger: Logger.Logger<unknown, A>): Layer.Layer<nev
 export const addLoggerEffect = <R, E, A>(
   effect: Effect.Effect<R, E, Logger.Logger<unknown, A>>
 ): Layer.Layer<R, E, never> =>
-  Layer.unwrapEffect(
+  layer.unwrapEffect(
     core.map(effect, addLogger)
   )
 
@@ -58,7 +59,7 @@ export const addLoggerEffect = <R, E, A>(
 export const addLoggerScoped = <R, E, A>(
   effect: Effect.Effect<R, E, Logger.Logger<unknown, A>>
 ): Layer.Layer<Exclude<R, Scope>, E, never> =>
-  Layer.unwrapScoped(
+  layer.unwrapScoped(
     core.map(effect, addLogger)
   )
 
@@ -184,19 +185,33 @@ export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider)
 
 /** @internal */
 export const setParentSpan = (span: Tracer.ParentSpan): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(fiberRuntime.withParentSpanScoped(span))
+  layer.scopedDiscard(fiberRuntime.setParentSpan(span))
 
 /** @internal */
 export const setSpan = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
+    readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
   }
-): Layer.Layer<never, never, never> => layer.scopedDiscard(fiberRuntime.withSpanScoped(name, options))
+): Layer.Layer<never, never, never> =>
+  layer.scopedDiscard(
+    options?.onEnd
+      ? core.tap(
+        fiberRuntime.makeSpanScoped(name, options),
+        (span) =>
+          core.zipRight(
+            fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit)),
+            fiberRuntime.setParentSpan(span)
+          )
+      )
+      : fiberRuntime.setSpan(name, options)
+  )
 
 /** @internal */
 export const setTracer = (tracer: Tracer.Tracer): Layer.Layer<never, never, never> =>

package/src/internal/layer.ts

@@ -18,6 +18,7 @@ import * as ref from "../internal/ref"
 import * as runtime from "../internal/runtime"
 import * as synchronized from "../internal/synchronizedRef"
 import type * as Layer from "../Layer"
+import * as List from "../List"
 import { pipeArguments } from "../Pipeable"
 import type * as Runtime from "../Runtime"
 import type * as Schedule from "../Schedule"
@@ -1122,27 +1123,42 @@ export const unwrapScoped = <R, E, R1, E1, A>(
 /** @internal */
 export const withSpan = dual<
   (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
+    readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
   }) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<R, E, A>,
   <R, E, A>(self: Layer.Layer<R, E, A>, name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
+    readonly sampled?: boolean
     readonly context?: Context.Context<never>
+    readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
   }) => Layer.Layer<R, E, A>
 >((args) => isLayer(args[0]), (self, name, options) =>
   unwrapScoped(
     core.map(
-      fiberRuntime.useSpanScoped(name, options),
-      (span) => locallyEffect(self, effect.withParentSpan(span))
+      options?.onEnd
+        ? core.tap(
+          fiberRuntime.makeSpanScoped(name, options),
+          (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+        )
+        : fiberRuntime.makeSpanScoped(name, options),
+      (span) => withParentSpan(self, span)
     )
   ))
 
+/** @internal */
+export const withParentSpan = dual<
+  (span: Tracer.ParentSpan) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<R, E, A>,
+  <R, E, A>(self: Layer.Layer<R, E, A>, span: Tracer.ParentSpan) => Layer.Layer<R, E, A>
+>(2, (self, span) => fiberRefLocallyWith(self, core.currentTracerSpan, List.prepend(span)))
+
 // circular with Effect
 
 const provideSomeLayer = dual<

package/src/internal/logger.ts

@@ -37,7 +37,7 @@ export const makeLogger = <Message, Output>(
       readonly cause: CauseExt.Cause<unknown>
       readonly context: FiberRefs.FiberRefs
       readonly spans: List.List<LogSpan.LogSpan>
-      readonly annotations: HashMap.HashMap<string, Logger.AnnotationValue>
+      readonly annotations: HashMap.HashMap<string, unknown>
       readonly date: Date
     }
   ) => Output
@@ -207,7 +207,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
         }
         output = output + filterKeyName(key)
         output = output + "="
-        output = appendQuoted(String(value), output)
+        output = appendQuoted(serializeUnknown(value), output)
       }
     }
 
@@ -215,7 +215,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
   }
 )
 
-const serializeUnknown = (u: unknown): string => {
+export const serializeUnknown = (u: unknown): string => {
   try {
     return typeof u === "object" ? JSON.stringify(u) : String(u)
   } catch (_) {
@@ -282,7 +282,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
         }
         output = output + filterKeyName(key)
         output = output + "="
-        output = appendQuotedLogfmt(String(value), output)
+        output = appendQuotedLogfmt(serializeUnknown(value), output)
       }
     }