feat: concatAll

src/concatAll.js

@@ -0,0 +1,35 @@
+import { concat, identical, identity, pipe, when, reduce } from 'ramda';
+
+import stubUndefined from './stubUndefined';
+
+const nullSemigroup = { concat: identity };
+
+/**
+ * Returns the result of concatenating all semigroups (such as arrays or strings) in passed foldable (such as an array).
+ * Returns undefined if empty foldable was passed.
+ *
+ * @func concatAll
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category List
+ * @sig [[a]] -> ([a] | undefined)
+ * @sig [String] -> (String | undefined)
+ * @sig Semigroup s => Foldable s f => f -> (s | undefined)
+ * @param {Foldable<Semigroup>} foldable foldable with semigroups to concatenate
+ * @return {Semigroup|null} concatenated semigroups, or undefined, if empty foldable was passed
+ * @see {@link http://ramdajs.com/docs/#defaultTo|defaultTo}
+ * @see {@link http://ramdajs.com/docs/#concat|concat}
+ * @see {@link http://ramdajs.com/docs/#unnest|unnest}
+ * @see {@link http://ramdajs.com/docs/#join|join}
+ * @example
+ *
+ * concatAll([[1], [2], [3]]); //=> [1, 2, 3]
+ * concatAll(['1', '2', '3']); //=> '123'
+ * concatAll([]); //=> undefined;
+ */
+const concatAll = pipe(
+  reduce(concat, nullSemigroup),
+  when(identical(nullSemigroup), stubUndefined)
+);
+
+export default concatAll;

src/index.d.ts

@@ -10,6 +10,15 @@ declare namespace RamdaAdjunct {
         ap<U>(fn: Apply<(t: T) => U>): Apply<U>;
     }
 
+    interface Foldable<T> {
+        reduce<Acc>(fn: (acc: Acc, val: T) => Acc, initAcc: Acc): Acc;
+    }
+
+    interface Semigroup {
+        // https://www.typescriptlang.org/docs/handbook/advanced-types.html#polymorphic-this-types
+        concat(other: this): this;
+    }
+
     interface Catamorphism<T> {
         cata<T1>(leftFn: (v: T1) => T, rightFn: (v: T1) => T): T;
     }
@@ -376,6 +385,12 @@ declare namespace RamdaAdjunct {
          */
         ensureArray<T>(value: T | T[]): T[];
 
+        /**
+         * Returns the result of concatenating all semigroups (such as arrays or strings) in passed foldable (such as an array).
+         * Returns null if empty foldable was passed.
+         */
+        concatAll<S extends Semigroup>(foldable: Foldable<S>): S | null;
+
         /**
          * Returns the result of concatenating the given lists or strings.
          */

src/index.js

@@ -95,6 +95,7 @@ export { default as reduceIndexed } from './reduceIndexed';
 export { default as pickIndexes } from './pickIndexes';
 export { default as list } from './list';
 export { default as ensureArray } from './ensureArray';
+export { default as concatAll } from './concatAll';
 export { default as concatRight } from './concatRight';
 export { default as reduceP } from './reduceP';
 export { default as reduceRightP } from './reduceRightP';

test/concatAll.js

@@ -0,0 +1,35 @@
+import { assert } from 'chai';
+import { NEL, Nil } from 'monet';
+
+import { concatAll } from '../src';
+import eq from './shared/eq';
+
+describe('concatAll', function() {
+  it('should concatenate arrays', function() {
+    eq(concatAll([[1], [2], [3]]), [1, 2, 3]);
+  });
+
+  it('should concatenate strings', function() {
+    eq(concatAll(['1', '2', '3']), '123');
+  });
+
+  it('should concatenate semigroups', function() {
+    eq(concatAll([NEL(1), NEL(2)]), NEL(1, NEL(2, Nil)));
+  });
+
+  it('should returns undefined if empty foldable was passed', function() {
+    eq(concatAll([]), undefined);
+  });
+
+  it('should throw if non-foldable is passed', function() {
+    assert.throws(() => concatAll(null), TypeError);
+  });
+
+  it('should throw if foldable contains non-semigroups', function() {
+    assert.throws(() => concatAll([1, 2, null, true]), TypeError);
+  });
+
+  it('should throw if foldable contains non-compatible semigroups', function() {
+    assert.throws(() => concatAll(['1', [1]]), TypeError);
+  });
+});