FileSystem
The @effect/platform/FileSystem
module provides a set of operations for reading and writing from/to the file system.
The module provides a single FileSystem
tag, which acts as the gateway for interacting with the filesystem.
1import { import FileSystem
FileSystem } from "@effect/platform"2import { import Effect
Effect } from "effect"3
4const const program: Effect.Effect<void, never, FileSystem.FileSystem>
program = import Effect
Effect.const gen: <YieldWrap<Tag<FileSystem.FileSystem, FileSystem.FileSystem>>, void>(f: (resume: Effect.Adapter) => Generator<YieldWrap<Tag<FileSystem.FileSystem, FileSystem.FileSystem>>, void, never>) => Effect.Effect<...> (+1 overload)
gen(function* () {5 const const fs: FileSystem.FileSystem
fs = yield* import FileSystem
FileSystem.const FileSystem: Tag<FileSystem.FileSystem, FileSystem.FileSystem>
FileSystem6
7 // use `fs` to operate on the file system8})
The FileSystem
interface includes the following operations:
Operation | Description |
---|---|
access | Check if a file can be accessed. You can optionally specify the level of access to check for. |
copy | Copy a file or directory from fromPath to toPath . Equivalent to cp -r . |
copyFile | Copy a file from fromPath to toPath . |
chmod | Change the permissions of a file. |
chown | Change the owner and group of a file. |
exists | Check if a path exists. |
link | Create a hard link from fromPath to toPath . |
makeDirectory | Create a directory at path . You can optionally specify the mode and whether to recursively create nested directories. |
makeTempDirectory | Create a temporary directory. By default, the directory will be created inside the system’s default temporary directory. |
makeTempDirectoryScoped | Create a temporary directory inside a scope. Functionally equivalent to makeTempDirectory , but the directory will be automatically deleted when the scope is closed. |
makeTempFile | Create a temporary file. The directory creation is functionally equivalent to makeTempDirectory . The file name will be a randomly generated string. |
makeTempFileScoped | Create a temporary file inside a scope. Functionally equivalent to makeTempFile , but the file will be automatically deleted when the scope is closed. |
open | Open a file at path with the specified options . The file handle will be automatically closed when the scope is closed. |
readDirectory | List the contents of a directory. You can recursively list the contents of nested directories by setting the recursive option. |
readFile | Read the contents of a file. |
readFileString | Read the contents of a file as a string. |
readLink | Read the destination of a symbolic link. |
realPath | Resolve a path to its canonicalized absolute pathname. |
remove | Remove a file or directory. By setting the recursive option to true , you can recursively remove nested directories. |
rename | Rename a file or directory. |
sink | Create a writable Sink for the specified path . |
stat | Get information about a file at path . |
stream | Create a readable Stream for the specified path . |
symlink | Create a symbolic link from fromPath to toPath . |
truncate | Truncate a file to a specified length. If the length is not specified, the file will be truncated to length 0 . |
utimes | Change the file system timestamps of the file at path . |
watch | Watch a directory or file for changes. |
writeFile | Write data to a file at path . |
writeFileString | Write a string to a file at path . |
Example (Using readFileString
)
1import { import FileSystem
FileSystem } from "@effect/platform"2import { import NodeContext
NodeContext, import NodeRuntime
NodeRuntime } from "@effect/platform-node"3import { import Effect
Effect } from "effect"4
5const const program: Effect.Effect<void, PlatformError, FileSystem.FileSystem>
program = import Effect
Effect.const gen: <YieldWrap<Tag<FileSystem.FileSystem, FileSystem.FileSystem>> | YieldWrap<Effect.Effect<string, PlatformError, never>>, void>(f: (resume: Effect.Adapter) => Generator<...>) => Effect.Effect<...> (+1 overload)
gen(function* () {6 const const fs: FileSystem.FileSystem
fs = yield* import FileSystem
FileSystem.const FileSystem: Tag<FileSystem.FileSystem, FileSystem.FileSystem>
FileSystem7
8 // Reading the content of the same file where this code is written9 const const content: string
content = yield* const fs: FileSystem.FileSystem
fs.(property) FileSystem.readFileString: (path: string, encoding?: string) => Effect.Effect<string, PlatformError>
Read the contents of a file.
readFileString("./index.ts", "utf8")10 namespace console
var console: Console
The `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[]): void
Prints 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 content: string
content)11})12
13import NodeRuntime
NodeRuntime.const runMain: RunMain
<PlatformError, void>(effect: Effect.Effect<void, PlatformError, never>, options?: {
readonly disableErrorReporting?: boolean | undefined;
readonly disablePrettyLogger?: boolean | undefined;
readonly teardown?: Teardown | undefined;
}) => void (+1 overload)
runMain(const program: Effect.Effect<void, PlatformError, FileSystem.FileSystem>
program.(method) Pipeable.pipe<Effect.Effect<void, PlatformError, FileSystem.FileSystem>, Effect.Effect<void, PlatformError, never>>(this: Effect.Effect<...>, ab: (_: Effect.Effect<...>) => Effect.Effect<...>): 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)))