effect 2.0.2 → 2.0.4

package/src/Types.ts

@@ -174,3 +174,8 @@ export type Covariant<A> = (_: never) => A
  * @category models
  */
 export type Contravariant<A> = (_: A) => void
+
+/**
+ * @since 2.0.0
+ */
+export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse

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
  */
@@ -255,6 +260,11 @@ export * as Fiber from "./Fiber.js"
  */
 export * as FiberId from "./FiberId.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as FiberMap from "./FiberMap.js"
+
 /**
  * @since 2.0.0
  */
@@ -270,6 +280,11 @@ export * as FiberRefs from "./FiberRefs.js"
  */
 export * as FiberRefsPatch from "./FiberRefsPatch.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as FiberSet from "./FiberSet.js"
+
 /**
  * @since 2.0.0
  */
@@ -832,6 +847,25 @@ export * as TestSized from "./TestSized.js"
  */
 export * as Tracer from "./Tracer.js"
 
+/**
+ * A `Trie` is used for locating specific `string` keys from within a set.
+ *
+ * It works similar to `HashMap`, but with keys required to be `string`.
+ * This constraint unlocks some performance optimizations and new methods to get string prefixes (e.g. `keysWithPrefix`, `longestPrefixOf`).
+ *
+ * Prefix search is also the main feature that makes a `Trie` more suited than `HashMap` for certain usecases.
+ *
+ * A `Trie` is often used to store a dictionary (list of words) that can be searched
+ * in a manner that allows for efficient generation of completion lists
+ * (e.g. predict the rest of a word a user is typing).
+ *
+ * A `Trie` has O(n) lookup time where `n` is the size of the key,
+ * or even less than `n` on search misses.
+ *
+ * @since 2.0.0
+ */
+export * as Trie from "./Trie.js"
+
 /**
  * This module provides utility functions for working with tuples in TypeScript.
  *

package/src/internal/hashMap/node.ts

@@ -2,7 +2,7 @@ import { equals } from "../../Equal.js"
 import type { HashMap } from "../../HashMap.js"
 import * as O from "../../Option.js"
 import { isTagged } from "../../Predicate.js"
-import { Stack } from "../stack.js"
+import * as Stack from "../stack.js"
 import { arraySpliceIn, arraySpliceOut, arrayUpdate } from "./array.js"
 import { fromBitmap, hashFragment, toBitmap } from "./bitwise.js"
 import { MAX_INDEX_NODE, MIN_ARRAY_NODE, SIZE } from "./config.js"
@@ -370,14 +370,14 @@ function mergeLeaves<K, V>(
   h2: number,
   n2: Node<K, V>
 ): Node<K, V> {
-  let stack: Stack<(node: Node<K, V>) => Node<K, V>> | undefined = undefined
+  let stack: Stack.Stack<(node: Node<K, V>) => Node<K, V>> | undefined = undefined
   let currentShift = shift
   // eslint-disable-next-line no-constant-condition
   while (true) {
     const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2)
 
     if (typeof res === "function") {
-      stack = new Stack(res, stack)
+      stack = Stack.make(res, stack)
       currentShift = currentShift + SIZE
     } else {
       let final = res

package/src/internal/pubsub.ts

@@ -645,28 +645,25 @@ class BoundedPubSubSingleSubscription<in out A> implements Subscription<A> {
 }
 
 /** @internal */
-class Node<out A> {
-  constructor(
-    public value: A | AbsentValue,
-    public subscribers: number,
-    public next: Node<A> | null
-  ) {
-  }
+interface Node<out A> {
+  value: A | AbsentValue
+  subscribers: number
+  next: Node<A> | null
 }
 
 /** @internal */
 class UnboundedPubSub<in out A> implements AtomicPubSub<A> {
-  publisherHead = new Node<A>(AbsentValue, 0, null)
+  publisherHead: Node<A> = {
+    value: AbsentValue,
+    subscribers: 0,
+    next: null
+  }
+  publisherTail = this.publisherHead
   publisherIndex = 0
-  publisherTail: Node<A>
   subscribersIndex = 0
 
   readonly capacity = Number.MAX_SAFE_INTEGER
 
-  constructor() {
-    this.publisherTail = this.publisherHead
-  }
-
   isEmpty(): boolean {
     return this.publisherHead === this.publisherTail
   }
@@ -682,7 +679,11 @@ class UnboundedPubSub<in out A> implements AtomicPubSub<A> {
   publish(value: A): boolean {
     const subscribers = this.publisherTail.subscribers
     if (subscribers !== 0) {
-      this.publisherTail.next = new Node(value, subscribers, null)
+      this.publisherTail.next = {
+        value,
+        subscribers,
+        next: null
+      }
       this.publisherTail = this.publisherTail.next
       this.publisherIndex += 1
     }

package/src/internal/redBlackTree/node.ts

@@ -10,22 +10,31 @@ export declare namespace Node {
   }
 }
 
-/** @internal */
-export class Node<out K, out V> {
-  constructor(
-    public color: Node.Color,
-    public key: K,
-    public value: V,
-    public left: Node<K, V> | undefined,
-    public right: Node<K, V> | undefined,
-    public count: number
-  ) {}
+export interface Node<out K, out V> {
+  color: Node.Color
+  key: K
+  value: V
+  left: Node<K, V> | undefined
+  right: Node<K, V> | undefined
+  count: number
 }
 
 /** @internal */
-export function clone<K, V>(node: Node<K, V>) {
-  return new Node(node.color, node.key, node.value, node.left, node.right, node.count)
-}
+export const clone = <K, V>({
+  color,
+  count,
+  key,
+  left,
+  right,
+  value
+}: Node<K, V>) => ({
+  color,
+  key,
+  value,
+  left,
+  right,
+  count
+})
 
 /** @internal */
 export function swap<K, V>(n: Node<K, V>, v: Node<K, V>) {
@@ -38,11 +47,22 @@ export function swap<K, V>(n: Node<K, V>, v: Node<K, V>) {
 }
 
 /** @internal */
-export function repaint<K, V>(node: Node<K, V>, color: Node.Color) {
-  return new Node(color, node.key, node.value, node.left, node.right, node.count)
-}
+export const repaint = <K, V>({
+  count,
+  key,
+  left,
+  right,
+  value
+}: Node<K, V>, color: Node.Color) => ({
+  color,
+  key,
+  value,
+  left,
+  right,
+  count
+})
 
 /** @internal */
-export function recount<K, V>(node: Node<K, V>) {
+export const recount = <K, V>(node: Node<K, V>) => {
   node.count = 1 + (node.left?.count ?? 0) + (node.right?.count ?? 0)
 }

package/src/internal/redBlackTree.ts

@@ -11,7 +11,7 @@ import { hasProperty } from "../Predicate.js"
 import type * as RBT from "../RedBlackTree.js"
 import { Direction, RedBlackTreeIterator } from "./redBlackTree/iterator.js"
 import * as Node from "./redBlackTree/node.js"
-import { Stack } from "./stack.js"
+import * as Stack from "./stack.js"
 
 const RedBlackTreeSymbolKey = "effect/RedBlackTree"
 
@@ -288,27 +288,34 @@ export const insert = dual<
     }
   }
   // Rebuild path to leaf node
-  n_stack.push(new Node.Node(Node.Color.Red, key, value, undefined, undefined, 1))
+  n_stack.push({
+    color: Node.Color.Red,
+    key,
+    value,
+    left: undefined,
+    right: undefined,
+    count: 1
+  })
   for (let s = n_stack.length - 2; s >= 0; --s) {
     const n2 = n_stack[s]!
     if (d_stack[s]! <= 0) {
-      n_stack[s] = new Node.Node(
-        n2.color,
-        n2.key,
-        n2.value,
-        n_stack[s + 1],
-        n2.right,
-        n2.count + 1
-      )
+      n_stack[s] = {
+        color: n2.color,
+        key: n2.key,
+        value: n2.value,
+        left: n_stack[s + 1],
+        right: n2.right,
+        count: n2.count + 1
+      }
     } else {
-      n_stack[s] = new Node.Node(
-        n2.color,
-        n2.key,
-        n2.value,
-        n2.left,
-        n_stack[s + 1],
-        n2.count + 1
-      )
+      n_stack[s] = {
+        color: n2.color,
+        key: n2.key,
+        value: n2.value,
+        left: n2.left,
+        right: n_stack[s + 1],
+        count: n2.count + 1
+      }
     }
   }
   // Rebalance tree using rotations
@@ -778,20 +785,34 @@ export const removeFirst = dual<
   }
   const cstack = new Array<Node.Node<K, V>>(stack.length)
   let n = stack[stack.length - 1]!
-  cstack[cstack.length - 1] = new Node.Node(
-    n.color,
-    n.key,
-    n.value,
-    n.left,
-    n.right,
-    n.count
-  )
+  cstack[cstack.length - 1] = {
+    color: n.color,
+    key: n.key,
+    value: n.value,
+    left: n.left,
+    right: n.right,
+    count: n.count
+  }
   for (let i = stack.length - 2; i >= 0; --i) {
     n = stack[i]!
     if (n.left === stack[i + 1]) {
-      cstack[i] = new Node.Node(n.color, n.key, n.value, cstack[i + 1], n.right, n.count)
+      cstack[i] = {
+        color: n.color,
+        key: n.key,
+        value: n.value,
+        left: cstack[i + 1],
+        right: n.right,
+        count: n.count
+      }
     } else {
-      cstack[i] = new Node.Node(n.color, n.key, n.value, n.left, cstack[i + 1], n.count)
+      cstack[i] = {
+        color: n.color,
+        key: n.key,
+        value: n.value,
+        left: n.left,
+        right: cstack[i + 1],
+        count: n.count
+      }
     }
   }
   // Get node
@@ -807,13 +828,27 @@ export const removeFirst = dual<
     }
     // Copy path to leaf
     const v = cstack[split - 1]
-    cstack.push(new Node.Node(n.color, v!.key, v!.value, n.left, n.right, n.count))
+    cstack.push({
+      color: n.color,
+      key: v!.key,
+      value: v!.value,
+      left: n.left,
+      right: n.right,
+      count: n.count
+    })
     cstack[split - 1]!.key = n.key
     cstack[split - 1]!.value = n.value
     // Fix up stack
     for (let i = cstack.length - 2; i >= split; --i) {
       n = cstack[i]!
-      cstack[i] = new Node.Node(n.color, n.key, n.value, n.left, cstack[i + 1], n.count)
+      cstack[i] = {
+        color: n.color,
+        key: n.key,
+        value: n.value,
+        left: n.left,
+        right: cstack[i + 1],
+        count: n.count
+      }
     }
     cstack[split - 1]!.left = cstack[split]
   }
@@ -913,11 +948,11 @@ const visitFull = <K, V, A>(
   visit: (key: K, value: V) => Option.Option<A>
 ): Option.Option<A> => {
   let current: Node.Node<K, V> | undefined = node
-  let stack: Stack<Node.Node<K, V>> | undefined = undefined
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
   let done = false
   while (!done) {
     if (current != null) {
-      stack = new Stack(current, stack)
+      stack = Stack.make(current, stack)
       current = current.left
     } else if (stack != null) {
       const value = visit(stack.value.key, stack.value.value)
@@ -940,11 +975,11 @@ const visitGreaterThanEqual = <K, V, A>(
   visit: (key: K, value: V) => Option.Option<A>
 ): Option.Option<A> => {
   let current: Node.Node<K, V> | undefined = node
-  let stack: Stack<Node.Node<K, V>> | undefined = undefined
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
   let done = false
   while (!done) {
     if (current !== undefined) {
-      stack = new Stack(current, stack)
+      stack = Stack.make(current, stack)
       if (ord(min, current.key) <= 0) {
         current = current.left
       } else {
@@ -973,11 +1008,11 @@ const visitLessThan = <K, V, A>(
   visit: (key: K, value: V) => Option.Option<A>
 ): Option.Option<A> => {
   let current: Node.Node<K, V> | undefined = node
-  let stack: Stack<Node.Node<K, V>> | undefined = undefined
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
   let done = false
   while (!done) {
     if (current !== undefined) {
-      stack = new Stack(current, stack)
+      stack = Stack.make(current, stack)
       current = current.left
     } else if (stack !== undefined && ord(max, stack.value.key) > 0) {
       const value = visit(stack.value.key, stack.value.value)
@@ -1001,11 +1036,11 @@ const visitBetween = <K, V, A>(
   visit: (key: K, value: V) => Option.Option<A>
 ): Option.Option<A> => {
   let current: Node.Node<K, V> | undefined = node
-  let stack: Stack<Node.Node<K, V>> | undefined = undefined
+  let stack: Stack.Stack<Node.Node<K, V>> | undefined = undefined
   let done = false
   while (!done) {
     if (current !== undefined) {
-      stack = new Stack(current, stack)
+      stack = Stack.make(current, stack)
       if (ord(min, current.key) <= 0) {
         current = current.left
       } else {

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 | Cron.Cron): Schedule.Schedule<never, unknown, [number, number]> => {
+  const parsed = Cron.isCron(expression) ? Either.right(expression) : 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/stack.ts

@@ -1,4 +1,10 @@
 /** @internal */
-export class Stack<out A> {
-  constructor(readonly value: A, readonly previous?: Stack<A>) {}
+export interface Stack<out A> {
+  readonly value: A
+  readonly previous: Stack<A> | undefined
 }
+
+export const make = <A>(value: A, previous?: Stack<A>): Stack<A> => ({
+  value,
+  previous
+})