Add ReaderIO transformation/combinators to ReaderTask

docs/modules/ReaderTask.ts.md

@@ -29,18 +29,23 @@ Added in v2.3.0
   - [asksReaderTaskW](#asksreadertaskw)
   - [chainFirst](#chainfirst)
   - [chainFirstIOK](#chainfirstiok)
+  - [chainFirstReaderIOK](#chainfirstreaderiok)
+  - [chainFirstReaderIOKW](#chainfirstreaderiokw)
   - [chainFirstReaderK](#chainfirstreaderk)
   - [chainFirstReaderKW](#chainfirstreaderkw)
   - [chainFirstTaskK](#chainfirsttaskk)
   - [chainFirstW](#chainfirstw)
   - [chainIOK](#chainiok)
+  - [chainReaderIOK](#chainreaderiok)
+  - [chainReaderIOKW](#chainreaderiokw)
   - [chainReaderK](#chainreaderk)
   - [chainReaderKW](#chainreaderkw)
   - [chainTaskK](#chaintaskk)
   - [flap](#flap)
   - [flatten](#flatten)
   - [flattenW](#flattenw)
   - [fromIOK](#fromiok)
+  - [fromReaderIOK](#fromreaderiok)
   - [fromReaderK](#fromreaderk)
   - [fromTaskK](#fromtaskk)
   - [local](#local)
@@ -72,6 +77,7 @@ Added in v2.3.0
 - [natural transformations](#natural-transformations)
   - [fromIO](#fromio)
   - [fromReader](#fromreader)
+  - [fromReaderIO](#fromreaderio)
   - [fromTask](#fromtask)
 - [utils](#utils)
   - [ApT](#apt)
@@ -266,6 +272,32 @@ export declare const chainFirstIOK: <A, B>(f: (a: A) => IO<B>) => <E>(first: Rea
 
 Added in v2.10.0
 
+## chainFirstReaderIOK
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderIOK: <A, R, B>(
+  f: (a: A) => RIO.ReaderIO<R, B>
+) => (ma: ReaderTask<R, A>) => ReaderTask<R, A>
+```
+
+Added in v2.13.0
+
+## chainFirstReaderIOKW
+
+Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderIOKW: <A, R2, B>(
+  f: (a: A) => RIO.ReaderIO<R2, B>
+) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A>
+```
+
+Added in v2.13.0
+
 ## chainFirstReaderK
 
 **Signature**
@@ -332,6 +364,32 @@ export declare const chainIOK: <A, B>(f: (a: A) => IO<B>) => <E>(first: ReaderTa
 
 Added in v2.4.0
 
+## chainReaderIOK
+
+**Signature**
+
+```ts
+export declare const chainReaderIOK: <A, R, B>(
+  f: (a: A) => RIO.ReaderIO<R, B>
+) => (ma: ReaderTask<R, A>) => ReaderTask<R, B>
+```
+
+Added in v2.13.0
+
+## chainReaderIOKW
+
+Less strict version of [`chainReaderIOK`](#chainreaderiok).
+
+**Signature**
+
+```ts
+export declare const chainReaderIOKW: <A, R2, B>(
+  f: (a: A) => RIO.ReaderIO<R2, B>
+) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, B>
+```
+
+Added in v2.13.0
+
 ## chainReaderK
 
 **Signature**
@@ -416,6 +474,18 @@ export declare const fromIOK: <A, B>(f: (...a: A) => IO<B>) => <E>(...a: A) => R
 
 Added in v2.4.0
 
+## fromReaderIOK
+
+**Signature**
+
+```ts
+export declare const fromReaderIOK: <A extends readonly unknown[], R, B>(
+  f: (...a: A) => RIO.ReaderIO<R, B>
+) => (...a: A) => ReaderTask<R, B>
+```
+
+Added in v2.13.0
+
 ## fromReaderK
 
 **Signature**
@@ -723,6 +793,16 @@ export declare const fromReader: NaturalTransformation22<'Reader', 'ReaderTask'>
 
 Added in v2.3.0
 
+## fromReaderIO
+
+**Signature**
+
+```ts
+export declare const fromReaderIO: <R, A>(fa: RIO.ReaderIO<R, A>) => ReaderTask<R, A>
+```
+
+Added in v2.13.0
+
 ## fromTask
 
 **Signature**

dtslint/ts3.5/ReaderTask.ts

@@ -1,6 +1,79 @@
 import * as _ from '../../src/ReaderTask'
+import * as RIO from '../../src/ReaderIO'
 import { pipe } from '../../src/function'
 
+interface R1 {
+  foo: string
+}
+
+interface R2 {
+  bar: string
+}
+
+//
+// fromReaderIO
+//
+
+// $ExpectType ReaderTask<R1, boolean>
+_.fromReaderIO(RIO.of<R1, boolean>(true))
+
+//
+// fromReaderIOK
+//
+
+// $ExpectType (a: boolean) => ReaderTask<R1, boolean>
+_.fromReaderIOK((a: boolean) => RIO.of<R1, boolean>(a))
+
+//
+// chainReaderIOKW
+//
+
+// $ExpectType ReaderTask<R1 & R2, boolean>
+pipe(
+  _.of<R1, number>(1),
+  _.chainReaderIOKW(() => RIO.of<R2, boolean>(true))
+)
+
+//
+// chainReaderIOK
+//
+
+// $ExpectType ReaderTask<R1, number>
+pipe(
+  _.of<R1, number>(1),
+  _.chainReaderIOK(() => RIO.of(1))
+)
+
+pipe(
+  _.of<R1, number>(1), // $ExpectError
+  _.chainReaderIOK(() => RIO.of<R2, boolean>(true))
+)
+
+//
+// chainFirstReaderIOKW
+//
+
+// $ExpectType ReaderTask<R1 & R2, number>
+pipe(
+  _.of<R1, number>(1),
+  _.chainFirstReaderIOKW(() => RIO.of<R2, boolean>(true))
+)
+
+//
+// chainFirstReaderIOK
+//
+
+// $ExpectType ReaderTask<R1, number>
+pipe(
+  _.of<R1, number>(1),
+  _.chainFirstReaderIOK(() => RIO.of(true))
+)
+
+pipe(
+  _.of<R1, number>(1), // $ExpectError
+  _.chainFirstReaderIOK(() => RIO.of<R2, boolean>(true))
+)
+
 //
 // Do
 //

src/ReaderTask.ts

@@ -34,6 +34,7 @@ import { MonadTask2 } from './MonadTask'
 import { Monoid } from './Monoid'
 import { Pointed2 } from './Pointed'
 import * as R from './Reader'
+import * as RIO from './ReaderIO'
 import * as RT from './ReaderT'
 import { ReadonlyNonEmptyArray } from './ReadonlyNonEmptyArray'
 import { Semigroup } from './Semigroup'
@@ -43,6 +44,7 @@ import * as T from './Task'
 // model
 // -------------------------------------------------------------------------------------
 
+import ReaderIO = RIO.ReaderIO
 import Task = T.Task
 
 /**
@@ -75,6 +77,12 @@ export const fromTask: FromTask2<URI>['fromTask'] = /*#__PURE__*/ R.of
  */
 export const fromIO: FromIO2<URI>['fromIO'] = /*#__PURE__*/ flow(T.fromIO, fromTask)
 
+/**
+ * @category natural transformations
+ * @since 2.13.0
+ */
+export const fromReaderIO: <R, A>(fa: ReaderIO<R, A>) => ReaderTask<R, A> = R.map(T.fromIO)
+
 // -------------------------------------------------------------------------------------
 // combinators
 // -------------------------------------------------------------------------------------
@@ -487,6 +495,50 @@ export const chainFirstReaderKW: <A, R1, B>(
   f: (a: A) => R.Reader<R1, B>
 ) => <R2>(ma: ReaderTask<R2, A>) => ReaderTask<R1 & R2, A> = chainFirstReaderK as any
 
+/**
+ * @category combinators
+ * @since 2.13.0
+ */
+export const fromReaderIOK = <A extends ReadonlyArray<unknown>, R, B>(
+  f: (...a: A) => ReaderIO<R, B>
+): ((...a: A) => ReaderTask<R, B>) => (...a) => fromReaderIO(f(...a))
+
+/**
+ * Less strict version of [`chainReaderIOK`](#chainreaderiok).
+ *
+ * @category combinators
+ * @since 2.13.0
+ */
+export const chainReaderIOKW: <A, R2, B>(
+  f: (a: A) => ReaderIO<R2, B>
+) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, B> = (f) => chainW(fromReaderIOK(f))
+
+/**
+ * @category combinators
+ * @since 2.13.0
+ */
+export const chainReaderIOK: <A, R, B>(
+  f: (a: A) => ReaderIO<R, B>
+) => (ma: ReaderTask<R, A>) => ReaderTask<R, B> = chainReaderIOKW
+
+/**
+ * Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
+ *
+ * @category combinators
+ * @since 2.13.0
+ */
+export const chainFirstReaderIOKW: <A, R2, B>(
+  f: (a: A) => ReaderIO<R2, B>
+) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A> = (f) => chainFirstW(fromReaderIOK(f))
+
+/**
+ * @category combinators
+ * @since 2.13.0
+ */
+export const chainFirstReaderIOK: <A, R, B>(
+  f: (a: A) => ReaderIO<R, B>
+) => (ma: ReaderTask<R, A>) => ReaderTask<R, A> = chainFirstReaderIOKW
+
 /**
  * @category instances
  * @since 2.10.0

test/ReaderTask.ts

@@ -2,6 +2,7 @@ import { pipe, SK } from '../src/function'
 import * as I from '../src/IO'
 import { monoidString } from '../src/Monoid'
 import * as R from '../src/Reader'
+import * as RIO from '../src/ReaderIO'
 import * as _ from '../src/ReaderTask'
 import * as RA from '../src/ReadonlyArray'
 import { ReadonlyNonEmptyArray } from '../src/ReadonlyNonEmptyArray'
@@ -86,6 +87,10 @@ describe('ReaderTask', () => {
     U.deepStrictEqual(await _.fromReader(R.of(1))({})(), 1)
   })
 
+  it('fromReaderIO', async () => {
+    U.deepStrictEqual(await _.fromReaderIO(RIO.of(1))({})(), 1)
+  })
+
   // -------------------------------------------------------------------------------------
   // combinators
   // -------------------------------------------------------------------------------------
@@ -125,6 +130,31 @@ describe('ReaderTask', () => {
     U.deepStrictEqual(await pipe(_.of('a'), _.chain(f))({})(), 1)
   })
 
+  it('fromReaderIOK', async () => {
+    const f = (s: string) => RIO.of(s.length)
+    U.deepStrictEqual(await _.fromReaderIOK(f)('a')(undefined)(), 1)
+  })
+
+  it('chainReaderIOKW', async () => {
+    const f = (s: string) => RIO.of(s.length)
+    U.deepStrictEqual(await pipe(_.of('a'), _.chainReaderIOKW(f))({})(), 1)
+  })
+
+  it('chainReaderIOK', async () => {
+    const f = (s: string) => RIO.of(s.length)
+    U.deepStrictEqual(await pipe(_.of('a'), _.chainReaderIOK(f))(undefined)(), 1)
+  })
+
+  it('chainFirstReaderIOKW', async () => {
+    const f = (s: string) => RIO.of(s.length)
+    U.deepStrictEqual(await pipe(_.of('a'), _.chainFirstReaderIOKW(f))({})(), 'a')
+  })
+
+  it('chainFirstReaderIOK', async () => {
+    const f = (s: string) => RIO.of(s.length)
+    U.deepStrictEqual(await pipe(_.of('a'), _.chainFirstReaderIOK(f))({})(), 'a')
+  })
+
   // -------------------------------------------------------------------------------------
   // instances
   // -------------------------------------------------------------------------------------