Process substitution normally inlines a command where a filename is expected. This construction, from the same Stack Overflow answer that covered detaching processes, uses it for the pipe it brings and throws the command away:
exec {i}<> <(:) {o}<> >(:) {e}<> >(:)Three pieces, each doing one job. The substitutions <(:) and >(:) each make bash create a pipe and expose it as a /dev/fd/N path; the substituted command is :, which touches nothing and exits immediately—it exists only so the substitution does. {i}<> is bash’s allocate-a-descriptor syntax: the shell picks a free descriptor number and stores it in $i. And <> opens the /dev/fd path read-write, which is the load-bearing trick: that open produces a descriptor holding both ends of the pipe. A pipe whose read end and write end are both held cannot deliver EOF and cannot raise SIGPIPE, so the endpoint stays valid indefinitely—long after : has exited, with no producer yet attached.
When those opens succeed, $i, $o, and $e name three durable anonymous pipe endpoints that exist before any of the processes that will use them. That inverts the usual shell constraint. A pipeline’s pipes are born and die with the pipeline, and their order of creation is the pipeline’s order. Here the rendezvous points are allocated first, so consumers and producers can be launched independently, in any order, at any interval—in the answer, retained descriptors were passed into dynamically generated coprocesses as they were created. Descriptor lifetime is under explicit control: the endpoint lives until you deliberately close it (exec {i}>&-), not until some process happens to exit.
The named-pipe comparison is where this earns its keep. mkfifo also decouples endpoint creation from process creation, but it costs a filesystem path—a name to choose, permissions to consider, a stale node to clean up on every exit path—and opening a FIFO one-sided blocks until a peer arrives, which reintroduces the ordering problem the endpoint was supposed to remove. The substitution endpoint is anonymous, needs no filesystem cleanup, and can retain both ends through one open. Keeping the write end open also means EOF cannot signal that a producer has finished; completion needs another signal.
The construction depends on Linux’s /dev/fd semantics—macOS’s /dev/fd duplicates the descriptor instead of reopening the pipe, and the read-write open fails outright—and on bash-specific syntax. The answer documents an occasional “file busy” error when using : and reports no such failure with sleep 1 or command true in the slot. Those are observed workarounds for that exit/open race, not a guarantee from the syntax. The shell’s descriptor allocator becomes a small IPC toolbox for the rare script that needs plumbing assembled before the machines it connects.