# Parser.FlatMap

Selects the next Parser from a successful value and continues at the remaining input.

## Signatures

```ts
interface FlatMap<P extends Any, F extends TypeFunction> extends Parser<unknown> {
    readonly return: InputOf<this> extends infer Input extends string ? Apply<P, Input> extends infer R ? [
        R
    ] extends [
        never
    ] ? never : R extends readonly [
        infer Value,
        infer Rest extends string
    ] ? Pipe<Value, F> extends infer Next ? [
        Next
    ] extends [
        never
    ] ? never : Next extends Any ? Pipe<Rest, Next> : never : never : never : never : never;
}
```

## Why

Dependent grammar remains expressible without losing failure or remainder information.

## Ownership and lifetime

TypeScript instantiates `FlatMap` while parsing a string-literal input; partial results and unconsumed text exist only in the resulting type.

## Property: return

Computes this type lambda's parse result for its current input.

## Property: return: Why

The local type-function protocol evaluates each parser combinator through this member without a parallel runtime object.

## Property: return: Ownership and lifetime

TypeScript evaluates `FlatMap.return` when the surrounding parser is applied; the associated result is erased and retains no input at runtime.