diff --git a/package.json b/package.json
index 7936423..63a176a 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "lambda-res",
   "description": "Type-safe error handling without exception",
   "keywords": ["aws", "serverless", "lambda", "error", "error-handling"],
-  "version": "1.0.18",
+  "version": "1.0.19",
   "author": "Alex Shelkovskiy <alexshelkov@gmail.com>",
   "repository": "https://github.com/alexshelkov/result",
   "license": "MIT",
diff --git a/src/__tests__/cast.ts b/src/__tests__/cast.ts
index 3384eb4..11028f8 100644
--- a/src/__tests__/cast.ts
+++ b/src/__tests__/cast.ts
@@ -5,11 +5,11 @@ describe('to result', () => {
     expect.assertions(2);
 
     expect(() => {
-      return toResult(null);
+      toResult(null);
     }).toThrow('Unexpected input');
 
     expect(() => {
-      return toResult('123');
+      toResult('123');
     }).toThrow('Unexpected input');
   });
 
@@ -17,7 +17,7 @@ describe('to result', () => {
     expect.assertions(1);
 
     expect(() => {
-      return toResult({ data: 1 });
+      toResult({ data: 1 });
     }).toThrow('Unexpected input');
   });
 
diff --git a/src/__tests__/util.ts b/src/__tests__/util.ts
index a85144d..f249d68 100644
--- a/src/__tests__/util.ts
+++ b/src/__tests__/util.ts
@@ -1,4 +1,4 @@
-import { Err, Result, ok, fail, err, compare, nope } from '../index';
+import { Err, Result, ok, fail, throwFail, err, compare, nope } from '../index';
 
 describe('util', () => {
   it('works with skip option', () => {
@@ -66,11 +66,33 @@ describe('util', () => {
     }).toThrow('Unknown status');
   });
 
+  it('throw fail', () => {
+    expect.assertions(2);
+
+    expect(() => {
+      throwFail<Err>('Thrown');
+    }).toThrow('Thrown');
+
+    expect(() => {
+      const a: string | undefined = Math.random() === -1 ? 'never' : undefined;
+
+      if (!a) {
+        throwFail<Err>('Thrown');
+      }
+
+      // undefined is removed because
+      // throwFail returns never
+      const b: string = a;
+
+      expect(b).toStrictEqual('never');
+    }).toThrow('Thrown');
+  });
+
   it('never will throw exception if called', () => {
     expect.assertions(1);
 
     expect(() => {
-      return nope(undefined as never);
+      nope(undefined as never);
     }).toThrow('Unreachable');
   });
 });
diff --git a/src/index.ts b/src/index.ts
index 2cc37cd..3786ecc 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -2,19 +2,18 @@ export { ErrUtil as Err, Err as ErrInfo, ErrLevel, Errs } from './err';
 
 export { Success, Failure, Result, Response } from './result';
 
-export {
-  isErr,
-  isErrType,
-  isSuccessLike,
-  isFailureLike
-} from './checks'
+export { isErr, isErrType, isSuccessLike, isFailureLike } from './checks';
 
 export {
   ok,
   fail,
+  throwFail,
   err,
   compare,
   nope,
   toResult,
   FailureException,
+  OkFn,
+  FailFn,
+  ThrowFailFn,
 } from './utils';
diff --git a/src/result.ts b/src/result.ts
index 297a985..358d9ff 100644
--- a/src/result.ts
+++ b/src/result.ts
@@ -77,14 +77,6 @@ export interface Failure<Fail> extends PartialFailure<Fail> {
 
   onOk(): never;
 
-  // onFail<Res1 extends Result<never, Fail2>, Res2 extends Response<never, Fail2>, Res extends Res1  | Res2, Data = never, Fail2 = never>(
-  //   this: Result<Data, Fail>,
-  //   cb: (
-  //     err: Fail,
-  //     result: Result<never, Fail>
-  //   ) => Res
-  // ): Res extends Response<never, Fail2> ? Transform<Data, Fail2> : Result<Data, Fail2>;
-
   onFail<Data = never, Fail2 = never>(
     this: Result<Data, Fail>,
     cb: (err: Fail, result: Result<never, Fail>) => Result<never, Fail2>
@@ -95,17 +87,6 @@ export interface Failure<Fail> extends PartialFailure<Fail> {
     cb: (err: Fail, result: Result<never, Fail>) => Response<never, Fail2>
   ): Transform<Data, Fail2>;
 
-  // onErr<
-  //   Type extends string,
-  //   Res extends ({ type: Type } | Type) | Promise<{ type: Type } | Type>,
-  //   Data = never
-  //   >(
-  //   this: Result<Data, Fail>,
-  //   cb: (err: Fail, result: Result<never, Fail>) => Res
-  // ): Res extends Promise<infer WholeRes>
-  //   ? Transform<Data, ErrUtil<WholeRes>>
-  //   : Result<Data, ErrUtil<Res>>;
-
   onErr<Type extends string, Res extends { type: Type } | Type, Data = never>(
     this: Result<Data, Fail>,
     cb: (err: Fail, result: Result<never, Fail>) => Res
diff --git a/src/utils.ts b/src/utils.ts
index cb54f7c..8e2079f 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -316,7 +316,9 @@ type OkMessage = {
   skip?: boolean;
 };
 
-export const ok = <Data = never>(
+export type OkFn = <Data = never>(data: Data, params?: OkMessage) => Success<Data>;
+
+export const ok: OkFn = <Data = never>(
   data: Data,
   { code, order, skip }: OkMessage = {}
 ): Success<Data> => {
@@ -372,7 +374,12 @@ export const err = <Fail = never>(
 
 type ErrorMessage<Error> = FailMessage & Omit<Error, 'type' | 'message'>;
 
-export const fail = <Fail extends Err | undefined = never>(
+export type FailFn = <Fail extends Err | undefined = never>(
+  type: Fail extends Err ? Fail['type'] : undefined,
+  params?: ErrorMessage<Fail>
+) => Failure<Fail>;
+
+export const fail: FailFn = <Fail extends Err | undefined = never>(
   type: Fail extends Err ? Fail['type'] : undefined,
   { message, code, order, skip, ...error }: ErrorMessage<Fail> = {} as ErrorMessage<Fail>
 ): Failure<Fail> => {
@@ -385,6 +392,18 @@ export const fail = <Fail extends Err | undefined = never>(
   return err(failure, { message, code, order, skip });
 };
 
+export type ThrowFailFn = <Fail extends Err | undefined = never>(
+  type: Fail extends Err ? Fail['type'] : undefined,
+  params?: ErrorMessage<Fail>
+) => never;
+
+export const throwFail: ThrowFailFn = <Fail extends Err | undefined = never>(
+  type: Fail extends Err ? Fail['type'] : undefined,
+  params: ErrorMessage<Fail> = {} as ErrorMessage<Fail>
+): never => {
+  throw fail(type, params);
+};
+
 export const compare = <Data1, Error1, Data2, Error2>(
   r1: Result<Data1, Error1>,
   r2: Result<Data2, Error2>