effect 4.0.0-beta.10 → 4.0.0-beta.12

package/src/Logger.ts

@@ -115,8 +115,7 @@ import type { PlatformError } from "./PlatformError.ts"
 import * as Predicate from "./Predicate.ts"
 import { CurrentLogAnnotations, CurrentLogSpans } from "./References.ts"
 import type * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
-import type * as Types from "./Types.ts"
+import type * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Logger"
 
@@ -144,8 +143,9 @@ const TypeId = "~effect/Logger"
  * @since 2.0.0
  * @category models
  */
-export interface Logger<in Message, out Output> extends Logger.Variance<Message, Output>, Pipeable {
-  log: (options: Logger.Options<Message>) => Output
+export interface Logger<in Message, out Output> extends Pipeable {
+  readonly [TypeId]: typeof TypeId
+  log(options: Options<Message>): Output
 }
 
 /**
@@ -153,100 +153,32 @@ export interface Logger<in Message, out Output> extends Logger.Variance<Message,
  * ```ts
  * import { Effect, Logger } from "effect"
  *
- * // Access Logger namespace types and functionality
- * const customLogger = Logger.make((options) => {
- *   console.log(`Message: ${options.message}`)
- *   console.log(`Level: ${options.logLevel}`)
- *   console.log(`Date: ${options.date.toISOString()}`)
- *   console.log(`Fiber ID: ${options.fiber.id}`)
+ * // Options interface provides all logging context
+ * const detailedLogger = Logger.make((options) => {
+ *   const output = {
+ *     message: options.message,
+ *     level: options.logLevel,
+ *     timestamp: options.date.toISOString(),
+ *     fiberId: options.fiber.id,
+ *     hasCause: options.cause !== undefined
+ *   }
+ *   console.log(JSON.stringify(output))
  * })
  *
- * // The Logger namespace contains types like Options, Variance, etc.
- * const program = Effect.log("Hello World").pipe(
- *   Effect.provide(Logger.layer([customLogger]))
+ * const program = Effect.log("Processing request").pipe(
+ *   Effect.provide(Logger.layer([detailedLogger]))
  * )
  * ```
  *
  * @since 2.0.0
  * @category models
  */
-export declare namespace Logger {
-  /**
-   * @example
-   * ```ts
-   * import { Logger } from "effect"
-   *
-   * // Variance interface defines contravariance for Message and covariance for Output
-   * const customLogger = Logger.make<unknown, void>((options) => {
-   *   console.log(options.message)
-   * })
-   *
-   * // The logger can accept more specific message types (contravariance)
-   * // and can be used where less specific output types are expected (covariance)
-   * ```
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<in Message, out Output> {
-    readonly [TypeId]: VarianceStruct<Message, Output>
-  }
-
-  /**
-   * @example
-   * ```ts
-   * import { Logger } from "effect"
-   *
-   * // VarianceStruct defines the actual variance structure used internally
-   * // This structure ensures proper typing and variance behavior
-   * const logger = Logger.make<unknown, void>((options) => {
-   *   console.log(options.message)
-   * })
-   *
-   * // The variance structure handles contravariance for input Message type
-   * // and covariance for output Output type
-   * ```
-   *
-   * @since 4.0.0
-   * @category models
-   */
-  export interface VarianceStruct<in Message, out Output> {
-    _Message: Types.Contravariant<Message>
-    _Output: Types.Covariant<Output>
-  }
-
-  /**
-   * @example
-   * ```ts
-   * import { Effect, Logger } from "effect"
-   *
-   * // Options interface provides all logging context
-   * const detailedLogger = Logger.make((options) => {
-   *   const output = {
-   *     message: options.message,
-   *     level: options.logLevel,
-   *     timestamp: options.date.toISOString(),
-   *     fiberId: options.fiber.id,
-   *     hasCause: options.cause !== undefined
-   *   }
-   *   console.log(JSON.stringify(output))
-   * })
-   *
-   * const program = Effect.log("Processing request").pipe(
-   *   Effect.provide(Logger.layer([detailedLogger]))
-   * )
-   * ```
-   *
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Options<out Message> {
-    readonly message: Message
-    readonly logLevel: LogLevel.LogLevel
-    readonly cause: Cause.Cause<unknown>
-    readonly fiber: Fiber.Fiber<unknown, unknown>
-    readonly date: Date
-  }
+export interface Options<out Message> {
+  readonly message: Message
+  readonly logLevel: LogLevel.LogLevel
+  readonly cause: Cause.Cause<unknown>
+  readonly fiber: Fiber.Fiber<unknown, unknown>
+  readonly date: Date
 }
 
 /**
@@ -562,7 +494,7 @@ const format = (
   quoteValue: (s: string) => string,
   space?: number | string | undefined
 ) =>
-({ cause, date, fiber, logLevel, message }: Logger.Options<unknown>): string => {
+({ cause, date, fiber, logLevel, message }: Options<unknown>): string => {
   const formatValue = (value: string): string => value.match(textOnly) ? value : quoteValue(value)
   const format = (label: string, value: string): string => `${effect.formatLabel(label)}=${formatValue(value)}`
   const append = (label: string, value: string): string => " " + format(label, value)
@@ -636,7 +568,7 @@ const format = (
  * @category constructors
  */
 export const make: <Message, Output>(
-  log: (options: Logger.Options<Message>) => Output
+  log: (options: Options<Message>) => Output
 ) => Logger<Message, Output> = effect.loggerMake
 
 /**
@@ -1389,7 +1321,7 @@ export const layer = <
   const Loggers extends ReadonlyArray<Logger<unknown, unknown> | Effect.Effect<Logger<unknown, unknown>, any, any>>
 >(
   loggers: Loggers,
-  options?: { mergeWithExisting: boolean }
+  options?: { readonly mergeWithExisting?: boolean | undefined } | undefined
 ): Layer.Layer<
   never,
   Loggers extends readonly [] ? never : Effect.Error<Loggers[number]>,
@@ -1398,13 +1330,14 @@ export const layer = <
     Scope.Scope
   >
 > =>
-  Layer.effectServices(
+  Layer.effect(
+    CurrentLoggers,
     withFiber(effect.fnUntraced(function*(fiber) {
       const currentLoggers = new Set(options?.mergeWithExisting === true ? fiber.getRef(effect.CurrentLoggers) : [])
       for (const logger of loggers) {
         currentLoggers.add(isEffect(logger) ? yield* logger : logger)
       }
-      return ServiceMap.make(effect.CurrentLoggers, currentLoggers)
+      return currentLoggers
     }))
   )
 

package/src/Queue.ts

@@ -1113,7 +1113,6 @@ export const collect = <A, E>(self: Dequeue<A, E | Done>): Effect<Array<A>, Pull
           while: constTrue,
           body: constant(takeAll(self)),
           step(items: Arr.NonEmptyArray<A>) {
-            out.push(...items)
             for (let i = 0; i < items.length; i++) {
               out.push(items[i])
             }

package/src/Random.ts

@@ -76,6 +76,24 @@ const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effec
  */
 export const next: Effect.Effect<number> = randomWith((r) => r.nextDoubleUnsafe())
 
+/**
+ * Generates a random boolean value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const value = yield* Random.nextBoolean
+ *   console.log("Random boolean:", value)
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Random Number Generators
+ */
+export const nextBoolean: Effect.Effect<boolean> = randomWith((r) => r.nextDoubleUnsafe() > 0.5)
+
 /**
  * Generates a random integer between `Number.MIN_SAFE_INTEGER` (inclusive)
  * and `Number.MAX_SAFE_INTEGER` (inclusive).

package/src/References.ts

@@ -11,7 +11,7 @@
  * @since 4.0.0
  */
 import { constTrue, constUndefined } from "./Function.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { LogLevel, Severity } from "./LogLevel.ts"
 import type { ReadonlyRecord } from "./Record.ts"
 import { MaxOpsBeforeYield } from "./Scheduler.ts"
 import * as ServiceMap from "./ServiceMap.ts"
@@ -451,7 +451,7 @@ export const CurrentLogAnnotations = ServiceMap.Reference<ReadonlyRecord<string,
  * @category references
  * @since 4.0.0
  */
-export const CurrentLogLevel: ServiceMap.Reference<LogLevel> = ServiceMap.Reference<LogLevel>(
+export const CurrentLogLevel: ServiceMap.Reference<Severity> = ServiceMap.Reference<Severity>(
   "effect/References/CurrentLogLevel",
   { defaultValue: () => "Info" }
 )
@@ -516,9 +516,9 @@ export const MinimumLogLevel = ServiceMap.Reference<
  * @category references
  * @since 4.0.0
  */
-export const UnhandledLogLevel: ServiceMap.Reference<LogLevel | undefined> = ServiceMap.Reference(
+export const UnhandledLogLevel: ServiceMap.Reference<Severity | undefined> = ServiceMap.Reference(
   "effect/References/UnhandledLogLevel",
-  { defaultValue: (): LogLevel | undefined => "Error" }
+  { defaultValue: (): Severity | undefined => "Error" }
 )
 
 /**

package/src/Schema.ts

@@ -1717,7 +1717,7 @@ export function fieldsAssign<const NewFields extends Struct.Fields>(fields: NewF
  * @since 4.0.0
  */
 export function encodeKeys<
-  S extends Struct<Struct.Fields>,
+  S extends Top & { readonly fields: Struct.Fields },
   const M extends { readonly [K in keyof S["fields"]]?: PropertyKey }
 >(mapping: M) {
   return function(

package/src/SchemaAST.ts

@@ -1455,7 +1455,8 @@ export class Arrays extends Base {
         // handle post rest elements
         // ---------------------------------------------
         for (let j = 0; j < tail.length; j++) {
-          if (len < i + 1) {
+          i += j
+          if (len < i) {
             continue
           } else {
             const tailj = tail[j]

package/src/Stream.ts

@@ -22,7 +22,7 @@ import { addSpanStackTrace } from "./internal/tracer.ts"
 import * as Iterable from "./Iterable.ts"
 import * as Latch from "./Latch.ts"
 import type * as Layer from "./Layer.ts"
-import type { LogLevel } from "./LogLevel.ts"
+import type { Severity } from "./LogLevel.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import * as MutableList from "./MutableList.ts"
 import * as Option from "./Option.ts"
@@ -8820,12 +8820,12 @@ export const orDie = <A, E, R>(self: Stream<A, E, R>): Stream<A, never, R> => fr
  */
 export const ignore: <
   Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 >(
   selfOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R>
   : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R> = dual(
@@ -8833,7 +8833,7 @@ export const ignore: <
     <A, E, R>(
       self: Stream<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel | undefined
+        readonly log?: boolean | Severity | undefined
       } | undefined
     ): Stream<A, never, R> => fromChannel(Channel.ignore(self.channel, options))
   )
@@ -8860,19 +8860,19 @@ export const ignore: <
  */
 export const ignoreCause: <
   Arg extends Stream<any, any, any> | {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 >(
   streamOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel | undefined
+    readonly log?: boolean | Severity | undefined
   } | undefined
 ) => [Arg] extends [Stream<infer A, infer _E, infer R>] ? Stream<A, never, R>
   : <A, E, R>(self: Stream<A, E, R>) => Stream<A, never, R> = dual(
     (args) => isStream(args[0]),
     <A, E, R>(
       self: Stream<A, E, R>,
-      options?: { readonly log?: boolean | LogLevel | undefined } | undefined
+      options?: { readonly log?: boolean | Severity | undefined } | undefined
     ): Stream<A, never, R> => fromChannel(Channel.ignoreCause(self.channel, options))
   )
 

package/src/index.ts

@@ -1119,6 +1119,11 @@ export * as Equal from "./Equal.ts"
  */
 export * as Equivalence from "./Equivalence.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as ErrorReporter from "./ErrorReporter.ts"
+
 /**
  * @since 3.16.0
  */