Added bracketW functions

src/IOEither.ts

@@ -845,16 +845,27 @@ export const bracket = <E, A, B>(
   acquire: IOEither<E, A>,
   use: (a: A) => IOEither<E, B>,
   release: (a: A, e: Either<E, B>) => IOEither<E, void>
-): IOEither<E, B> =>
+): IOEither<E, B> => bracketW(acquire, use, release)
+
+/**
+ * Less strict version of [`bracket`](#bracket).
+ *
+ * @since 2.12.0
+ */
+export const bracketW: <E1, E2, E3, A, B>(
+  acquire: IOEither<E1, A>,
+  use: (a: A) => IOEither<E2, B>,
+  release: (a: A, e: E.Either<E2, B>) => IOEither<E3, void>
+) => IOEither<E1 | E2 | E3, B> = (acquire, use, release) =>
   pipe(
     acquire,
-    chain((a) =>
+    chainW((a) =>
       pipe(
         use(a),
         I.chain((e) =>
           pipe(
             release(a, e),
-            chain(() => I.of(e))
+            chainW(() => I.of(e))
           )
         )
       )

src/ReaderTaskEither.ts

@@ -1292,13 +1292,26 @@ export const chainFirstTaskK =
  * @since 2.0.4
  */
 export function bracket<R, E, A, B>(
-  aquire: ReaderTaskEither<R, E, A>,
+  acquire: ReaderTaskEither<R, E, A>,
   use: (a: A) => ReaderTaskEither<R, E, B>,
   release: (a: A, e: Either<E, B>) => ReaderTaskEither<R, E, void>
 ): ReaderTaskEither<R, E, B> {
+  return bracketW(acquire, use, release)
+}
+
+/**
+ * Less strict version of [`bracket`](#bracket).
+ *
+ * @since 2.12.0
+ */
+export function bracketW<R1, R2, R3, E1, E2, E3, A, B>(
+  acquire: ReaderTaskEither<R1, E1, A>,
+  use: (a: A) => ReaderTaskEither<R2, E2, B>,
+  release: (a: A, e: Either<E2, B>) => ReaderTaskEither<R3, E3, void>
+): ReaderTaskEither<R1 & R2 & R3, E1 | E2 | E3, B> {
   return (r) =>
-    TE.bracket(
-      aquire(r),
+    TE.bracketW(
+      acquire(r),
       (a) => use(a)(r),
       (a, e) => release(a, e)(r)
     )

src/TaskEither.ts

@@ -1122,16 +1122,27 @@ export const bracket = <E, A, B>(
   acquire: TaskEither<E, A>,
   use: (a: A) => TaskEither<E, B>,
   release: (a: A, e: Either<E, B>) => TaskEither<E, void>
-): TaskEither<E, B> =>
+): TaskEither<E, B> => bracketW(acquire, use, release)
+
+/**
+ * Less strict version of [`bracket`](#bracket).
+ *
+ * @since 2.12.0
+ */
+export const bracketW: <E1, E2, E3, A, B>(
+  acquire: TaskEither<E1, A>,
+  use: (a: A) => TaskEither<E2, B>,
+  release: (a: A, e: E.Either<E2, B>) => TaskEither<E3, void>
+) => TaskEither<E1 | E2 | E3, B> = (acquire, use, release) =>
   pipe(
     acquire,
-    chain((a) =>
+    chainW((a) =>
       pipe(
         use(a),
         T.chain((e) =>
           pipe(
             release(a, e),
-            chain(() => T.of(e))
+            chainW(() => T.of(e))
           )
         )
       )

test/IOEither.ts

@@ -1,7 +1,7 @@
 import * as U from './util'
 import { sequenceT } from '../src/Apply'
 import * as E from '../src/Either'
-import { identity, pipe, SK } from '../src/function'
+import { constVoid, identity, pipe, SK } from '../src/function'
 import * as I from '../src/IO'
 import * as _ from '../src/IOEither'
 import * as O from '../src/Option'
@@ -366,6 +366,15 @@ describe('IOEither', () => {
     })
   })
 
+  it('bracketW', async () => {
+    const res = _.bracketW(
+      _.right<string, string>('string'),
+      (_a: string) => _.right<number, string>('test'),
+      (_a: string, _e: E.Either<number, string>) => _.right<Error, void>(constVoid())
+    )()
+    U.deepStrictEqual(res, E.right('test'))
+  })
+
   it('getApplicativeIOValidation', () => {
     const A = _.getApplicativeIOValidation(S.Monoid)
     U.deepStrictEqual(sequenceT(A)(_.left('a'), _.left('b'))(), E.left('ab'))

test/ReaderTaskEither.ts

@@ -1,6 +1,6 @@
 import { sequenceT } from '../src/Apply'
 import * as E from '../src/Either'
-import { flow, pipe, SK } from '../src/function'
+import { constVoid, flow, pipe, SK } from '../src/function'
 import * as I from '../src/IO'
 import * as IE from '../src/IOEither'
 import * as N from '../src/number'
@@ -415,6 +415,23 @@ describe('ReaderTaskEither', () => {
     })
   })
 
+  it('bracketW', async () => {
+    const acquire = _.right<{ readonly a: string }, string, string>('string')
+    const use = (_a: string) => _.right<{ readonly b: number }, number, string>('test')
+    const release = (_a: string, _e: E.Either<number, string>) =>
+      _.right<{ readonly c: boolean }, Error, void>(constVoid())
+    const res = await _.bracketW(
+      acquire,
+      use,
+      release
+    )({
+      a: 'string',
+      b: 5,
+      c: true
+    })()
+    U.deepStrictEqual(res, E.right('test'))
+  })
+
   it('chainEitherK', async () => {
     const f = (s: string) => E.right(s.length)
     U.deepStrictEqual(await pipe(_.right('a'), _.chainEitherK(f))(undefined)(), E.right(1))

test/TaskEither.ts

@@ -2,7 +2,7 @@ import * as U from './util'
 import { sequenceT } from '../src/Apply'
 import * as RA from '../src/ReadonlyArray'
 import * as E from '../src/Either'
-import { identity, pipe, SK } from '../src/function'
+import { constVoid, identity, pipe, SK } from '../src/function'
 import * as I from '../src/IO'
 import * as IE from '../src/IOEither'
 import { monoidString } from '../src/Monoid'
@@ -356,6 +356,15 @@ describe('TaskEither', () => {
     })
   })
 
+  it('bracketW', async () => {
+    const res = await _.bracketW(
+      _.right<string, string>('string'),
+      (_a: string) => _.right<number, string>('test'),
+      (_a: string, _e: E.Either<number, string>) => _.right<Error, void>(constVoid())
+    )()
+    U.deepStrictEqual(res, E.right('test'))
+  })
+
   // -------------------------------------------------------------------------------------
   // combinators
   // -------------------------------------------------------------------------------------