#Function: assertFailure()

import { 
import ResultResult } from '@praha/byethrow';

const 
const result: Result.Result<never, "error">result = 
import ResultResult.
const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)fail('error');
const 
const failure: Result.Failure<"error">failure = 
import ResultResult.
const assertFailure: <Result.Result<never, "error">>(result: Result.Result<never, "error">) => Result.Failure<"error">
Asserts that a
Result 
or
ResultAsync 
is a
Failure
and returns it.
This function requires that the result's success type is never, meaning the result is
guaranteed to be a
Failure
at the type level.
If the result is a
Success 
at runtime, throws an error.
@function@typeParamR  - The result type that extends ResultMaybeAsync with never as the success type.@paramresult  - The Result  or ResultAsync  to assert as a Failure.
The success type must be never.@returnsThe  Failure result or a Promise of Failure result.@throws{Error} If the result is a Success  at runtime.@example
import { Result } from '@praha/byethrow';

const result = Result.fail('error');
const failure = Result.assertFailure(result);
// failure: { type: 'Failure', error: 'error' }
@example
Type-safe  usage after narrowing success type
import { Result } from '@praha/byethrow';

const getResult = (): Result.Result<number, string> => Result.fail('error');
const value = Result.pipe(
getResult(),
Result.andThen(() => Result.fail('die')), // Success type becomes never
Result.assertFailure, // Type-safe: success type is now never
Result.unwrapError(), // Safe unwrap after assertion
);
@seeunwrapError  - Use with assertFailure to safely unwrap error values.@categoryAssertionsassertFailure(
const result: Result.Result<never, "error">result);
// failure: { type: 'Failure', error: 'error' }

import { 
import ResultResult } from '@praha/byethrow';

const 
const getResult: () => Result.Result<number, string>getResult = (): 
import ResultResult.
type Result<T, E> = Result.Success<T> | Result.Failure<E>
A union type representing either a success or a failure.
@typeParamT  - The type of the Success value.@typeParamE  - The type of the Failure value.@example
import { Result } from '@praha/byethrow';

const doSomething = (): Result.Result<number, string> => {
  return Math.random() > 0.5
    ? { type: 'Success', value: 10 }
    : { type: 'Failure', error: 'Oops' };
};
@categoryCore  TypesResult<number, string> => 
import ResultResult.
const fail: <"error">(error: "error") => Result.Result<never, "error"> (+1 overload)fail('error');
const 
const value: stringvalue = 
import ResultResult.
const pipe: <Result.Result<number, string>, Result.Result<never, string>, Result.Failure<string>, string>(a: Result.Result<number, string>, ab: (a: Result.Result<number, string>) => Result.Result<never, string>, bc: (b: Result.Result<never, string>) => Result.Failure<string>, cd: (c: Result.Failure<string>) => string) => string (+25 overloads)pipe(
  
const getResult: () => Result.Result<number, string>getResult(),
  
import ResultResult.
const andThen: <Result.Result<number, string>, Result.Result<never, "die">>(fn: (a: number) => Result.Result<never, "die">) => (result: Result.Result<number, string>) => Result.Result<never, string> (+1 overload)andThen(() => 
import ResultResult.
const fail: <"die">(error: "die") => Result.Result<never, "die"> (+1 overload)fail('die')), // Success type becomes never
  
import ResultResult.
const assertFailure: <R extends Result.ResultMaybeAsync<never, any>>(result: R) => true extends HasPromise<R> ? Promise<Result.Failure<Result.InferFailure<R>>> : Result.Failure<Result.InferFailure<R>>
Asserts that a
Result 
or
ResultAsync 
is a
Failure
and returns it.
This function requires that the result's success type is never, meaning the result is
guaranteed to be a
Failure
at the type level.
If the result is a
Success 
at runtime, throws an error.
@function@typeParamR  - The result type that extends ResultMaybeAsync with never as the success type.@paramresult  - The Result  or ResultAsync  to assert as a Failure.
The success type must be never.@returnsThe  Failure result or a Promise of Failure result.@throws{Error} If the result is a Success  at runtime.@example
import { Result } from '@praha/byethrow';

const result = Result.fail('error');
const failure = Result.assertFailure(result);
// failure: { type: 'Failure', error: 'error' }
@example
Type-safe  usage after narrowing success type
import { Result } from '@praha/byethrow';

const getResult = (): Result.Result<number, string> => Result.fail('error');
const value = Result.pipe(
getResult(),
Result.andThen(() => Result.fail('die')), // Success type becomes never
Result.assertFailure, // Type-safe: success type is now never
Result.unwrapError(), // Safe unwrap after assertion
);
@seeunwrapError  - Use with assertFailure to safely unwrap error values.@categoryAssertionsassertFailure, // Type-safe: success type is now never
  
import ResultResult.
const unwrapError: <Result.Failure<string>>() => (result: Result.Failure<string>) => string (+3 overloads)unwrapError(), // Safe unwrap after assertion
);