add Cause.Annotated

.changeset/calm-houses-brake.md

@@ -0,0 +1,20 @@
+---
+"effect": minor
+---
+
+add `Logger.withLeveledConsole`
+
+In browsers and different platforms, `console.error` renders differently than `console.info`. This helps to distinguish between different levels of logging. `Logger.withLeveledConsole` takes any logger and calls the respective `Console` method based on the log level. For instance, `Effect.logError` will call `Console.error` and `Effect.logInfo` will call `Console.info`.
+
+To use it, you can replace the default logger with a `Logger.withLeveledConsole` logger:
+
+```ts
+import { Logger, Effect } from "effect"
+
+const loggerLayer = Logger.withLeveledConsole(Logger.stringLogger)
+
+Effect.gen(function* () {
+ yield* Effect.logError("an error")
+ yield* Effect.logInfo("an info")
+}).pipe(Effect.provide(loggerLayer))
+```

.changeset/eighty-lobsters-refuse.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+Made `Ref`, `SynchronizedRed` and `SubscriptionRef` a subtype of `Effect`

.changeset/few-mayflies-speak.md

@@ -0,0 +1,21 @@
+---
+"effect": minor
+---
+
+add Semaphore.withPermitsIfAvailable
+
+You can now use `Semaphore.withPermitsIfAvailable` to run an Effect only if the
+Semaphore has enough permits available. This is useful when you want to run an
+Effect only if you can acquire a permit without blocking.
+
+It will return an `Option.Some` with the result of the Effect if the permits were
+available, or `None` if they were not.
+
+```ts
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+ const semaphore = yield* Effect.makeSemaphore(1)
+ semaphore.withPermitsIfAvailable(1)(Effect.void)
+})
+```

.changeset/gorgeous-toes-help.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `Deferred<A>` is now a subtype of `Effect<A>`. This change simplifies handling of deferred values, removing the need for explicit call `Deffer.await`.
+
+```typescript
+import { Effect, Deferred } from "effect"
+
+Effect.gen(function* () {
+ const deferred = yield* Deferred.make<string>()
+
+ const before = yield* Deferred.await(deferred)
+ const after = yield* deferred
+})
+```

.changeset/honest-cups-wash.md

@@ -0,0 +1,6 @@
+---
+"effect": minor
+"@effect/platform": patch
+---
+
+add Logger.prettyLoggerDefault, to prevent duplicate pretty loggers

.changeset/lucky-eagles-speak.md

@@ -0,0 +1,24 @@
+---
+"effect": minor
+---
+
+add Effect.makeLatch, for creating a simple async latch
+
+```ts
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+ // Create a latch, starting in the closed state
+ const latch = yield* Effect.makeLatch(false)
+
+ // Fork a fiber that logs "open sesame" when the latch is opened
+ const fiber = yield* Effect.log("open sesame").pipe(
+ latch.whenOpen,
+ Effect.fork
+ )
+
+ // Open the latch
+ yield* latch.open
+ yield* fiber.await
+})
+```

.changeset/quick-roses-warn.md

@@ -0,0 +1,6 @@
+---
+"effect": minor
+"@effect/cli": patch
+---
+
+Add Number.round

.changeset/seven-lamps-nail.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `Fiber<A, E>` is now a subtype of `Effect<A, E>`. This change removes the need for explicit call `Fiber.join`.
+
+```typescript
+import { Effect, Fiber } from "effect"
+
+Effect.gen(function*() {
+ const fiber = yield* Effect.fork(Effect.succeed(1))
+
+ const oldWay = yield* Fiber.join(fiber)
+ const now = yield* fiber
+}))
+```

.changeset/stream-share.md

@@ -0,0 +1,10 @@
+---
+"effect": minor
+---
+
+add `Stream.share` api
+
+The `Stream.share` api is a ref counted variant of the broadcast apis.
+
+It allows you to share a stream between multiple consumers, and will close the
+upstream when the last consumer ends.

.changeset/strong-moose-tickle.md

@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+add Cause.Annotated

.changeset/tender-foxes-walk.md

@@ -0,0 +1,87 @@
+---
+"@effect/platform-browser": minor
+"@effect/platform-node": minor
+"@effect/platform-bun": minor
+"@effect/platform": minor
+"@effect/rpc-http": minor
+---
+
+refactor /platform HttpClient
+
+#### HttpClient.fetch removed
+
+The `HttpClient.fetch` client implementation has been removed. Instead, you can
+access a `HttpClient` using the corresponding `Context.Tag`.
+
+```ts
+import { FetchHttpClient, HttpClient } from "@effect/platform"
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+ const client = yield* HttpClient.HttpClient
+
+ // make a get request
+ yield* client.get("https://jsonplaceholder.typicode.com/todos/1")
+}).pipe(
+ Effect.scoped,
+ // the fetch client has been moved to the `FetchHttpClient` module
+ Effect.provide(FetchHttpClient.layer)
+)
+```
+
+#### `HttpClient` interface now uses methods
+
+Instead of being a function that returns the response, the `HttpClient`
+interface now uses methods to make requests.
+
+Some shorthand methods have been added to the `HttpClient` interface to make
+less complex requests easier.
+
+```ts
+import {
+ FetchHttpClient,
+ HttpClient,
+ HttpClientRequest
+} from "@effect/platform"
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+ const client = yield* HttpClient.HttpClient
+
+ // make a get request
+ yield* client.get("https://jsonplaceholder.typicode.com/todos/1")
+ // make a post request
+ yield* client.post("https://jsonplaceholder.typicode.com/todos")
+
+ // execute a request instance
+ yield* client.execute(
+ HttpClientRequest.get("https://jsonplaceholder.typicode.com/todos/1")
+ )
+})
+```
+
+#### Scoped `HttpClientResponse` helpers removed
+
+The `HttpClientResponse` helpers that also eliminated the `Scope` have been removed.
+
+Instead, you can use the `HttpClientResponse` methods directly, and explicitly
+add a `Effect.scoped` to the pipeline.
+
+```ts
+import { FetchHttpClient, HttpClient } from "@effect/platform"
+import { Effect } from "effect"
+
+Effect.gen(function* () {
+ const client = yield* HttpClient.HttpClient
+
+ yield* client.get("https://jsonplaceholder.typicode.com/todos/1").pipe(
+ Effect.flatMap((response) => response.json),
+ Effect.scoped // eliminate the `Scope`
+ )
+})
+```
+
+#### Some apis have been renamed
+
+Including the `HttpClientRequest` body apis, which is to make them more
+discoverable.

.changeset/thick-coats-buy.md

@@ -0,0 +1,5 @@
+---
+"@effect/platform": patch
+---
+
+Added refinement overloads to `HttpClient.filterOrFail` and `HttpClient.filterOrElse`

.changeset/twelve-dingos-destroy.md

@@ -0,0 +1,6 @@
+---
+"@effect/opentelemetry": minor
+"effect": minor
+---
+
+Cache some fiber references in the runtime to optimize reading in hot-paths

.changeset/violet-suns-chew.md

@@ -0,0 +1,26 @@
+---
+"effect": minor
+---
+
+Added `RcMap.keys` and `MutableHashMap.keys`.
+
+These functions allow you to get a list of keys currently stored in the underlying hash map.
+
+```ts
+const map = MutableHashMap.make([["a", "a"], ["b", "b"], ["c", "c"]])
+const keys = MutableHashMap.keys(map) // ["a", "b", "c"]
+```
+
+```ts
+Effect.gen(function* () {
+ const map = yield* RcMap.make({
+ lookup: (key) => Effect.succeed(key)
+ })
+
+ yield* RcMap.get(map, "a")
+ yield* RcMap.get(map, "b")
+ yield* RcMap.get(map, "c")
+
+ const keys = yield* RcMap.keys(map) // ["a", "b", "c"]
+})
+```

.changeset/wise-kiwis-tan.md

@@ -0,0 +1,16 @@
+---
+"effect": minor
+---
+
+The `FiberRef<A>` is now a subtype of `Effect<A>`. This change simplifies handling of deferred values, removing the need for explicit call `FiberRef.get`.
+
+```typescript
+import { Effect, FiberRef } from "effect"
+
+Effect.gen(function* () {
+ const fiberRef = yield* FiberRef.make("value")
+
+ const before = yield* FiberRef.get(fiberRef)
+ const after = yield* fiberRef
+})
+```

packages/cli/src/internal/prompt/number.ts

@@ -5,6 +5,7 @@ import * as Optimize from "@effect/printer/Optimize"
 import * as Schema from "@effect/schema/Schema"
 import * as Arr from "effect/Array"
 import * as Effect from "effect/Effect"
+import * as EffectNumber from "effect/Number"
 import * as Option from "effect/Option"
 import type * as Prompt from "../../Prompt.js"
 import * as InternalPrompt from "../prompt.js"
@@ -20,11 +21,6 @@ interface State {
  readonly error: Option.Option<string>
 }
 
-const round = (number: number, precision: number) => {
- const factor = Math.pow(10, precision)
- return Math.round(number * factor) / factor
-}
-
 const parseInt = Schema.NumberFromString.pipe(
  Schema.int(),
  Schema.decodeUnknown
@@ -352,7 +348,7 @@ function handleProcessFloat(options: FloatOptions) {
  })),
  onSuccess: (n) =>
  Effect.flatMap(
- Effect.sync(() => round(n, options.precision)),
+ Effect.sync(() => EffectNumber.round(n, options.precision)),
  (rounded) =>
  Effect.match(options.validate(rounded), {
  onFailure: (error) =>

packages/cluster-node/examples/sample-connect.ts

@@ -30,25 +30,33 @@ const liveLayer = Effect.gen(function*() {
  Layer.effectDiscard,
  Layer.provide(Sharding.live),
  Layer.provide(StorageFile.storageFile),
- Layer.provide(PodsRpc.podsRpc<never>((podAddress) =>
- HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
- HttpClient.fetchOk.pipe(
- HttpClient.mapRequest(
- HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
- )
- )
- ).pipe(RpcResolver.toClient)
- )),
- Layer.provide(ShardManagerClientRpc.shardManagerClientRpc(
- (shardManagerUri) =>
+ Layer.provide(Layer.unwrapEffect(Effect.gen(function*() {
+ const client = yield* HttpClient.HttpClient
+ return PodsRpc.podsRpc<never>((podAddress) =>
  HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
- HttpClient.fetchOk.pipe(
+ client.pipe(
+ HttpClient.filterStatusOk,
  HttpClient.mapRequest(
- HttpClientRequest.prependUrl(shardManagerUri)
+ HttpClientRequest.prependUrl(`http://${podAddress.host}:${podAddress.port}/api/rest`)
  )
  )
  ).pipe(RpcResolver.toClient)
- )),
+ )
+ }))),
+ Layer.provide(Layer.unwrapEffect(Effect.gen(function*() {
+ const client = yield* HttpClient.HttpClient
+ return ShardManagerClientRpc.shardManagerClientRpc(
+ (shardManagerUri) =>
+ HttpRpcResolver.make<ShardingServiceRpc.ShardingServiceRpc>(
+ client.pipe(
+ HttpClient.filterStatusOk,
+ HttpClient.mapRequest(
+ HttpClientRequest.prependUrl(shardManagerUri)
+ )
+ )
+ ).pipe(RpcResolver.toClient)
+ )
+ }))),
  Layer.provide(ShardingConfig.withDefaults({ shardingPort: 54322 })),
  Layer.provide(Serialization.json),
  Layer.provide(NodeHttpClient.layerUndici)