effect 2.0.1 → 2.0.3

package/src/ReadonlyArray.ts

@@ -8,15 +8,15 @@ import type { Either } from "./Either.js"
 import * as E from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
-import { dual, identity } from "./Function.js"
 import type { LazyArg } from "./Function.js"
+import { dual, identity } from "./Function.js"
 import type { TypeLambda } from "./HKT.js"
 import * as readonlyArray from "./internal/readonlyArray.js"
 import type { Option } from "./Option.js"
 import * as O from "./Option.js"
 import * as Order from "./Order.js"
-import { isBoolean, not } from "./Predicate.js"
 import type { Predicate, Refinement } from "./Predicate.js"
+import { isBoolean } from "./Predicate.js"
 import * as RR from "./ReadonlyRecord.js"
 import * as Tuple from "./Tuple.js"
 
@@ -559,25 +559,27 @@ export const takeRight: {
  * @since 2.0.0
  */
 export const takeWhile: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Array<B>
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Array<B>
-  <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): Array<B>
-  <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A>
-} = dual(2, <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A> => {
+  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: Iterable<A>) => Array<B>
+  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>
+  <A, B extends A>(self: Iterable<A>, refinement: (a: A, i: number) => a is B): Array<B>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> => {
+  let i = 0
   const out: Array<A> = []
   for (const a of self) {
-    if (!predicate(a)) {
+    if (!predicate(a, i)) {
       break
     }
     out.push(a)
+    i++
   }
   return out
 })
 
-const spanIndex = <A>(self: Iterable<A>, predicate: Predicate<A>): number => {
+const spanIndex = <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): number => {
   let i = 0
   for (const a of self) {
-    if (!predicate(a)) {
+    if (!predicate(a, i)) {
       break
     }
     i++
@@ -596,14 +598,17 @@ const spanIndex = <A>(self: Iterable<A>, predicate: Predicate<A>): number => {
  */
 export const span: {
   <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>
+    refinement: (a: A, i: number) => a is B
   ): (self: Iterable<C>) => [init: Array<B>, rest: Array<Exclude<C, B>>]
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => [init: Array<B>, rest: Array<B>]
-  <A, B extends A>(self: Iterable<A>, refinement: Refinement<A, B>): [init: Array<B>, rest: Array<Exclude<A, B>>]
-  <A>(self: Iterable<A>, predicate: Predicate<A>): [init: Array<A>, rest: Array<A>]
+  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => [init: Array<B>, rest: Array<B>]
+  <A, B extends A>(
+    self: Iterable<A>,
+    refinement: (a: A, i: number) => a is B
+  ): [init: Array<B>, rest: Array<Exclude<A, B>>]
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [init: Array<A>, rest: Array<A>]
 } = dual(
   2,
-  <A>(self: Iterable<A>, predicate: Predicate<A>): [init: Array<A>, rest: Array<A>] =>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [init: Array<A>, rest: Array<A>] =>
     splitAt(self, spanIndex(self, predicate))
 )
 
@@ -646,11 +651,12 @@ export const dropRight: {
  * @since 2.0.0
  */
 export const dropWhile: {
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => Array<B>
-  <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A>
+  <B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Iterable<B>) => Array<B>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A>
 } = dual(
   2,
-  <A>(self: Iterable<A>, predicate: Predicate<A>): Array<A> => fromIterable(self).slice(spanIndex(self, predicate))
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Array<A> =>
+    fromIterable(self).slice(spanIndex(self, predicate))
 )
 
 /**
@@ -660,12 +666,12 @@ export const dropWhile: {
  * @since 2.0.0
  */
 export const findFirstIndex: {
-  <A>(predicate: Predicate<A>): (self: Iterable<A>) => Option<number>
-  <A>(self: Iterable<A>, predicate: Predicate<A>): Option<number>
-} = dual(2, <A>(self: Iterable<A>, predicate: Predicate<A>): Option<number> => {
+  <A>(predicate: (a: A, i: number) => boolean): (self: Iterable<A>) => Option<number>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number> => {
   let i = 0
   for (const a of self) {
-    if (predicate(a)) {
+    if (predicate(a, i)) {
       return O.some(i)
     }
     i++
@@ -680,12 +686,12 @@ export const findFirstIndex: {
  * @since 2.0.0
  */
 export const findLastIndex: {
-  <A>(predicate: Predicate<A>): (self: Iterable<A>) => Option<number>
-  <A>(self: Iterable<A>, predicate: Predicate<A>): Option<number>
-} = dual(2, <A>(self: Iterable<A>, predicate: Predicate<A>): Option<number> => {
+  <A>(predicate: (a: A, i: number) => boolean): (self: Iterable<A>) => Option<number>
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number>
+} = dual(2, <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): Option<number> => {
   const input = fromIterable(self)
   for (let i = input.length - 1; i >= 0; i--) {
-    if (predicate(input[i])) {
+    if (predicate(input[i], i)) {
       return O.some(i)
     }
   }
@@ -1230,12 +1236,14 @@ export const split: {
  * @since 2.0.0
  */
 export const splitWhere: {
-  <B extends A, A = B>(predicate: Predicate<A>): (self: Iterable<B>) => [beforeMatch: Array<B>, fromMatch: Array<B>]
-  <A>(self: Iterable<A>, predicate: Predicate<A>): [beforeMatch: Array<A>, fromMatch: Array<A>]
+  <B extends A, A = B>(
+    predicate: (a: A, i: number) => boolean
+  ): (self: Iterable<B>) => [beforeMatch: Array<B>, fromMatch: Array<B>]
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [beforeMatch: Array<A>, fromMatch: Array<A>]
 } = dual(
   2,
-  <A>(self: Iterable<A>, predicate: Predicate<A>): [beforeMatch: Array<A>, fromMatch: Array<A>] =>
-    span(self, not(predicate))
+  <A>(self: Iterable<A>, predicate: (a: A, i: number) => boolean): [beforeMatch: Array<A>, fromMatch: Array<A>] =>
+    span(self, (a: A, i: number) => !predicate(a, i))
 )
 
 /**
@@ -1578,17 +1586,19 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filterMapWhile: {
-  <A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Array<B>
-  <A, B>(self: Iterable<A>, f: (a: A) => Option<B>): Array<B>
-} = dual(2, <A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => {
+  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Array<B>
+  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Array<B>
+} = dual(2, <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => {
+  let i = 0
   const out: Array<B> = []
   for (const a of self) {
-    const b = f(a)
+    const b = f(a, i)
     if (O.isSome(b)) {
       out.push(b.value)
     } else {
       break
     }
+    i++
   }
   return out
 })
@@ -1844,13 +1854,13 @@ export const liftEither = <A extends Array<unknown>, E, B>(
  * @since 2.0.0
  */
 export const every: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>
-  <A>(predicate: Predicate<A>): (self: ReadonlyArray<A>) => boolean
-  <A, B extends A>(self: ReadonlyArray<A>, refinement: Refinement<A, B>): self is ReadonlyArray<B>
-  <A>(self: ReadonlyArray<A>, predicate: Predicate<A>): boolean
+  <A, B extends A>(refinement: (a: A, i: number) => a is B): (self: ReadonlyArray<A>) => self is ReadonlyArray<B>
+  <A>(predicate: (a: A, i: number) => boolean): (self: ReadonlyArray<A>) => boolean
+  <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B>
+  <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): boolean
 } = dual(
   2,
-  <A, B extends A>(self: ReadonlyArray<A>, refinement: Refinement<A, B>): self is ReadonlyArray<B> =>
+  <A, B extends A>(self: ReadonlyArray<A>, refinement: (a: A, i: number) => a is B): self is ReadonlyArray<B> =>
     self.every(refinement)
 )
 
@@ -1861,11 +1871,14 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <B extends A, A = B>(predicate: Predicate<A>): (self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>
-  <A>(self: ReadonlyArray<A>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<A>
+  <B extends A, A = B>(
+    predicate: (a: A, i: number) => boolean
+  ): (self: ReadonlyArray<B>) => self is NonEmptyReadonlyArray<B>
+  <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): self is NonEmptyReadonlyArray<A>
 } = dual(
   2,
-  <A>(self: ReadonlyArray<A>, predicate: Predicate<A>): self is NonEmptyReadonlyArray<A> => self.some(predicate)
+  <A>(self: ReadonlyArray<A>, predicate: (a: A, i: number) => boolean): self is NonEmptyReadonlyArray<A> =>
+    self.some(predicate)
 )
 
 /**
@@ -2026,18 +2039,26 @@ export const join: {
  * @category folding
  */
 export const mapAccum: {
-  <S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Iterable<A>) => [state: S, mappedArray: Array<B>]
-  <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => readonly [S, B]): [state: S, mappedArray: Array<B>]
-} = dual(3, <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A) => [S, B]): [state: S, mappedArray: Array<B>] => {
-  let s1 = s
-  const out: Array<B> = []
-  for (const a of self) {
-    const r = f(s1, a)
-    s1 = r[0]
-    out.push(r[1])
+  <S, A, B>(
+    s: S,
+    f: (s: S, a: A, i: number) => readonly [S, B]
+  ): (self: Iterable<A>) => [state: S, mappedArray: Array<B>]
+  <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A, i: number) => readonly [S, B]): [state: S, mappedArray: Array<B>]
+} = dual(
+  3,
+  <S, A, B>(self: Iterable<A>, s: S, f: (s: S, a: A, i: number) => [S, B]): [state: S, mappedArray: Array<B>] => {
+    let i = 0
+    let s1 = s
+    const out: Array<B> = []
+    for (const a of self) {
+      const r = f(s1, a, i)
+      s1 = r[0]
+      out.push(r[1])
+      i++
+    }
+    return [s1, out]
   }
-  return [s1, out]
-})
+)
 
 /**
  * Zips this chunk crosswise with the specified chunk using the specified combiner.

package/src/Schedule.ts

@@ -405,6 +405,18 @@ export const mapInputEffect: {
  */
 export const count: Schedule<never, unknown, number> = internal.count
 
+/**
+ * Cron schedule that recurs every `minute` that matches the schedule.
+ *
+ * It triggers at zero second of the minute. Producing the timestamps of the cron window.
+ *
+ * NOTE: `expression` parameter is validated lazily. Must be a valid cron expression.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const cron: (expression: string) => Schedule<never, unknown, [number, number]> = internal.cron
+
 /**
  * Cron-like schedule that recurs every specified `day` of month. Won't recur
  * on months containing less days than specified in `day` param.

package/src/index.ts

@@ -170,6 +170,11 @@ export * as Console from "./Console.js"
  */
 export * as Context from "./Context.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Cron from "./Cron.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/schedule.ts

@@ -2,6 +2,7 @@ import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
+import * as Cron from "../Cron.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
 import * as Either from "../Either.js"
@@ -419,6 +420,47 @@ export const mapInputEffect = dual<
       (input) => self.step(now, input, state)
     )))
 
+/** @internal */
+export const cron = (expression: string): Schedule.Schedule<never, unknown, [number, number]> => {
+  const parsed = Cron.parse(expression)
+  return makeWithState<[boolean, [number, number, number]], never, unknown, [number, number]>(
+    [true, [Number.MIN_SAFE_INTEGER, 0, 0]],
+    (now, _, [initial, previous]) => {
+      if (now < previous[0]) {
+        return core.succeed([
+          [false, previous],
+          [previous[1], previous[2]],
+          ScheduleDecision.continueWith(Interval.make(previous[1], previous[2]))
+        ])
+      }
+
+      if (Either.isLeft(parsed)) {
+        return core.die(parsed.left)
+      }
+
+      const cron = parsed.right
+      const date = new Date(now)
+
+      let next: number
+      if (initial && Cron.match(cron, date)) {
+        next = now
+      } else {
+        const result = Cron.next(cron, date)
+        next = result.getTime()
+      }
+
+      const start = beginningOfMinute(next)
+      const end = endOfMinute(next)
+      const interval = Interval.make(start, end)
+      return core.succeed([
+        [false, [next, start, end]],
+        [start, end],
+        ScheduleDecision.continueWith(interval)
+      ])
+    }
+  )
+}
+
 /** @internal */
 export const dayOfMonth = (day: number): Schedule.Schedule<never, unknown, number> => {
   return makeWithState<[number, number], never, unknown, number>(

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.0.1"
+export const moduleVersion = "2.0.3"