IMax153 / effect-docs-astro-showcase

0 stars 0 forks source link

Sync code

Would using Effect.gen and Random be a better example? I'm not sure what the goal is here, but at best, this is just as cumbersome as using the native code.

Proposal:

const main = () => {
  const value = Math.random()
  console.log(`Got value ${value}`)
}

main()

import { Effect, Random } from "effect"

const main = Effect.gen(function* (_) {
  const value = yield* Random.next
  console.log(`Got value ${value}`)
})

Effect.runSync(main)

Async code

Why not use Effect.gen? I'm not sure what the goal is here, but at best, this is just as cumbersome as using the native code.

Proposal:

import { Effect } from "effect"

const main = Effect.gen(function* (_) {
  yield* Effect.sleep("1 second")
  console.log("Hello, World!")
})

Effect.runPromise(main)

Error Handling

Why not use Effect.gen and Random?

Proposal:

class CustomError extends Error {
-  constructor(readonly value: number) {}
+  constructor(readonly value: number) {
+    super()
+  }
}

+// The return type `number` doesn't account
+// for the possibility of throwing an error
-// Return type of `number` doesn't reflect the
-// fact that the function can throw
const maybeFail = (): number => {
  const value = Math.random()
  if (value > 0.5) {
    throw new CustomError(value)
  }
  return value
}

const main = () => {
  try {
    const value = maybeFail()
    console.log(`Got value ${value}`)
  } catch (error) {
    if (error instanceof CustomError) {
      console.error(`Oops! Got value ${error.value}`)
    } else {
      console.error("No idea what happened!")
    }
  }
}

main()

import { Effect, Random, Console } from "effect"

class CustomError extends Error {
  constructor(readonly value: number) {
    super()
  }
}

const maybeFail: Effect.Effect<
  number,
  CustomError // Ensures type safety
> = Effect.gen(function* (_) {
  const value = yield* Random.next
  if (value > 0.5) {
    throw new CustomError(value)
  }
  return value
})

const main = Effect.gen(function* (_) {
  const value = yield* maybeFail
  console.log(`Got value ${value}`)
}).pipe(
  Effect.catchAll((error) =>
    Console.error(`Oops! Got value ${error.value}`)
  )
)

Effect.runPromise(main)

Interruption

Why not use Effect.gen?

Proposal:

import { Effect } from "effect"

const main = Effect.gen(function* (_) {
  yield* Effect.sleep("1 second")
  console.log("Hello")
}).pipe(
  Effect.timeoutFail({
    duration: "500 millis",
    onTimeout: () => "Aborted!"
  })
)

Effect.runPromise(main)

Retry

Should native code use p-retry?
Why not use Effect.gen?
A Tag is unnecessary.

Proposal:

import { FetchHttpClient, HttpClient } from "@effect/platform"
import { Effect } from "effect"

const getUser = (id: number, retries = 3) =>
  HttpClient.get(`/users/${id}`).pipe(
    Effect.andThen((response) => response.json),
    Effect.scoped,
    Effect.retry({ times: retries }),
    Effect.provide(FetchHttpClient.layer)
  )

const main = Effect.gen(function* () {
  const user = yield* getUser(1)
  console.log("Got user", user)
})

Effect.runPromise(main)

Concurrency

The native code is difficult to follow, switch to using p-map?

Proposal:

const getUser = (id: number) =>
  Promise.resolve({ id, name: `user ${id}` })

async function forEach<A, B>(
  items: Array<A>,
  concurrency: number,
  f: (a: A) => Promise<B>
): Promise<Array<B>> {
  let index = 0
  const results: Array<B> = new Array(items.length)
  async function process(index: number) {
    const next = items[index]!
    results[index] = await f(next)
  }
  async function worker() {
    while (index < items.length) {
      await process(index++)
    }
  }
  await Promise.all(Array.from({ length: concurrency }, worker))
  return results
}

const ids = Array.from({ length: 10 }, (_, i) => i)

async function main() {
  const users = await forEach(ids, 3, (id) => getUser(id))
  console.log("Got users", users)
}

main()

or (using p-map)

import pMap from "p-map"

const getUser = (id: number) =>
  Promise.resolve({ id, name: `user ${id}` })

const ids = [1, 2, 3, 4, 5]

async function main() {
  const users = await pMap(ids, getUser, { concurrency: 3 })
  console.log("Got users", users)
}

main()

import { Effect } from "effect"

const getUser = (id: number) => Effect.succeed({ id, name: `user ${id}` })

const ids = [1, 2, 3, 4, 5]

const main = Effect.gen(function* () {
  const users = yield* Effect.forEach(ids, getUser, { concurrency: 3 })
  console.log("Got users", users)
})

Effect.runPromise(main)

Composition

The example is too long and difficult to follow, remove it?

zod

Just a small improvement.

Proposal:

import { Schema } from "@effect/schema"

const User = Schema.Struct({
  username: Schema.String
})

Schema.decodeUnknownSync(User)({
  username: "john_doe"
})

// extract the inferred type
-type User = Schema.Schema.Type<typeof User>
+type User = typeof User.Type

yup

It's redundant and has fewer downloads than Zod, remove it? https://npmtrends.com/superjson-vs-yup-vs-zod

superjson

It's redundant and has fewer downloads than Zod, remove it? https://npmtrends.com/superjson-vs-yup-vs-zod

rxjs

Just a small improvement.

Proposal:

import { Effect, Schedule, Stream } from "effect"

-const counts = Stream.fromSchedule(Schedule.spaced(1000)).pipe(
+const counts = Stream.fromSchedule(Schedule.spaced("1 second")).pipe(
  Stream.take(5),
  Stream.map((x) => x * 2),
  Stream.runCollect
)

Effect.runPromise(counts).then((x) => console.log(x))

p-*

This example is too long and complicated, remove it?

ts-results

Switch to neverthrow, which has more downloads: https://npmtrends.com/@mobily/ts-belt-vs-neverthrow-vs-ts-results

Proposal:

import { existsSync, readFileSync } from "fs"
import { Ok, Err, Result } from "neverthrow"

function readFile(path: string): Result<string, "invalid path"> {
  if (existsSync(path)) {
    return new Ok(readFileSync(path, "utf8"))
  } else {
    return new Err("invalid path")
  }
}

fetch

It's more complex than native alternatives, remove it?

express

It's more complex than native alternatives, remove it?

IMax153 / effect-docs-astro-showcase

Landing page examples code #55

Sync code

Async code

Error Handling

Interruption

Retry

Concurrency

Composition

zod

yup

superjson

rxjs

p-*

ts-results

fetch

express