Fix Effect.all occurrences (#173)

package.json

@@ -19,8 +19,8 @@
     "react-dom": "18.2.0"
   },
   "devDependencies": {
-    "@effect/data": "^0.13.6",
-    "@effect/io": "^0.31.4",
+    "@effect/data": "^0.14.1",
+    "@effect/io": "^0.32.1",
     "@mdx-js/mdx": "^2.3.0",
     "@types/node": "^18.16.1",
     "@types/react": "^18.2.0",

pages/docs/_meta.json

@@ -19,6 +19,8 @@
     "type": "separator"
   },
   "data-types": "Data types",
+  "trait": "Traits",
+  "behaviour": "Behaviours",
   "packages": "Packages",
   "-More": {
     "title": "More",

pages/docs/behaviour/_meta.json

@@ -0,0 +1,4 @@
+{
+  "equivalence": "Equivalence",
+  "order": "Order"
+}

pages/docs/behaviour/equivalence.mdx

@@ -0,0 +1,5 @@
+# Equivalence
+
+import { Stub } from "@/components/Stub"
+
+<Stub />

pages/docs/behaviour/order.mdx

@@ -0,0 +1,5 @@
+# Order
+
+import { Stub } from "@/components/Stub"
+
+<Stub />

pages/docs/essentials/pipeline.mdx

@@ -208,10 +208,10 @@ The syntax for `all` is as follows:
 ```ts
 import * as Effect from "@effect/io/Effect"
 
-const combinedEffect = Effect.all(...effects)
+const combinedEffect = Effect.all(effects)
 ```
 
-Here, `...effects` represents multiple effects that you want to combine. The `all` function will execute all these effects in sequence and return a new effect that produces a tuple containing the results of each individual effect. This can be useful when you need to perform multiple independent operations and collect their results in a structured way.
+Here, `effects` represents multiple effects that you want to combine. The `all` function will execute all these effects in sequence and return a new effect that produces a tuple containing the results of each individual effect. This can be useful when you need to perform multiple independent operations and collect their results in a structured way.
 
 Keep in mind that the order of the results corresponds to the order of the original effects passed to `all`.
 
@@ -224,7 +224,7 @@ const foo = Effect.succeed(42)
 const bar = Effect.succeed("Hello")
 
 // Effect<never, never, [number, string]>
-const combinedEffect = Effect.all(foo, bar)
+const combinedEffect = Effect.all([foo, bar])
 
 console.log(Effect.runSync(combinedEffect)) // Output: [42, "Hello"]
 ```
@@ -251,7 +251,7 @@ const bar = Effect.succeed(2)
 
 // Effect<never, Error, string>
 const program = pipe(
-  Effect.all(foo, bar),
+  Effect.all([foo, bar]),
   Effect.flatMap(([a, b]) => divide(a, b)),
   Effect.map((n1) => increment(n1)),
   Effect.map((n2) => `Result is: ${n2}`)
@@ -294,7 +294,7 @@ const foo = Effect.succeed(10)
 const bar = Effect.succeed(2)
 
 // Effect<never, Error, string>
-const program = Effect.all(foo, bar).pipe(
+const program = Effect.all([foo, bar]).pipe(
   Effect.flatMap(([a, b]) => divide(a, b)),
   Effect.map((n1) => increment(n1)),
   Effect.map((n2) => `Result is: ${n2}`)
@@ -307,11 +307,11 @@ console.log(Effect.runSync(program)) // Output: "Result is: 6"
 
 Let's summarize the transformation functions we have seen so far:
 
-| **Function** | **Input**                                 | **Output**             |
-| ------------ | ----------------------------------------- | ---------------------- |
-| `map`        | `Effect<R, E, A>`, `A => B`               | `Effect<R, E, B>`      |
-| `flatMap`    | `Effect<R, E, A>`, `A => Effect<R, E, B>` | `Effect<R, E, B>`      |
-| `all`        | `Effect<R, E, A>`, `Effect<R, E, B>`      | `Effect<R, E, [A, B]>` |
+| **Function** | **Input**                                 | **Output**                  |
+| ------------ | ----------------------------------------- | --------------------------- |
+| `map`        | `Effect<R, E, A>`, `A => B`               | `Effect<R, E, B>`           |
+| `flatMap`    | `Effect<R, E, A>`, `A => Effect<R, E, B>` | `Effect<R, E, B>`           |
+| `all`        | `Effect<R, E, A>`, `Effect<R, E, B>`, ... | `Effect<R, E, [A, B, ...]>` |
 
 These functions are powerful tools for transforming and chaining `Effect` computations. They allow you to apply functions to values inside `Effect` and build complex pipelines of computations.
 

pages/docs/essentials/using-generators.mdx

@@ -31,7 +31,7 @@ const divide = (a: number, b: number): Effect.Effect<never, Error, number> =>
 
 // Effect<never, Error, string>
 const program = Effect.gen(function* (_) {
-  const [a, b] = yield* _(Effect.all(Effect.succeed(10), Effect.succeed(2)))
+  const [a, b] = yield* _(Effect.all([Effect.succeed(10), Effect.succeed(2)]))
   const n1 = yield* _(divide(a, b))
   const n2 = increment(n1)
   return `Result is: ${n2}`
@@ -56,7 +56,7 @@ const divide = (a: number, b: number): Effect.Effect<never, Error, number> =>
 
 // Effect<never, Error, string>
 const program = pipe(
-  Effect.all(Effect.succeed(10), Effect.succeed(2)),
+  Effect.all([Effect.succeed(10), Effect.succeed(2)]),
   Effect.flatMap(([a, b]) => divide(a, b)),
   Effect.map((n1) => increment(n1)),
   Effect.map((n2) => `Result is: ${n2}`)
@@ -75,9 +75,9 @@ console.log(Effect.runSync(program)) // Output: "Result is: 6"
 
 When working with generators in Effect, the `_` helper plays a crucial role when yielding an effect. By passing the effect you want to yield to the `_` function
 
-```ts /Effect.all(Effect.succeed(10), Effect.succeed(2))/ /divide(a, b)/
+```ts /Effect.all([Effect.succeed(10), Effect.succeed(2)])/ /divide(a, b)/
 const result = Effect.gen(function* (_) {
-  const [a, b] = yield* _(Effect.all(Effect.succeed(10), Effect.succeed(2)))
+  const [a, b] = yield* _(Effect.all([Effect.succeed(10), Effect.succeed(2)]))
   const n1 = yield* _(divide(a, b))
   ...
 })
@@ -111,7 +111,7 @@ const divide = (a: number, b: number): Effect.Effect<never, Error, number> =>
     : Effect.succeed(a / b)
 
 const program = Effect.gen(function* (_) {
-  const [a, b] = yield* _(Effect.all(Effect.succeed(10), Effect.succeed(2)))
+  const [a, b] = yield* _(Effect.all([Effect.succeed(10), Effect.succeed(2)]))
   const n1 = yield* _(divide(a, b))
   const n2 = increment(n1)
   return `Result is: ${n2}`

pages/docs/guide/state-management/global-shared-state.mdx

@@ -292,7 +292,7 @@ const getNames = Effect.flatMap(Ref.make(Chunk.empty<string>()), (ref) => {
       { concurrency: "unbounded", discard: true }
     )
   )
-  return Effect.all(fiber1, fiber2).pipe(
+  return Effect.all([fiber1, fiber2]).pipe(
     Effect.flatMap(([f1, f2]) =>
       Fiber.join(f1).pipe(Effect.flatMap(() => Fiber.join(f2)))
     ),

pages/docs/trait/_meta.json

@@ -0,0 +1,4 @@
+{
+  "hash": "Hash",
+  "equal": "Equal"
+}

pages/docs/trait/equal.mdx

@@ -0,0 +1,5 @@
+# Equal
+
+import { Stub } from "@/components/Stub"
+
+<Stub />

pages/docs/trait/hash.mdx

@@ -0,0 +1,5 @@
+# Hash
+
+import { Stub } from "@/components/Stub"
+
+<Stub />

pages/docs/tutorial/configuration.mdx

@@ -30,10 +30,10 @@ import * as Effect from "@effect/io/Effect"
 import * as Config from "@effect/io/Config"
 
 // Effect<never, ConfigError, void>
-const program = Effect.all(
+const program = Effect.all([
   Effect.config(Config.string("HOST")),
-  Effect.config(Config.float("PORT"))
-).pipe(
+  Effect.config(Config.float("PORT")),
+]).pipe(
   Effect.flatMap(([host, port]) =>
     Effect.sync(() => console.log(`Application started: ${host}:${port}`))
   )

pages/docs/tutorial/context-management/layers.mdx

@@ -187,9 +187,9 @@ export const Recipe = Context.Tag<Recipe>()
 // Layer<Flour | Sugar, never, Recipe>
 export const RecipeLive = Layer.effect(
   Recipe,
-  Effect.map(Effect.all(Sugar, Flour), ([sugar, flour]) =>
+  Effect.map(Effect.all([Sugar, Flour]), ([sugar, flour]) =>
     Recipe.of({
-      steps: Effect.all(sugar.grams(200), flour.cups(1)),
+      steps: Effect.all([sugar.grams(200), flour.cups(1)]),
     })
   )
 )
@@ -217,7 +217,7 @@ export const RecipeLive = Layer.effect(
     const sugar = yield* _(Sugar)
     const flour = yield* _(Flour)
     return Recipe.of({
-      steps: Effect.all(sugar.grams(200), flour.cups(1)),
+      steps: Effect.all([sugar.grams(200), flour.cups(1)]),
     })
   })
 )

pages/docs/tutorial/context-management/services.mdx

@@ -238,7 +238,7 @@ By using the `Effect.serviceOption` function, we can gracefully handle scenarios
 
 ## Using Multiple Services
 
-When we need to manage multiple services in our program, we can utilize the `Effect.all(...tags){:ts}` function.
+When we need to manage multiple services in our program, we can utilize the `Effect.all(tags){:ts}` function.
 By passing a tuple of tags, we can access the corresponding tuple of services:
 
 <Tabs>
@@ -261,7 +261,7 @@ interface Logger {
 const Logger = Context.Tag<Logger>()
 
 // Effect<Random | Logger, never, void>
-const program = Effect.all(Random, Logger).pipe(
+const program = Effect.all([Random, Logger]).pipe(
   Effect.flatMap(([random, logger]) =>
     Effect.flatMap(random.next(), (randomNumber) =>
       logger.log(String(randomNumber))
@@ -291,7 +291,7 @@ const Logger = Context.Tag<Logger>()
 
 // Effect<Random | Logger, never, void>
 const program = Effect.gen(function* (_) {
-  const [random, logger] = yield* _(Effect.all(Random, Logger))
+  const [random, logger] = yield* _(Effect.all([Random, Logger]))
   const randomNumber = yield* _(random.next())
   return yield* _(logger.log(String(randomNumber)))
 })

pages/docs/tutorial/error-management/expected-errors.mdx

@@ -82,13 +82,13 @@ const flakyBar = Random.next.pipe(
 )
 
 // Effect<never, FooError | BarError, string>
-const program = Effect.all(flakyFoo, flakyBar).pipe(
+const program = Effect.all([flakyFoo, flakyBar]).pipe(
   Effect.map(([foo, bar]) => foo + bar)
 )
 ```
 
 In the above program, we have two operations: `flakyFoo` and `flakyBar`, each representing a potential source of error.
-These operations are combined using the `Effect.all(...effects){:ts}` function from the Effect library, which allows us to sequence them together.
+These operations are combined using the `Effect.all(effects){:ts}` function from the Effect library, which allows us to sequence them together.
 
   </Tab>
   <Tab>