Path

The @effect/platform/Path module provides a set of operations for working with file paths.

Basic Usage

The module provides a single Path tag, which acts as the gateway for interacting with paths.

1
import { import Path
Path } from "@effect/platform"
2
import { import Effect
Effect } from "effect"
3

4
const const program: Effect.Effect<void, never, Path.Path>
program = import Effect
Effect.const gen: <YieldWrap<Tag<Path.Path, Path.Path>>, void>(f: (resume: Effect.Adapter) => Generator<YieldWrap<Tag<Path.Path, Path.Path>>, void, never>) => Effect.Effect<...> (+1 overload)
gen(function* () {
5
  const const path: Path.Path
path = yield* import Path
Path.namespace Path
const Path: Tag<Path.Path, Path.Path>
Path
6

7
  // use `path` to operate on paths
8
})

The Path interface includes the following operations:

Operation	Description
basename	Returns the last part of a path, optionally removing a given suffix.
dirname	Returns the directory part of a path.
extname	Returns the file extension from a path.
format	Formats a path object into a path string.
fromFileUrl	Converts a file URL to a path.
isAbsolute	Checks if a path is absolute.
join	Joins multiple path segments into one.
normalize	Normalizes a path by resolving `.` and `..` segments.
parse	Parses a path string into an object with its segments.
relative	Computes the relative path from one path to another.
resolve	Resolves a sequence of paths to an absolute path.
sep	Returns the platform-specific path segment separator (e.g., `/` on POSIX).
toFileUrl	Converts a path to a file URL.
toNamespacedPath	Converts a path to a namespaced path (specific to Windows).

Example (Using join)

1
import { import Path
Path } from "@effect/platform"
2
import { import Effect
Effect } from "effect"
3
import { import NodeContext
NodeContext, import NodeRuntime
NodeRuntime } from "@effect/platform-node"
4

5
const const program: Effect.Effect<void, never, Path.Path>
program = import Effect
Effect.const gen: <YieldWrap<Tag<Path.Path, Path.Path>>, void>(f: (resume: Effect.Adapter) => Generator<YieldWrap<Tag<Path.Path, Path.Path>>, void, never>) => Effect.Effect<...> (+1 overload)
gen(function* () {
6
  const const path: Path.Path
path = yield* import Path
Path.namespace Path
const Path: Tag<Path.Path, Path.Path>
Path
7

8
  const const mypath: string
mypath = const path: Path.Path
path.(property) Path.join: (...paths: ReadonlyArray<string>) => string
join("tmp", "file.txt")
9
  namespace console
var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v22.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
console.(method) Console.log(message?: any, ...optionalParams: any[]): voidPrints to `stdout` with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to [`printf(3)`](http://man7.org/linux/man-pages/man3/printf.3.html)
(the arguments are all passed to [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args)).

```js
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
```

See [`util.format()`](https://nodejs.org/docs/latest-v22.x/api/util.html#utilformatformat-args) for more information.
log(const mypath: string
mypath)
10
})
11

12
import NodeRuntime
NodeRuntime.const runMain: RunMain
<never, void>(effect: Effect.Effect<void, never, never>, options?: {
    readonly disableErrorReporting?: boolean | undefined;
    readonly disablePrettyLogger?: boolean | undefined;
    readonly teardown?: Teardown | undefined;
}) => void (+1 overload)
runMain(const program: Effect.Effect<void, never, Path.Path>
program.(method) Pipeable.pipe<Effect.Effect<void, never, Path.Path>, Effect.Effect<void, never, never>>(this: Effect.Effect<...>, ab: (_: Effect.Effect<void, never, Path.Path>) => Effect.Effect<void, never, never>): Effect.Effect<...> (+21 overloads)
pipe(import Effect
Effect.const provide: <NodeContext.NodeContext, never, never>(layer: Layer<NodeContext.NodeContext, never, never>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<...> (+9 overloads)Splits the context into two parts, providing one part using the
specified layer/context/runtime and leaving the remainder `R0`
provide(import NodeContext
NodeContext.const layer: Layer<NodeContext.NodeContext, never, never>
layer)))