feat(semigroup): add partial semigroup

Author: JalilArfaoui

docs/modules/Semigroup.ts.md

@@ -50,6 +50,7 @@ Added in v2.0.0
 
 - [combinators](#combinators)
   - [intercalate](#intercalate)
+  - [partial](#partial)
   - [reverse](#reverse)
   - [struct](#struct)
   - [tuple](#tuple)
@@ -110,6 +111,39 @@ assert.strictEqual(S1.concat('a', 'b'), 'a + b')
 
 Added in v2.10.0
 
+## partial
+
+Given a struct of semigroups returns a semigroup for the struct, that can have optional keys.
+
+**Signature**
+
+```ts
+export declare const partial: <A>(
+  semigroups: { [K in keyof A]: Semigroup<A[K]> }
+) => Semigroup<{ readonly [K in keyof Partial<A>]: A[K] }>
+```
+
+**Example**
+
+```ts
+import { partial, last } from 'fp-ts/Semigroup'
+import * as S from 'fp-ts/string'
+
+interface Person {
+  readonly name: string
+  readonly age: number
+}
+
+const S1 = partial<Person>({
+  name: S.Semigroup,
+  age: last(),
+})
+
+assert.deepStrictEqual(S1.concat({ name: 'first', age: 42 }, { name: 'second' }), { name: 'firstsecond', age: 42 })
+```
+
+Added in v2.10.0
+
 ## reverse
 
 The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.

src/Semigroup.ts

@@ -158,6 +158,46 @@ export const struct = <A>(
   }
 })
 
+/**
+ * Given a struct of semigroups returns a semigroup for the struct, that can have optional keys.
+ *
+ * @example
+ * import { partial, last } from 'fp-ts/Semigroup'
+ * import * as S from 'fp-ts/string'
+ *
+ * interface Person {
+ *   readonly name: string
+ *   readonly age: number
+ * }
+ *
+ * const S1 = partial<Person>({
+ *   name: S.Semigroup,
+ *   age: last()
+ * })
+ *
+ * assert.deepStrictEqual(S1.concat({ name: "first", age: 42 }, { name: "second" }), { name: "firstsecond", age: 42 })
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+export const partial = <A>(
+  semigroups: { [K in keyof A]: Semigroup<A[K]> }
+): Semigroup<{ readonly [K in keyof Partial<A>]: A[K] }> => ({
+  concat: (first, second) => {
+    const r: A = {} as any
+    for (const k in semigroups) {
+      if (_.has.call(semigroups, k)) {
+        if (_.has.call(first, k) && _.has.call(second, k)) {
+          r[k] = semigroups[k].concat(first[k], second[k])
+        } else if (_.has.call(first, k) || _.has.call(second, k)) {
+          r[k] = second[k] || first[k]
+        }
+      }
+    }
+    return r
+  }
+})
+
 /**
  * Given a tuple of semigroups returns a semigroup for the tuple.
  *

test/Semigroup.ts

@@ -57,6 +57,15 @@ describe('Semigroup', () => {
     U.deepStrictEqual(S.concat({}, {}), {})
   })
 
+  it('partial', () => {
+    // should ignore non own properties
+    const S1 = _.partial(Object.create({ a: 1 }))
+    U.deepStrictEqual(S1.concat({}, {}), {})
+
+    const S2 = _.partial({ a: S.Semigroup, b: N.SemigroupSum, c: B.SemigroupAll, d: S.Semigroup })
+    U.deepStrictEqual(S2.concat({ a: 'first', b: 12 }, { b: 2, c: true }), { a: 'first', b: 14, c: true })
+  })
+
   it('semigroupAll', () => {
     // tslint:disable-next-line: deprecation
     const S = _.semigroupAll