Module `Base__.With_return`

`with_return f`

allows for something like the return statement in C within `f`

.

There are three ways `f`

can terminate:

If `f`

calls `r.return x`

, then `x`

is returned by `with_return`

. If `f`

evaluates to a value `x`

, then `x`

is returned by `with_return`

. If `f`

raises an exception, it escapes `with_return`

. Here is a typical example:

```
let find l ~f =
with_return (fun r ->
List.iter l ~f:(fun x -> if f x then r.return (Some x));
None
)
```

It is only because of a deficiency of ML types that `with_return`

doesn't have type:

`val with_return : 'a. (('a -> ('b. 'b)) -> 'a) -> 'a `

but we can slightly increase the scope of `'b`

without changing the meaning of the type, and then we get:

```
type 'a return = { return : 'b . 'a -> 'b }
val with_return : ('a return -> 'a) -> 'a
```

But the actual reason we chose to use a record type with polymorphic field is that otherwise we would have to clobber the namespace of functions with `return`

and that is undesirable because `return`

would get hidden as soon as we open any monad. We considered names different than `return`

but everything seemed worse than just having `return`

as a record field. We are clobbering the namespace of record fields but that is much more acceptable.

type -'a return

` = `private

`{`

`}`

val with_return : ('a return -> 'a ) -> 'a

val with_return_option : ('a return -> unit) -> 'a option

Note that `with_return_option`

allocates ~5 words more than the equivalent `with_return`

call.

val prepend : 'a return -> f:('b -> 'a ) -> 'b return

`prepend a ~f`

returns a value `x`

such that each call to `x.return`

first applies `f`

before applying `a.return`

. The call to `f`

is "prepended" to the call to the original `a.return`

. A possible use case is to hand `x`

over to another function which returns `'b`

, a subtype of `'a`

, or to capture a common transformation `f`

applied to returned values at several call sites.