Option.some / Option.none

Creates an Option that contains a value, or one that contains nothing.

1
import { Option } from "effect"
2

3
//      ┌─── Option<number>
4
//      ▼
5
const found = Option.some(42)
6
const missing = Option.none<number>()
7

8
Option.isSome(found)   // true
9
Option.isNone(missing) // true

When to Use

When a value might not exist and the caller only needs to distinguish presence from absence, no error information attached.

Option.fromNullishOr

Returns Some(value) when the argument is neither null nor undefined, otherwise None. The bridge between nullable JavaScript APIs and the Option world.

1
import { Option } from "effect"
2

3
const map = new Map<string, string>([["a", "hello"]])
4

5
//      ┌─── Option<string>
6
//      ▼
7
const present = Option.fromNullishOr(map.get("a"))
8
const absent = Option.fromNullishOr(map.get("b"))

When to Use

Wrapping Map.get, Array.find, DOM lookups, or any API that signals absence with null/undefined.

Your turn build an `Option.some`, an `Option.none()`, and use `Option.fromNullishOr` to bridge nullable values.

Option.map / Option.getOrElse / Option.match

Transform a Some without touching None; unwrap with a fallback; or branch on both cases explicitly.

1
import { Option } from "effect"
2

3
const doubled = Option.map(Option.some(5), (n) => n * 2)        // Some(10)
4
const skipped = Option.map(Option.none<number>(), (n) => n * 2) // None
5

6
const value = Option.getOrElse(Option.none<number>(), () => 0)  // 0
7

8
const message = Option.match(Option.some({ name: "Alice" }), {
9
  onNone: () => "No user",
10
  onSome: (u) => `Hello, ${u.name}`,
11
})
12
// "Hello, Alice"

Your turn use `Option.map`, `Option.getOrElse`, and `Option.match` to transform and unwrap Options without manual checks.

Result.right / Result.left

Creates an Result carrying a success value (Right) or a failure value (Left).

1
import { Result } from "effect"
2

3
//      ┌─── Result<number, string>
4
//      ▼
5
const ok = Result.right(42)
6
const err = Result.left("invalid")

Details

The success type comes first in Result<R, L>, the opposite of some other libraries. Read it as “value on the right, error on the left”, matching Haskell convention.

When to Use

Synchronous validation, parsing, anything where success and failure are both worth returning as data. If anything async or service-driven enters the picture, promote to Effect.

Your turn wrap a success with `Result.right`, a failure with `Result.left`, then map and match the results.

Yielding Option and Result in Effect.gen

In Effect v4 both types implement the Yieldable protocol. Inside Effect.gen, yield* Option.some(x) unwraps to x; yield* Option.none() short-circuits the effect with a NoSuchElementException.

Result.right(x) unwraps to x; Result.left(e) fails the effect with e.

1
import { Effect, Option, Data } from "effect"
2

3
class NotFoundError extends Data.TaggedError("NotFoundError")<{
4
  readonly id: string
5
}> {}
6

7
const findUser = (id: string): Option.Option<{ name: string }> => {
8
  const db = new Map([["1", { name: "Alice" }]])
9
  return Option.fromNullishOr(db.get(id))
10
}
11

12
//      ┌─── Effect<string, NotFoundError, never>
13
//      ▼
14
const program = (id: string) =>
15
  Effect.gen(function* () {
16
    const user = yield* findUser(id)
17
    return user.name
18
  }).pipe(Effect.mapError(() => new NotFoundError({ id })))

This pattern bridges synchronous lookups into Effect’s typed-error system without manual Option.match plumbing.

Your turn `yield*` the `Option` directly inside `Effect.gen`, then pipe `Effect.mapError` to translate the default failure into a domain error.