fp-pack 0.6.0 → 0.7.0

package/src/implement/async/pipeAsyncSideEffect.ts

@@ -5,6 +5,7 @@ import SideEffect, { isSideEffect } from '../composition/sideEffect';
 type MaybeSideEffect<T> = T | SideEffect<any>;
 type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
 type AsyncOrSync<A, R> = (a: A) => MaybeSideEffect<R> | Promise<MaybeSideEffect<R>>;
+type ZeroFn<R> = () => MaybeSideEffect<R> | Promise<MaybeSideEffect<R>>;
 type PipeInput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [
   AsyncOrSync<infer A, any>,
   ...AsyncOrSync<any, any>[]
@@ -29,6 +30,79 @@ type PipeAsyncSideEffectFrom<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[
 function pipeAsyncSideEffect<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]>(
   ...funcs: Fns
 ): PipeAsyncSideEffectFrom<Fns>;
+function pipeAsyncSideEffect<R>(ab: ZeroFn<R>): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, H, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, H, I, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, I>,
+  ij: AsyncOrSync<Awaited<I>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, H, I, J, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, I>,
+  ij: AsyncOrSync<Awaited<I>, J>,
+  jk: AsyncOrSync<Awaited<J>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
 function pipeAsyncSideEffect<A, R>(
   ab: AsyncOrSync<A, R>
 ): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;

package/src/implement/composition/compose.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import compose from './compose';
+import from from './from';
 
 describe('compose', () => {
   it('applies functions right-to-left', () => {
@@ -27,4 +28,17 @@ describe('compose', () => {
     expect(fn(4)).toBe(16);
   });
 
+  it('supports zero-arity tail functions', () => {
+    const addOne = (n: number) => n + 1;
+    const fn = compose(addOne, () => 2);
+    expect(fn()).toBe(3);
+  });
+
+  it('supports from() as a constant source', () => {
+    const addOne = (n: number) => n + 1;
+    const fn = compose(addOne, from(2));
+    expect(fn()).toBe(3);
+    expect(fn(10)).toBe(3);
+  });
+
 });

package/src/implement/composition/compose.ts

@@ -2,46 +2,158 @@
  * compose - 함수를 우→좌로 합성
  */
 
+import type { FromFn } from './from';
+
 type UnaryFn<A, R> = (a: A) => R;
+type ZeroFn<R> = () => R;
 type ComposeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [...UnaryFn<any, any>[], UnaryFn<infer A, any>]
   ? A
   : never;
-type ComposeChain<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, infer R>]
-  ? UnaryFn<A, R>
+type ComposeOutput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, infer R>]
+  ? R
   : Fns extends [UnaryFn<infer A, infer R>, ...infer Rest]
-    ? Rest extends [UnaryFn<R, any>, ...UnaryFn<any, any>[]]
-      ? ComposeChain<Rest> extends UnaryFn<any, infer NextR>
-        ? UnaryFn<A, NextR>
+    ? Rest extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]
+      ? ComposeOutput<Rest> extends A
+        ? R
         : never
       : never
     : never;
-type Compose<Fns extends UnaryFn<any, any>[]> = (input: ComposeInput<Fns>) => ComposeChain<Fns> extends UnaryFn<
-  any,
-  infer R
->
-  ? R
-  : never;
+type Compose<Fns extends UnaryFn<any, any>[]> = (input: ComposeInput<Fns>) => ComposeOutput<Fns>;
+type ComposeFrom<Fns extends [...UnaryFn<any, any>[], FromFn<any>]> = (input?: ComposeInput<Fns>) => ComposeOutput<Fns>;
+
+function compose<R>(ab: ZeroFn<R>): () => R;
+function compose<B, R>(ab: UnaryFn<B, R>, bc: ZeroFn<B>): () => R;
+function compose<C, B, R>(ab: UnaryFn<B, R>, bc: UnaryFn<C, B>, cd: ZeroFn<C>): () => R;
+function compose<D, C, B, R>(ab: UnaryFn<B, R>, bc: UnaryFn<C, B>, cd: UnaryFn<D, C>, de: ZeroFn<D>): () => R;
+function compose<E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: ZeroFn<E>
+): () => R;
+function compose<F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: ZeroFn<F>
+): () => R;
+function compose<G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: ZeroFn<G>
+): () => R;
+function compose<H, G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: UnaryFn<H, G>,
+  hi: ZeroFn<H>
+): () => R;
+function compose<I, H, G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: UnaryFn<H, G>,
+  hi: UnaryFn<I, H>,
+  ij: ZeroFn<I>
+): () => R;
+function compose<J, I, H, G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: UnaryFn<H, G>,
+  hi: UnaryFn<I, H>,
+  ij: UnaryFn<J, I>,
+  jk: ZeroFn<J>
+): () => R;
 
+function compose<Fns extends [...UnaryFn<any, any>[], FromFn<any>]>(...funcs: Fns): ComposeFrom<Fns>;
 function compose<A, R>(ab: UnaryFn<A, R>): (a: A) => R;
-function compose<A, B, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, R>): (a: A) => R;
-function compose<A, B, C, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): (a: A) => R;
+function compose<A, B, R>(ab: UnaryFn<B, R>, bc: UnaryFn<A, B>): (a: A) => R;
+function compose<A, B, C, R>(ab: UnaryFn<C, R>, bc: UnaryFn<B, C>, cd: UnaryFn<A, B>): (a: A) => R;
 function compose<A, B, C, D, R>(
-  ab: UnaryFn<A, B>,
-  bc: UnaryFn<B, C>,
-  cd: UnaryFn<C, D>,
-  de: UnaryFn<D, R>
+  ab: UnaryFn<D, R>,
+  bc: UnaryFn<C, D>,
+  cd: UnaryFn<B, C>,
+  de: UnaryFn<A, B>
 ): (a: A) => R;
 function compose<A, B, C, D, E, R>(
-  ab: UnaryFn<A, B>,
-  bc: UnaryFn<B, C>,
+  ab: UnaryFn<E, R>,
+  bc: UnaryFn<D, E>,
   cd: UnaryFn<C, D>,
+  de: UnaryFn<B, C>,
+  ef: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, R>(
+  ab: UnaryFn<F, R>,
+  bc: UnaryFn<E, F>,
+  cd: UnaryFn<D, E>,
+  de: UnaryFn<C, D>,
+  ef: UnaryFn<B, C>,
+  fg: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, R>(
+  ab: UnaryFn<G, R>,
+  bc: UnaryFn<F, G>,
+  cd: UnaryFn<E, F>,
   de: UnaryFn<D, E>,
-  ef: UnaryFn<E, R>
+  ef: UnaryFn<C, D>,
+  fg: UnaryFn<B, C>,
+  gh: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, H, R>(
+  ab: UnaryFn<H, R>,
+  bc: UnaryFn<G, H>,
+  cd: UnaryFn<F, G>,
+  de: UnaryFn<E, F>,
+  ef: UnaryFn<D, E>,
+  fg: UnaryFn<C, D>,
+  gh: UnaryFn<B, C>,
+  hi: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, H, I, R>(
+  ab: UnaryFn<I, R>,
+  bc: UnaryFn<H, I>,
+  cd: UnaryFn<G, H>,
+  de: UnaryFn<F, G>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<D, E>,
+  gh: UnaryFn<C, D>,
+  hi: UnaryFn<B, C>,
+  ij: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: UnaryFn<J, R>,
+  bc: UnaryFn<I, J>,
+  cd: UnaryFn<H, I>,
+  de: UnaryFn<G, H>,
+  ef: UnaryFn<F, G>,
+  fg: UnaryFn<E, F>,
+  gh: UnaryFn<D, E>,
+  hi: UnaryFn<C, D>,
+  ij: UnaryFn<B, C>,
+  jk: UnaryFn<A, B>
 ): (a: A) => R;
 
 function compose<Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): Compose<Fns>;
 function compose(...funcs: Array<UnaryFn<any, any>>): (input: any) => any;
-function compose(...funcs: Array<(input: any) => any>) {
+function compose(...funcs: Array<(...args: any[]) => any>) {
   return (value: any) => funcs.reduceRight((acc, fn) => fn(acc), value);
 }
 

package/src/implement/composition/compose.type-test.ts

@@ -0,0 +1,109 @@
+import compose from './compose';
+import from from './from';
+
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+  ? true
+  : false;
+type Expect<T extends true> = T;
+
+export const pureCompose = compose(
+  (value: string) => `n:${value}`,
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1
+);
+
+type PureComposeExpected = (input: number) => string;
+export type ComposePureIsStrict = Expect<Equal<typeof pureCompose, PureComposeExpected>>;
+
+export const pureComposeSix = compose(
+  (value: number) => `n:${value}`,
+  (value: number) => value + 1,
+  (value: string) => value.length,
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1
+);
+
+type PureComposeSixExpected = (input: number) => string;
+export type ComposePureSixIsStrict = Expect<Equal<typeof pureComposeSix, PureComposeSixExpected>>;
+
+export const pureComposeTen = compose(
+  (value: string) => `n:${value}`,
+  (value: string) => value.padStart(4, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value + 1,
+  (value: string) => value.length,
+  (value: string) => value.padStart(3, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1,
+  (value: number) => value + 1
+);
+
+type PureComposeTenExpected = (input: number) => string;
+export type ComposePureTenIsStrict = Expect<Equal<typeof pureComposeTen, PureComposeTenExpected>>;
+
+export const composeZero = compose(
+  (value: number) => value + 1,
+  (value: number) => value * 2,
+  () => 1
+);
+
+type ComposeZeroExpected = () => number;
+export type ComposeZeroIsStrict = Expect<Equal<typeof composeZero, ComposeZeroExpected>>;
+
+export const composeZeroValue = composeZero();
+
+type ComposeZeroValueExpected = number;
+export type ComposeZeroValueIsStrict = Expect<Equal<typeof composeZeroValue, ComposeZeroValueExpected>>;
+
+export const composeFromNoInput = compose(from(1));
+
+type ComposeFromNoInputExpected = (input?: unknown) => number;
+export type ComposeFromNoInputIsStrict = Expect<Equal<typeof composeFromNoInput, ComposeFromNoInputExpected>>;
+
+export const composeFromNoInputValue = composeFromNoInput();
+
+type ComposeFromNoInputValueExpected = number;
+export type ComposeFromNoInputValueIsStrict = Expect<
+  Equal<typeof composeFromNoInputValue, ComposeFromNoInputValueExpected>
+>;
+
+export const composeFromNoInputValueWithArg = composeFromNoInput('input');
+
+type ComposeFromNoInputValueWithArgExpected = number;
+export type ComposeFromNoInputValueWithArgIsStrict = Expect<
+  Equal<typeof composeFromNoInputValueWithArg, ComposeFromNoInputValueWithArgExpected>
+>;
+
+export const composeFromTen = compose(
+  (value: string) => `n:${value}`,
+  (value: string) => value.padStart(4, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value + 1,
+  (value: string) => value.length,
+  (value: string) => value.padStart(3, '0'),
+  (value: number) => `${value}`,
+  (value: number) => value * 2,
+  (value: number) => value + 1,
+  from(1)
+);
+
+export const composeFromTenValue = composeFromTen('input');
+
+type ComposeFromTenValueExpected = string;
+export type ComposeFromTenValueIsStrict = Expect<Equal<typeof composeFromTenValue, ComposeFromTenValueExpected>>;
+
+export const composeFromTenValueNoInput = composeFromTen();
+
+type ComposeFromTenValueNoInputExpected = string;
+export type ComposeFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof composeFromTenValueNoInput, ComposeFromTenValueNoInputExpected>
+>;
+
+// Negative cases: input required when not using from/zero-arity.
+// @ts-expect-error input required for unary compose
+pureCompose();
+// @ts-expect-error input required for direct compose call
+compose((value: number) => value + 1)();

package/src/implement/composition/compose.util.type-test.ts

@@ -0,0 +1,128 @@
+import compose from './compose';
+import filter from '../array/filter';
+import flattenDeep from '../array/flattenDeep';
+import map from '../array/map';
+import sum from '../math/sum';
+import gt from '../equality/gt';
+import when from '../control/when';
+import ifElse from '../control/ifElse';
+import log from '../debug/log';
+import tap from './tap';
+import prop from '../object/prop';
+import mergeAll from '../object/mergeAll';
+import getOrElse from '../nullable/getOrElse';
+import mapMaybe from '../nullable/mapMaybe';
+import join from '../string/join';
+import trim from '../string/trim';
+import toUpper from '../string/toUpper';
+import streamFilter from '../../stream/filter';
+import streamMap from '../../stream/map';
+import streamRange from '../../stream/range';
+import streamReduce from '../../stream/reduce';
+import streamToArray from '../../stream/toArray';
+
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+  ? true
+  : false;
+type Expect<T extends true> = T;
+
+type User = {
+  name?: string;
+};
+
+type TagOwner = {
+  tags?: Array<string | null>;
+};
+
+type Config = {
+  value?: number;
+};
+
+const getName = prop('name') as (user: User) => string | undefined;
+const getTags = prop('tags') as (owner: TagOwner) => Array<string | null> | undefined;
+const mergeConfig = mergeAll as (configs: Config[]) => Config;
+const getValue = prop('value') as (config: Config) => number | undefined;
+const streamMapNumber = streamMap((value: number) => value + 1) as (iterable: Iterable<number>) => IterableIterator<number>;
+const streamFilterNumber = streamFilter((value: number) => value > 1) as (
+  iterable: Iterable<number>
+) => IterableIterator<number>;
+const streamReduceNumber = streamReduce((acc: number, value: number) => acc + value, 0) as (
+  iterable: Iterable<number>
+) => number;
+const streamMapAsyncNumber = streamMap(async (value: number) => value + 1) as (
+  iterable: Iterable<number>
+) => IterableIterator<Promise<number>>;
+const whenPositive = when<number>(gt(0), (value) => value + 1);
+
+export const composeArrayControlString = compose(
+  log('total'),
+  toUpper,
+  trim,
+  (value: number) => `${value}`,
+  when(gt(10), (value) => value + 1),
+  sum,
+  map((value: number) => value * 2),
+  filter(gt(1)),
+  flattenDeep<number>
+);
+
+type ComposeArrayControlStringExpected = (input: any[]) => string;
+export type ComposeArrayControlStringIsStrict = Expect<
+  Equal<typeof composeArrayControlString, ComposeArrayControlStringExpected>
+>;
+
+export const composeObjectNullableControl = compose(
+  tap((value: string) => value.length),
+  ifElse(
+    (value: string) => value.length > 0,
+    toUpper,
+    () => 'UNKNOWN'
+  ),
+  getOrElse(''),
+  getName
+);
+
+type ComposeObjectNullableControlExpected = (input: User) => string;
+export type ComposeObjectNullableControlIsStrict = Expect<
+  Equal<typeof composeObjectNullableControl, ComposeObjectNullableControlExpected>
+>;
+
+export const composeTags = compose(
+  join('|'),
+  map((tag: string) => tag.toUpperCase()),
+  mapMaybe((tag: string | null) => (tag ? tag.trim() : null)),
+  getOrElse<Array<string | null>>([]),
+  getTags
+);
+
+type ComposeTagsExpected = (input: TagOwner) => string;
+export type ComposeTagsIsStrict = Expect<Equal<typeof composeTags, ComposeTagsExpected>>;
+
+export const composeConfigValue = compose(
+  whenPositive,
+  getOrElse(0),
+  getValue,
+  mergeConfig
+);
+
+type ComposeConfigValueExpected = (input: Config[]) => number;
+export type ComposeConfigValueIsStrict = Expect<Equal<typeof composeConfigValue, ComposeConfigValueExpected>>;
+
+export const composeStreamSync = compose(
+  streamReduceNumber,
+  streamFilterNumber,
+  streamMapNumber,
+  (end: number) => streamRange(0, end)
+);
+
+type ComposeStreamSyncExpected = (input: number) => number;
+export type ComposeStreamSyncIsStrict = Expect<Equal<typeof composeStreamSync, ComposeStreamSyncExpected>>;
+
+export const composeStreamToArray = compose(
+  streamToArray,
+  streamMapAsyncNumber,
+  (end: number) => streamRange(0, end)
+);
+
+type ComposeStreamToArrayExpected = (input: number) => Promise<number[]>;
+export type ComposeStreamToArrayIsStrict = Expect<Equal<typeof composeStreamToArray, ComposeStreamToArrayExpected>>;

package/src/implement/composition/index.ts

@@ -12,6 +12,7 @@ export { default as constant } from './constant';
 export { default as from } from './from';
 export type { FromFn } from './from';
 export { default as tap } from './tap';
+export { default as tap0 } from './tap0';
 export { default as once } from './once';
 export { default as memoize } from './memoize';
 export { default as SideEffect } from './sideEffect';