# RefSubject.update

Updates a `RefSubject` using a pure function.

## Signatures

```ts
export declare const update: {
    <A>(f: (value: A) => A): <E, R>(ref: RefSubject<A, E, R>) => Effect.Effect<A, E, R>;
    <A, E, R>(ref: RefSubject<A, E, R>, f: (value: A) => A): Effect.Effect<A, E, R>;
};
```

## Why

`update` expresses a state transition where the state lives, without moving
transition logic into a component or renderer. The same function can run in
application code, tests, workers, event handlers, or a Typed template.

## Ownership and lifetime

The update runs inside the RefSubject's existing synchronized update
boundary: it reads the committed value, derives the next value, commits it,
and publishes that change. It acquires no independent resource and retains
the subject's existing error and service channels.

## Concurrency and failure

Concurrent updates are serialized by the subject core so each function sees
a committed value. A pure updater adds no error channel; failures already
associated with reading or writing the RefSubject remain explicit in `E`.

## Examples

```ts
import { Effect } from "effect"
import * as RefSubject from "@typed/fx/RefSubject"

const program = Effect.gen(function* () {
  const count = yield* RefSubject.make(5)

  // Increment by 1
  yield* RefSubject.update(count, (n) => n + 1)
  const value = yield* count
  console.log(value) // 6

  // Can also use pipe syntax
  yield* count.pipe(RefSubject.update((n) => n * 2))
  const doubled = yield* count
  console.log(doubled) // 12
})
```