Skip to content

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.

1
import {
import FileSystem
FileSystem
} from "@effect/platform"
2
import {
import Effect
Effect
} from "effect"
3
4
const
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>
FileSystem
6
7
// use `fs` to operate on the file system
8
})

The FileSystem interface includes the following operations:

OperationDescription
accessCheck if a file can be accessed. You can optionally specify the level of access to check for.
copyCopy a file or directory from fromPath to toPath. Equivalent to cp -r.
copyFileCopy a file from fromPath to toPath.
chmodChange the permissions of a file.
chownChange the owner and group of a file.
existsCheck if a path exists.
linkCreate a hard link from fromPath to toPath.
makeDirectoryCreate a directory at path. You can optionally specify the mode and whether to recursively create nested directories.
makeTempDirectoryCreate a temporary directory. By default, the directory will be created inside the system’s default temporary directory.
makeTempDirectoryScopedCreate a temporary directory inside a scope. Functionally equivalent to makeTempDirectory, but the directory will be automatically deleted when the scope is closed.
makeTempFileCreate a temporary file. The directory creation is functionally equivalent to makeTempDirectory. The file name will be a randomly generated string.
makeTempFileScopedCreate a temporary file inside a scope. Functionally equivalent to makeTempFile, but the file will be automatically deleted when the scope is closed.
openOpen a file at path with the specified options. The file handle will be automatically closed when the scope is closed.
readDirectoryList the contents of a directory. You can recursively list the contents of nested directories by setting the recursive option.
readFileRead the contents of a file.
readFileStringRead the contents of a file as a string.
readLinkRead the destination of a symbolic link.
realPathResolve a path to its canonicalized absolute pathname.
removeRemove a file or directory. By setting the recursive option to true, you can recursively remove nested directories.
renameRename a file or directory.
sinkCreate a writable Sink for the specified path.
statGet information about a file at path.
streamCreate a readable Stream for the specified path.
symlinkCreate a symbolic link from fromPath to toPath.
truncateTruncate a file to a specified length. If the length is not specified, the file will be truncated to length 0.
utimesChange the file system timestamps of the file at path.
watchWatch a directory or file for changes.
writeFileWrite data to a file at path.
writeFileStringWrite a string to a file at path.

Example (Using readFileString)

1
import {
import FileSystem
FileSystem
} from "@effect/platform"
2
import {
import NodeContext
NodeContext
,
import NodeRuntime
NodeRuntime
} from "@effect/platform-node"
3
import {
import Effect
Effect
} from "effect"
4
5
const
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>
FileSystem
7
8
// Reading the content of the same file where this code is written
9
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
13
import 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
)))