# Other Functions

### Other Useful Functions

#### requireTrue

Returns the specified error if the async-wrapped value is `false`.

```fsharp
'a -> Async<bool> -> Async<Result<unit, 'a>>`
```

#### requireFalse

Returns the specified error if the async-wrapped value is `true`.

```fsharp
'a -> Async<bool> -> Async<Result<unit, 'a>>`
```

#### requireSome

Converts an async-wrapped Option to a Result, using the given error if None.

```fsharp
'a -> Async<'b option> -> Async<Result<'b, 'a>>`
```

#### requireSomeWith

Converts an async-wrapped Option to a Result, using the given error factory if None. The error factory is only called when the value is `None`.

```fsharp
(unit -> 'a) -> Async<'b option> -> Async<Result<'b, 'a>>
```

#### requireNone

Converts an async-wrapped Option to a Result, using the given error if Some.

```fsharp
'a -> Async<'b option> -> Async<Result<unit, 'a>>`
```

#### requireNoneWith

Converts an async-wrapped Option to a Result, using the given error factory if Some. The error factory is only called when the value is `Some`.

```fsharp
(unit -> 'a) -> Async<'b option> -> Async<Result<unit, 'a>>
```

#### requireValueSome

Converts an async-wrapped ValueOption to a Result, using the given error if ValueNone.

```fsharp
'a -> Async<'b voption> -> Async<Result<'b, 'a>>
```

#### requireValueNone

Converts an async-wrapped ValueOption to a Result, using the given error if ValueSome.

```fsharp
'a -> Async<'b voption> -> Async<Result<unit, 'a>>
```

#### requireEqual

Returns Ok if the async-wrapped value and the provided value are equal, or the specified error if not. Same as `requireEqualTo`, but with a parameter order that fits normal function application better than piping.

```fsharp
'a -> Async<'a> -> 'b -> Async<Result<unit, 'b>>
```

#### requireEqualTo

Returns Ok if the async-wrapped value and the provided value are equal, or the specified error if not. Same as `requireEqual`, but with a parameter order that fits piping better than normal function application.

```fsharp
'a -> 'b -> Async<'a> -> Async<Result<unit, 'b>>
```

#### requireEmpty

Returns Ok if the async-wrapped sequence is empty, or the specified error if not.

```fsharp
'a -> Async<'b> -> Async<Result<unit, 'a>>
```

#### requireNotEmpty

Returns Ok if the async-wrapped sequence is non-empty, or the specified error if not.

```fsharp
'a -> Async<'b> -> Async<Result<unit, 'a>>
```

#### requireHead

Returns the first item of the sequence if it exists, or the specified error if the sequence is empty

```fsharp
'a -> Async<'b> -> Async<Result<'c, 'a>>
```

#### require

Returns the provided async-wrapped result if it is Ok and the predicate is true, or if the async-wrapped result is Error. If the predicate is false, returns a new async-wrapped Error result with the error value.

```fsharp
('a -> bool) -> 'b -> Async<Result<'a,'b>> -> Async<Result<'a,'b>>
```

#### setError

Replaces an error value of an async-wrapped result with a custom error value

```fsharp
'a -> Async<Result<'b, 'c>> -> Async<Result<'b, 'a>>
```

#### withError

Replaces a unit error value of an async-wrapped result with a custom error value. Safer than `setError` since you're not losing any information.

```fsharp
'a -> Async<Result<'b, unit> -> Async<Result<'b, 'a>>
```

#### defaultValue

Extracts the contained value of an async-wrapped result if Ok, otherwise uses the provided value.

```fsharp
'a -> Async<Result<'a, 'b>> -> Async<'a>
```

#### defaultWith

Extracts the contained value of an async-wrapped result if Ok, otherwise evaluates the given function and uses the result.

```fsharp
(unit -> 'a) -> Async<Result<'a, 'b>> -> Async<'a>
```

#### ignoreError

Same as `defaultValue` for a result where the Ok value is unit. The name describes better what is actually happening in this case.

```fsharp
Async<Result<unit, 'a>> -> Async<unit>
```

#### tee

If the async-wrapped result is Ok, executes the function on the Ok value. Passes through the input value unchanged.

```fsharp
('a -> unit) -> Async<Result<'a, 'b>> -> Async<Result<'a, 'b>>
```

#### teeError

If the async-wrapped result is Error, executes the function on the Error value. Passes through the input value unchanged.

```fsharp
('a -> unit) -> Async<Result<'b, 'a>> -> Async<Result<'b, 'a>>
```

#### teeIf

If the async-wrapped result is Ok and the predicate returns true for the wrapped value, executes the function on the Ok value. Passes through the input value unchanged.

```fsharp
('a -> bool) -> ('a -> unit) -> Async<Result<'a, 'b>> -> Async<Result<'a, 'b>>
```

#### teeErrorIf

If the async-wrapped result is Error and the predicate returns true for the wrapped value, executes the function on the Error value. Passes through the input value unchanged.

```fsharp
('a -> bool) -> ('a -> unit) -> Async<Result<'b, 'a>> -> Async<Result<'b, 'a>>
```

#### defaultError

Extracts the contained error value of an async-wrapped result if `Error`, otherwise uses the provided value.

```fsharp
'error -> Async<Result<'ok, 'error>> -> Async<'error>
```

***

### bindRequire Functions

The `bindRequire*` functions combine a `bind` and a `require` check in one step. They bind the inner `Ok` value through a function, then assert a condition on the result, returning `Error` with the given error value if the condition is not met.

#### bindRequireSome

Binds the async result and requires the inner `Ok` value to be `Some`, returning `Error` with the given error if it is `None`.

```fsharp
'error -> Async<Result<'ok option, 'error>> -> Async<Result<'ok, 'error>>
```

#### bindRequireNone

Binds the async result and requires the inner `Ok` value to be `None`, returning `Error` with the given error if it is `Some`.

```fsharp
'error -> Async<Result<'ok option, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireValueSome

Binds the async result and requires the inner `Ok` value to be `ValueSome`, returning `Error` with the given error if it is `ValueNone`.

```fsharp
'error -> Async<Result<'ok voption, 'error>> -> Async<Result<'ok, 'error>>
```

#### bindRequireValueNone

Binds the async result and requires the inner `Ok` value to be `ValueNone`, returning `Error` with the given error if it is `ValueSome`.

```fsharp
'error -> Async<Result<'ok voption, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireTrue

Binds the async result and requires the inner `Ok` value to be `true`, returning `Error` with the given error if it is `false`.

```fsharp
'error -> Async<Result<bool, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireFalse

Binds the async result and requires the inner `Ok` value to be `false`, returning `Error` with the given error if it is `true`.

```fsharp
'error -> Async<Result<bool, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireNotNull

Binds the async result and requires the inner `Ok` value to be non-null, returning `Error` with the given error if it is `null`.

```fsharp
'error -> Async<Result<'ok, 'error>> -> Async<Result<'ok, 'error>>
```

#### bindRequireEqual

Binds the async result and requires the inner `Ok` value to equal the provided value, returning `Error` with the given error if they differ.

```fsharp
'ok -> 'error -> Async<Result<'ok, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireEmpty

Binds the async result and requires the inner `Ok` sequence to be empty, returning `Error` with the given error if it is not.

```fsharp
'error -> Async<Result<#seq<'ok>, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireNotEmpty

Binds the async result and requires the inner `Ok` sequence to be non-empty, returning `Error` with the given error if it is empty.

```fsharp
'error -> Async<Result<#seq<'ok>, 'error>> -> Async<Result<unit, 'error>>
```

#### bindRequireHead

Binds the async result and returns the first element of the inner `Ok` sequence, returning `Error` with the given error if the sequence is empty.

```fsharp
'error -> Async<Result<#seq<'ok>, 'error>> -> Async<Result<'ok, 'error>>
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://demystifyfp.gitbook.io/fstoolkit-errorhandling/fstoolkit.errorhandling/asyncresult/others.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.