Effect

https://effect.kitlangton.com
Admin
Effect is a TypeScript library for building type-safe, composable asynchronous programs with...
Tokens:2,118
Snippets:24
Trust Score:5.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Ref.make: Create a concurrency-safe mutable reference

Source: https://effect.kitlangton.com/index

This section shows how to create a concurrency-safe mutable reference using `Ref.make`. The example demonstrates initializing a `Ref` with a value of 0 and then updating it multiple times concurrently using `Ref.updateAndGet` within an `Effect.repeat` loop.

```typescript
const increment = (counter: Ref<number>) => 
  Ref.updateAndGet(counter, n => n + 1)


const repeat = Effect.gen(function* () {
  const counter = yield* Ref.make(0)
  yield* Effect.repeat(increment(counter), Schedule.recurs(4))
})
```

--------------------------------

### Effect.addFinalizer: Register cleanup actions in a scope

Source: https://effect.kitlangton.com/index

This code example demonstrates `Effect.addFinalizer`, which registers cleanup actions to be executed when an effect's scope is exited. The finalizer ensures that specified cleanup logic, like closing resources or logging, is performed regardless of whether the effect succeeds, fails, or is interrupted.

```typescript
const effect = Effect.gen(function* () {
  // Register finalizer first
  yield* Effect.addFinalizer(() => console.log("cleanup"))
  // Succeed
  return "Done"
}).pipe(Effect.scoped)
```

--------------------------------

### Ref.updateAndGet: Update a ref and return the new value

Source: https://effect.kitlangton.com/index

This snippet illustrates the `Ref.updateAndGet` function, which atomically updates a mutable reference and returns its new value. The example shows concurrent updates to a shared `Ref` using `Effect.all`, with a random sleep to simulate varying processing times.

```typescript
const increment = (counter: Ref<number>) => Effect.gen(function* () {
  yield* Effect.sleep(Duration.millis(Math.random() * 1000 + 500))
  return yield* Ref.updateAndGet(counter, n => n + 1)
})


const concurrent = Effect.gen(function* () {
  const counter = yield* Ref.make(0)
  return yield* Effect.all(
    Array.from({ length: 5 }, () => increment(counter)),
    { concurrency: "unbounded" }
  )
})
```

--------------------------------

### Effect.promise Constructor in TypeScript

Source: https://effect.kitlangton.com/index

Creates an Effect from an asynchronous computation (Promise) that is guaranteed to succeed. It handles the resolution of the Promise into a successful Effect.

```typescript
function readTemperature(location) {
  return Effect.promise(() =>
    fetch(`slow.weather.com/api/${location}`)
     .then(r => r.json())
  )
}


const london = readTemperature("London")
```

--------------------------------

### Effect.sync Constructor in TypeScript

Source: https://effect.kitlangton.com/index

Creates an Effect from a synchronous side-effectful computation. This allows integrating synchronous operations that have side effects into the Effect ecosystem.

```typescript
const random = Effect.sync(() => Math.random())
```

--------------------------------

### Effect.die Constructor in TypeScript

Source: https://effect.kitlangton.com/index

Creates an Effect that terminates with an unrecoverable defect. This is typically used for unexpected errors that cannot be handled gracefully.

```typescript
const death = Effect.die(new Error("FATAL: System corrupted"))
```

--------------------------------

### Effect.succeed Constructor in TypeScript

Source: https://effect.kitlangton.com/index

Creates an Effect that immediately succeeds with a given value. This is useful for representing a known successful outcome without performing any computation.

```typescript
const value = Effect.succeed(42)
```

--------------------------------

### Effect.acquireRelease: Acquire resources with guaranteed cleanup

Source: https://effect.kitlangton.com/index

This snippet showcases `Effect.acquireRelease` for managing resources that require guaranteed cleanup. It defines how to acquire resources like a database connection, cache, or logger and ensures their associated cleanup actions (closing connections, flushing caches) are executed using `Effect.scoped`.

```typescript
const makeDatabase = Effect.acquireRelease(
  connectDatabase(),
  (db) => Effect.sync(() => db.close())
);


const makeCache = Effect.acquireRelease(
  connectCache(),
  (cache) => Effect.sync(() => cache.flush())
);


const makeLogger = Effect.acquireRelease(
  openLogFile(),
  (file) => Effect.sync(() => file.close())
);


const result = Effect.gen(function* () {
  const db = yield* makeDatabase
  const cache = yield* makeCache
  const logger = yield* makeLogger
  return yield* doWork(db, cache, logger)
})
.pipe(Effect.scoped)
```

--------------------------------

### Effect.repeatwhileOutput Schedule in TypeScript

Source: https://effect.kitlangton.com/index

Repeats an Effect as long as its output matches a specified condition. This allows for dynamic repetition based on the results of the Effect itself, combined with timing constraints.

```typescript
const hotdog = eatHotdog()
const contest = Effect.repeat(hotdog,
    Schedule.intersect(
      Schedule.spaced("400 millis"),
      Schedule.whileOutput(
        Schedule.elapsed,
        (elapsed) => Duration.lessThan(elapsed, Duration.seconds(10))
      )
    )
  )
)
```

--------------------------------

### Effect.repeat Schedule in TypeScript

Source: https://effect.kitlangton.com/index

Repeats an Effect with a fixed delay between each execution using a `Schedule`. This is useful for implementing polling or retry mechanisms with a constant interval.

```typescript
const phone = checkNotifications();
const checking = Effect.repeat(phone, Schedule.spaced("2 seconds"));
```

--------------------------------

### Effect.raceAll Concurrency in TypeScript

Source: https://effect.kitlangton.com/index

Races multiple Effects concurrently and returns the result of the first one to succeed. Similar to `race`, but accepts an array of Effects.

```typescript
const cat = runFast("cat")
const dog = runFast("dog")  
const mouse = runFast("mouse")
const rabbit = runFast("rabbit")


const winner = Effect.raceAll([cat, dog, mouse, rabbit])
```

--------------------------------

### Effect.sleep Constructor in TypeScript

Source: https://effect.kitlangton.com/index

Creates an Effect that suspends execution for a specified duration. This is useful for introducing delays or pacing in asynchronous workflows.

```typescript
const sleepEffect = Effect.gen(function* () {
  yield* Effect.sleep("3 seconds");
  return "Refreshed!";
});
```

--------------------------------

### Effect.fail Constructor in TypeScript

Source: https://effect.kitlangton.com/index

Creates an Effect that represents a recoverable error. This allows for explicit error handling using mechanisms like `orElse`.

```typescript
const error = Effect.fail("Kaboom!")
```

--------------------------------

### Effect.retryexponential: Retry with exponential backoff

Source: https://effect.kitlangton.com/index

This snippet demonstrates how to retry an effect with exponential backoff. It utilizes `Effect.retry` and `Schedule.exponential` to define the retry strategy. The `park` effect is retried with an initial delay of 700 milliseconds, increasing exponentially with each subsequent attempt.

```typescript
const park = attemptParallelPark();
const result = Effect.retry(park, Schedule.exponential("700 millis"));
```

--------------------------------

### Effect.forEach Concurrency in TypeScript

Source: https://effect.kitlangton.com/index

Executes an Effectful operation for each element in an iterable collection. It runs these operations concurrently by default, collecting their results.

```typescript
const locations = ["New York", "London", "Tokyo"];


const result = Effect.forEach(locations, getWeather);
```

--------------------------------

### Effect.partition Error Handling in TypeScript

Source: https://effect.kitlangton.com/index

Executes a collection of Effects and partitions their results into two groups: successes and failures. It returns an Effect that yields a tuple containing an array of failed results and an array of successful results.

```typescript
const result = Effect.partition(
  [iceCream, battery, popsicle, toad, lollipop],
  performLick
).pipe(
  Effect.map(([fails, successes]) =>
	 `👹 ${fails.length} 😇 ${successes.length}`
	)
);
```

--------------------------------

### Effect.orElse Error Handling in TypeScript

Source: https://effect.kitlangton.com/index

Provides a fallback mechanism for Effects. It attempts to run the first Effect, and if it fails, it executes the provided fallback Effect. This allows for recovery from specific errors.

```typescript
const shoot = shootFirst();
const question = askQuestions();
const result = Effect.orElse(shoot, () => question);
```

--------------------------------

### Effect.all Short-Circuiting Error Handling in TypeScript

Source: https://effect.kitlangton.com/index

Combines multiple Effects and runs them concurrently. If any of the Effects fails, the combined Effect immediately fails with that error, short-circuiting the execution of the others.

```typescript
const balance = readAccountBalance();
const credit = checkCreditScore();
const payment = chargeCreditCard();


const result = Effect.all([balance, credit, payment]);
```

--------------------------------

### Effect.validate Error Handling in TypeScript

Source: https://effect.kitlangton.com/index

Accumulates validation errors from multiple Effects instead of short-circuiting on the first error. This allows for collecting all validation failures at once.

```typescript
const length = checkLength(password);
const complexity = checkComplexity(password);
const vibes = checkVibes(password);


const result = length.pipe(
  Effect.validate(complexity),
  Effect.validate(vibes)
);
```

--------------------------------

### Effect.all Concurrency in TypeScript

Source: https://effect.kitlangton.com/index

Combines multiple Effects into a single Effect that runs them concurrently. It returns an array of results once all input Effects have completed successfully. If any Effect fails, the combined Effect fails immediately.

```typescript
const nyc = readTemperature("New York")
const berlin = readTemperature("Berlin")
const tokyo = readTemperature("Tokyo")
const london = readTemperature("London")


const result = Effect.all([nyc, berlin, tokyo, london])
```

--------------------------------

### Effect.race Concurrency in TypeScript

Source: https://effect.kitlangton.com/index

Races two Effects against each other and returns the result of the first one to complete successfully. If one Effect fails, the other continues to run until it also completes or fails.

```typescript
const tortoise = runFast("tortoise")
const achilles = runFast("achilles")  


const winner = Effect.race(tortoise, achilles)
```

--------------------------------

### Effect.eventually Error Handling in TypeScript

Source: https://effect.kitlangton.com/index

Repeats an Effect until it succeeds, ignoring any errors encountered during its execution. This is useful for operations that might be temporarily unstable but are expected to eventually succeed.

```typescript
const swipeCard = swipeCard();
const result = Effect.eventually(swipeCard);
```

--------------------------------

### Effect.timeout Error Handling in TypeScript

Source: https://effect.kitlangton.com/index

Adds a time limit to an Effect. If the Effect does not complete within the specified duration, it fails with a timeout error. This prevents operations from hanging indefinitely.

```typescript
const pizza = orderDelivery();
const result = Effect.timeout(pizza, "1 second");
```

--------------------------------

### Effect.retry Schedule in TypeScript

Source: https://effect.kitlangton.com/index

Retries an Effect a fixed number of times according to a defined schedule. This is useful for implementing robust retry logic with controlled delays and a maximum number of attempts.

```typescript
const wakeUp = attemptToWakeUp();
const snoozeSchedule = Schedule.intersect(
  Schedule.spaced("2 seconds"),
  Schedule.recurs(4)
);
const result = Effect.retry(wakeUp, snoozeSchedule);
```
Tokens:
Raw