effect 4.0.0-beta.93 → 4.0.0-beta.97

package/src/Cron.ts

@@ -110,6 +110,8 @@ export interface Cron extends Pipeable, Equal.Equal, Inspectable {
   readonly months: ReadonlySet<number>
   readonly weekdays: ReadonlySet<number>
   /** @internal */
+  readonly and: boolean
+  /** @internal */
   readonly first: {
     readonly second: number
     readonly minute: number
@@ -167,6 +169,7 @@ const CronProto = {
   [Hash.symbol](this: Cron): number {
     return pipe(
       Hash.hash(this.tz),
+      Hash.combine(Hash.hash(this.and)),
       Hash.combine(Hash.array(Arr.fromIterable(this.seconds))),
       Hash.combine(Hash.array(Arr.fromIterable(this.minutes))),
       Hash.combine(Hash.array(Arr.fromIterable(this.hours))),
@@ -252,7 +255,9 @@ export const isCron = (u: unknown): u is Cron => hasProperty(u, TypeId)
  *
  * Constructs a cron schedule by specifying which seconds, minutes, hours,
  * days, months, and weekdays the schedule should match. Empty arrays mean
- * "match all" for that time unit.
+ * "match all" for that time unit. When both days and weekdays are restricted,
+ * the default matches either field; set `and: true` to require both fields to
+ * match.
  *
  * **Example** (Creating schedules from constraints)
  *
@@ -354,6 +359,7 @@ export const make = (values: {
   readonly days: Iterable<number>
   readonly months: Iterable<number>
   readonly weekdays: Iterable<number>
+  readonly and?: boolean | undefined
   readonly tz?: DateTime.TimeZone | undefined
 }): Cron => {
   const o: Mutable<Cron> = Object.create(CronProto)
@@ -363,6 +369,7 @@ export const make = (values: {
   o.days = new Set(Arr.sort(values.days, N.Order))
   o.months = new Set(Arr.sort(values.months, N.Order))
   o.weekdays = new Set(Arr.sort(values.weekdays, N.Order))
+  o.and = values.and === true
   o.tz = Option.fromUndefinedOr(values.tz)
 
   const seconds = Array.from(o.seconds)
@@ -563,7 +570,7 @@ export const isCronParseError = (u: unknown): u is CronParseError => hasProperty
  * @since 2.0.0
  */
 export const parse = (cron: string, tz?: DateTime.TimeZone | string): Result.Result<Cron, CronParseError> => {
-  const segments = cron.split(" ").filter(String.isNonEmpty)
+  const segments = cron.trim().split(/\s+/).filter(String.isNonEmpty)
   if (segments.length !== 5 && segments.length !== 6) {
     return Result.fail(new CronParseError({ message: `Invalid number of segments in cron expression`, input: cron }))
   }
@@ -588,7 +595,18 @@ export const parse = (cron: string, tz?: DateTime.TimeZone | string): Result.Res
     days: parseSegment(days, dayOptions),
     months: parseSegment(months, monthOptions),
     weekdays: parseSegment(weekdays, weekdayOptions)
-  }).pipe(Result.map(make))
+  }).pipe(Result.map(({ tz, seconds, minutes, hours, days, months, weekdays }) =>
+    make({
+      tz,
+      seconds: seconds.values,
+      minutes: minutes.values,
+      hours: hours.values,
+      days: days.values,
+      months: months.values,
+      weekdays: weekdays.values,
+      and: (days.wildcard || weekdays.wildcard) && days.values.size !== 0 && weekdays.values.size !== 0
+    })
+  ))
 }
 
 /**
@@ -682,6 +700,11 @@ export const match = (cron: Cron, date: DateTime.DateTime.Input): boolean => {
     return true
   }
 
+  if (cron.and) {
+    return (cron.days.size === 0 || cron.days.has(parts.day)) &&
+      (cron.weekdays.size === 0 || cron.weekdays.has(parts.weekDay))
+  }
+
   if (cron.weekdays.size === 0) {
     return cron.days.has(parts.day)
   }
@@ -843,46 +866,59 @@ const stepCron = (cron: Cron, now: DateTime.DateTime.Input | undefined, directio
       }
 
       if (cron.weekdays.size !== 0 || cron.days.size !== 0) {
-        let a: number = reverse ? -Infinity : Infinity
-        let b: number = reverse ? -Infinity : Infinity
-
-        if (cron.weekdays.size !== 0) {
-          const currentWeekday = current.getUTCDay()
-          const nextWeekday = table.weekday[currentWeekday]
-          if (nextWeekday === undefined) {
-            a = reverse ?
-              currentWeekday - 7 + boundary.weekday :
-              7 - currentWeekday + boundary.weekday
-          } else {
-            a = nextWeekday - currentWeekday
+        if (cron.and) {
+          const matchesDay = cron.days.size === 0 || cron.days.has(current.getUTCDate())
+          const matchesWeekday = cron.weekdays.size === 0 || cron.weekdays.has(current.getUTCDay())
+          if (!matchesDay || !matchesWeekday) {
+            current.setUTCDate(current.getUTCDate() + tick)
+            current.setUTCHours(boundary.hour, boundary.minute, boundary.second)
+            adjustDst(current)
+            continue
           }
-        }
-
-        if (cron.days.size !== 0 && a !== 0) {
-          const currentDay = current.getUTCDate()
-          const nextDay = table.day[currentDay]
-          if (nextDay === undefined) {
-            if (reverse) {
-              const prevMonthDays = daysInMonth(new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), 0)))
-              b = -(currentDay + (prevMonthDays - boundary.day))
+        } else {
+          let a: number = reverse ? -Infinity : Infinity
+          let b: number = reverse ? -Infinity : Infinity
+
+          if (cron.weekdays.size !== 0) {
+            const currentWeekday = current.getUTCDay()
+            const nextWeekday = table.weekday[currentWeekday]
+            if (nextWeekday === undefined) {
+              a = reverse ?
+                currentWeekday - 7 + boundary.weekday :
+                7 - currentWeekday + boundary.weekday
             } else {
+              a = nextWeekday - currentWeekday
+            }
+          }
+
+          if (cron.days.size !== 0 && a !== 0) {
+            const currentDay = current.getUTCDate()
+            const nextDay = table.day[currentDay]
+            if (nextDay === undefined) {
+              if (reverse) {
+                const prevMonthDays = daysInMonth(
+                  new Date(Date.UTC(current.getUTCFullYear(), current.getUTCMonth(), 0))
+                )
+                b = -(currentDay + (prevMonthDays - boundary.day))
+              } else {
+                b = daysInMonth(current) - currentDay + boundary.day
+              }
+            } else if (!reverse && nextDay > daysInMonth(current)) {
+              // The next matching day does not exist in the current month. Setting it
+              // directly would overflow and skip earlier matching days next month.
               b = daysInMonth(current) - currentDay + boundary.day
+            } else {
+              b = nextDay - currentDay
             }
-          } else if (!reverse && nextDay > daysInMonth(current)) {
-            // The next matching day does not exist in the current month. Setting it
-            // directly would overflow and skip earlier matching days next month.
-            b = daysInMonth(current) - currentDay + boundary.day
-          } else {
-            b = nextDay - currentDay
           }
-        }
 
-        const addDays = reverse ? Math.max(a, b) : Math.min(a, b)
-        if (addDays !== 0) {
-          current.setUTCDate(current.getUTCDate() + addDays)
-          current.setUTCHours(boundary.hour, boundary.minute, boundary.second)
-          adjustDst(current)
-          continue
+          const addDays = reverse ? Math.max(a, b) : Math.min(a, b)
+          if (addDays !== 0) {
+            current.setUTCDate(current.getUTCDate() + addDays)
+            current.setUTCHours(boundary.hour, boundary.minute, boundary.second)
+            adjustDst(current)
+            continue
+          }
         }
       }
 
@@ -890,11 +926,11 @@ const stepCron = (cron: Cron, now: DateTime.DateTime.Input | undefined, directio
         const currentMonth = current.getUTCMonth() + 1
         const nextMonth = table.month[currentMonth]
         const clampBoundaryDay = (targetMonthIndex: number): number => {
-          if (cron.days.size !== 0) {
+          if (cron.days.size !== 0 && cron.weekdays.size === 0) {
             return boundary.day
           }
           const maxDayInMonth = daysInMonth(new Date(Date.UTC(current.getUTCFullYear(), targetMonthIndex + 1, 0)))
-          return Math.min(boundary.day, maxDayInMonth)
+          return reverse ? maxDayInMonth : 1
         }
         if (nextMonth === undefined) {
           current.setUTCFullYear(current.getUTCFullYear() + tick)
@@ -1004,6 +1040,7 @@ export const sequence = function*(cron: Cron, now?: DateTime.DateTime.Input): It
  * @since 2.0.0
  */
 export const Equivalence: Equ.Equivalence<Cron> = Equ.make((self, that) =>
+  self.and === that.and &&
   restrictionsEquals(self.seconds, that.seconds) &&
   restrictionsEquals(self.minutes, that.minutes) &&
   restrictionsEquals(self.hours, that.hours) &&
@@ -1154,6 +1191,12 @@ interface SegmentOptions {
   min: number
   max: number
   aliases?: Record<string, number> | undefined
+  normalize?: ((value: number) => number) | undefined
+}
+
+interface ParsedSegment {
+  readonly values: Set<number>
+  readonly wildcard: boolean
 }
 
 const secondOptions: SegmentOptions = {
@@ -1197,7 +1240,8 @@ const monthOptions: SegmentOptions = {
 
 const weekdayOptions: SegmentOptions = {
   min: 0,
-  max: 6,
+  max: 7,
+  normalize: (value) => value === 7 ? 0 : value,
   aliases: {
     sun: 0,
     mon: 1,
@@ -1212,17 +1256,21 @@ const weekdayOptions: SegmentOptions = {
 const parseSegment = (
   input: string,
   options: SegmentOptions
-): Result.Result<ReadonlySet<number>, CronParseError> => {
-  const capacity = options.max - options.min + 1
+): Result.Result<ParsedSegment, CronParseError> => {
   const values = new Set<number>()
   const fields = input.split(",")
-
-  for (const field of fields) {
-    const [raw, step] = splitStep(field)
-    if (raw === "*" && step === undefined) {
-      return Result.succeed(new Set())
+  const first = splitStep(fields[0]!)
+  const wildcard = first[0] === "*"
+  const normalize = options.normalize ?? ((value: number) => value)
+  const add = wildcard && (first[1] === undefined || first[1] === 1) ?
+    constVoid :
+    (value: number) => {
+      values.add(normalize(value))
     }
 
+  for (let index = 0; index < fields.length; index++) {
+    const field = fields[index]!
+    const [raw, step] = index === 0 ? first : splitStep(field)
     if (step !== undefined) {
       if (!Number.isInteger(step)) {
         return Result.fail(new CronParseError({ message: `Expected step value to be a positive integer`, input }))
@@ -1236,8 +1284,11 @@ const parseSegment = (
     }
 
     if (raw === "*") {
+      if (index === 0 && (step === undefined || step === 1)) {
+        continue
+      }
       for (let i = options.min; i <= options.max; i += step ?? 1) {
-        values.add(i)
+        add(i)
       }
     } else {
       const [left, right] = splitRange(raw, options.aliases)
@@ -1251,7 +1302,9 @@ const parseSegment = (
       }
 
       if (right === undefined) {
-        values.add(left)
+        for (let i = left; i <= (step === undefined ? left : options.max); i += step ?? 1) {
+          add(i)
+        }
       } else {
         if (!Number.isInteger(right)) {
           return Result.fail(new CronParseError({ message: `Expected a positive integer`, input }))
@@ -1266,23 +1319,20 @@ const parseSegment = (
         }
 
         for (let i = left; i <= right; i += step ?? 1) {
-          values.add(i)
+          add(i)
         }
       }
     }
-
-    if (values.size >= capacity) {
-      return Result.succeed(new Set())
-    }
   }
 
-  return Result.succeed(values)
+  return Result.succeed({ values, wildcard })
 }
 
 const splitStep = (input: string): [string, number | undefined] => {
   const separator = input.indexOf("/")
   if (separator !== -1) {
-    return [input.slice(0, separator), Number(input.slice(separator + 1))]
+    const step = input.slice(separator + 1)
+    return [input.slice(0, separator), decimalRegex.test(step) ? Number(step) : NaN]
   }
 
   return [input, undefined]
@@ -1298,5 +1348,7 @@ const splitRange = (input: string, aliases?: Record<string, number>): [number, n
 }
 
 function aliasOrValue(field: string, aliases?: Record<string, number>): number {
-  return aliases?.[field.toLocaleLowerCase()] ?? Number(field)
+  return aliases?.[field.toLocaleLowerCase()] ?? (decimalRegex.test(field) ? Number(field) : NaN)
 }
+
+const decimalRegex = /^\d+$/

package/src/Effect.ts

@@ -11751,6 +11751,137 @@ export const provideContext: {
   <A, E, R, XR>(self: Effect<A, E, R>, context: Context.Context<XR>): Effect<A, E, Exclude<R, XR>>
 } = internal.provideContext
 
+/**
+ * Runs an effect with the provided context as its complete environment.
+ *
+ * **When to use**
+ *
+ * Use when you already have a `Context` containing every service required by
+ * the effect and want the wrapped effect to run with exactly that context.
+ *
+ * **Gotchas**
+ *
+ * `setContext` replaces the current context for the wrapped effect. Services
+ * from an outer context are not inherited unless they are also present in the
+ * context passed to `setContext`.
+ *
+ * **Example** (Running with a complete context)
+ *
+ * ```ts
+ * import { Context, Effect } from "effect"
+ *
+ * class Config extends Context.Service<Config, {
+ *   readonly greeting: string
+ * }>()("Config") {}
+ *
+ * const program = Effect.gen(function*() {
+ *   const config = yield* Effect.service(Config)
+ *   return `${config.greeting}, World!`
+ * })
+ *
+ * const context = Context.make(Config, { greeting: "Hello" })
+ *
+ * const runnable = Effect.setContext(program, context)
+ *
+ * Effect.runPromise(runnable).then(console.log)
+ * // Output: "Hello, World!"
+ * ```
+ *
+ * @see {@link provideContext} for partially satisfying an effect's context requirements.
+ * @see {@link updateContext} for deriving the required context from the current one.
+ *
+ * @category environment
+ * @since 4.0.0
+ */
+export const setContext: {
+  /**
+   * Runs an effect with the provided context as its complete environment.
+   *
+   * **When to use**
+   *
+   * Use when you already have a `Context` containing every service required by
+   * the effect and want the wrapped effect to run with exactly that context.
+   *
+   * **Gotchas**
+   *
+   * `setContext` replaces the current context for the wrapped effect. Services
+   * from an outer context are not inherited unless they are also present in the
+   * context passed to `setContext`.
+   *
+   * **Example** (Running with a complete context)
+   *
+   * ```ts
+   * import { Context, Effect } from "effect"
+   *
+   * class Config extends Context.Service<Config, {
+   *   readonly greeting: string
+   * }>()("Config") {}
+   *
+   * const program = Effect.gen(function*() {
+   *   const config = yield* Effect.service(Config)
+   *   return `${config.greeting}, World!`
+   * })
+   *
+   * const context = Context.make(Config, { greeting: "Hello" })
+   *
+   * const runnable = Effect.setContext(program, context)
+   *
+   * Effect.runPromise(runnable).then(console.log)
+   * // Output: "Hello, World!"
+   * ```
+   *
+   * @see {@link provideContext} for partially satisfying an effect's context requirements.
+   * @see {@link updateContext} for deriving the required context from the current one.
+   *
+   * @category environment
+   * @since 4.0.0
+   */
+  <R>(context: Context.Context<R>): <A, E>(self: Effect<A, E, R>) => Effect<A, E>
+  /**
+   * Runs an effect with the provided context as its complete environment.
+   *
+   * **When to use**
+   *
+   * Use when you already have a `Context` containing every service required by
+   * the effect and want the wrapped effect to run with exactly that context.
+   *
+   * **Gotchas**
+   *
+   * `setContext` replaces the current context for the wrapped effect. Services
+   * from an outer context are not inherited unless they are also present in the
+   * context passed to `setContext`.
+   *
+   * **Example** (Running with a complete context)
+   *
+   * ```ts
+   * import { Context, Effect } from "effect"
+   *
+   * class Config extends Context.Service<Config, {
+   *   readonly greeting: string
+   * }>()("Config") {}
+   *
+   * const program = Effect.gen(function*() {
+   *   const config = yield* Effect.service(Config)
+   *   return `${config.greeting}, World!`
+   * })
+   *
+   * const context = Context.make(Config, { greeting: "Hello" })
+   *
+   * const runnable = Effect.setContext(program, context)
+   *
+   * Effect.runPromise(runnable).then(console.log)
+   * // Output: "Hello, World!"
+   * ```
+   *
+   * @see {@link provideContext} for partially satisfying an effect's context requirements.
+   * @see {@link updateContext} for deriving the required context from the current one.
+   *
+   * @category environment
+   * @since 4.0.0
+   */
+  <A, E, R>(self: Effect<A, E, R>, context: Context.Context<R>): Effect<A, E>
+} = internal.setContext
+
 /**
  * Accesses a service from the context.
  *

package/src/FileSystem.ts

@@ -118,6 +118,16 @@ export interface FileSystem {
     uid: number,
     gid: number
   ) => Effect.Effect<void, PlatformError>
+  /**
+   * Glob a directory.
+   */
+  readonly glob: (
+    pattern: string,
+    options?: {
+      readonly root?: string | undefined
+      readonly exclude?: ReadonlyArray<string> | undefined
+    }
+  ) => Effect.Effect<Array<string>, PlatformError>
   /**
    * Checks whether a path exists.
    */
@@ -917,6 +927,9 @@ export const makeNoop = (fileSystem: Partial<FileSystem>): FileSystem =>
     copyFile(path) {
       return Effect.fail(notFound("copyFile", path))
     },
+    glob(pattern) {
+      return Effect.fail(notFound("glob", pattern))
+    },
     exists() {
       return Effect.succeed(false)
     },

package/src/Layer.ts

@@ -565,10 +565,10 @@ export const forkMemoMap = (parent: MemoMap): Effect<MemoMap> => internalEffect.
  * @since 3.13.0
  */
 export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("effect/Layer/CurrentMemoMap") {
-  static getOrCreate: <Services>(self: Context.Context<Services>) => MemoMap = Context.getOrElse(
-    this,
-    makeMemoMapUnsafe
-  )
+  static forkOrCreate<Services>(self: Context.Context<Services>): MemoMap {
+    const current = Context.getOrUndefined(self, CurrentMemoMap)
+    return current ? forkMemoMapUnsafe(current) : makeMemoMapUnsafe()
+  }
 }
 
 /**
@@ -766,7 +766,7 @@ export const build = <RIn, E, ROut>(
   core.withFiber((fiber) =>
     buildWithMemoMap(
       self,
-      CurrentMemoMap.getOrCreate(fiber.context),
+      CurrentMemoMap.forkOrCreate(fiber.context),
       Context.getUnsafe(fiber.context, Scope.Scope)
     )
   )
@@ -922,7 +922,7 @@ export const buildWithScope: {
   core.withFiber((fiber) =>
     buildWithMemoMap(
       self,
-      CurrentMemoMap.getOrCreate(fiber.context),
+      CurrentMemoMap.forkOrCreate(fiber.context),
       scope
     )
   ))

package/src/LayerMap.ts

@@ -153,7 +153,7 @@ export const make: <
   } | undefined
 ) {
   const context = yield* Effect.context<never>()
-  const memoMap = Layer.CurrentMemoMap.getOrCreate(context)
+  const memoMap = Layer.CurrentMemoMap.forkOrCreate(context)
 
   const rcMap = yield* RcMap.make({
     lookup: (key: K) =>