fp-ts로 Typescript 함수형 프로그래밍 시작하기 3 (Semigroup)

*: (x: A, Y: A) => A

(x * y) * z = x * (y * z)

interface Semigroup<A> {
  concat: (x: A, y: A) => A;
}

/** number 타입의 곱셈 `Semigroup` */
export const semigroupProduct: Semigroup<number> = {
  concat: (x, y) => x * y,
};

/** number 타입의 덧셈 `Semigroup` */
const semigroupSum: Semigroup<number> = {
  concat: (x, y) => x + y,
};

const semigroupString: Semigroup<string> = {
  concat: (x, y) => x + y,
};

/** 항상 첫 번째 인자를 반환한다. */
function getFirstSemigroup<A = never>(): Semigroup<A> {
  return { concat: (x, y) => x };
}

/** 항상 두 번째 인자를 반환한다. */
function getLastSemigroup<A = never>(): Semigroup<A> {
  return { concat: (x, y) => y };
}

function getArraySemigroup<A = never>(): Semigroup<Array<A>> {
  return { concat: (x, y) => x.concat(y) };
}

function of<A>(a: A): Array<A> {
  return [a];
}

import { Ord } from 'fp-ts/lib/number';
import { max, min } from 'fp-ts/lib/Semigroup';

/** 2개의 값 중 작은 값을 반환한다.  */
const semigroupMin: Semigroup<number> = min(Ord);

/** 2개의 값 중 큰 값을 반환한다.  */
const semigroupMax: Semigroup<number> = max(Ord);

describe('Semigroup 인터페이스를 구현한 semigroupMin 인스턴스 테스트', () => {
  it('semigroupMin 인스턴스 concat 함수 테스트', () => {
    expect(semigroupMin.concat(2, 1)).toBe(1);
  });
});

describe('Semigroup 인터페이스를 구현한 semigroupMax 인스턴스 테스트', () => {
  it('semigroupMax 인스턴스 concat 함수 테스트', () => {
    expect(semigroupMax.concat(2, 1)).toBe(2);
  });
});

type Point = {
  x: number;
  y: number;
};

const semigroupPoint: Semigroup<Point> = {
  concat: (p1, p2) => ({
    x: semigroupSum.concat(p1.x, p2.x),
    y: semigroupSum.concat(p1.y, p2.y),
  }),
};

import { struct } from 'fp-ts/lib/Semigroup';

const semigroupPoint: Semigroup<Point> = struct({
  x: semigroupSum,
  y: semigroupSum,
});

type Vector = {
  from: Point;
  to: Point;
};

const semigroupVector: Semigroup<Vector> = struct({
  from: semigroupPoint,
  to: semigroupPoint,
});

import type { Semigroup } from 'fp-ts/lib/Semigroup';
import type { Point } from './semigroupPoint';
import { getSemigroup } from 'fp-ts/lib/function';
import { SemigroupAll } from 'fp-ts/lib/boolean';

/** `semigroupAll`은 결합 된 boolean Semigroup입니다. */
export const semigroupPredicate: Semigroup<
  (p: Point) => boolean
> = getSemigroup(SemigroupAll)<Point>();

const isPositiveX = (p: Point): boolean => p.x >= 0;
const isPositiveY = (p: Point): boolean => p.y >= 0;

const isPositiveXY = semigroupPredicate.concat(isPositiveX, isPositiveY);

describe('semigroupPredicate 인스턴스를 이용해 만든 isPositiveXY 테스트', () => {
  it('isPositiveXY 함수 테스트', () => {
    expect(isPositiveXY({ x: 1, y: 1 })).toBeTruthy();
    expect(isPositiveXY({ x: 1, y: -1 })).toBeFalsy();
    expect(isPositiveXY({ x: -1, y: 1 })).toBeFalsy();
    expect(isPositiveXY({ x: -1, y: -1 })).toBeFalsy();
  });
});

import { SemigroupSum, SemigroupProduct } from 'fp-ts/lib/number';
import { concatAll } from 'fp-ts/lib/Semigroup';

const sum = concatAll(SemigroupSum);
const product = concatAll(SemigroupProduct);

describe('concatAll, SemigroupSum를 사용한 sum 함수 테스트', () => {
  it('sum함수 테스트', () => {
    expect(sum(0)([1, 2, 3, 4])).toBe(10);
    expect(sum(10)([1, 2, 3, 4])).toBe(20);
  });
});

describe('concatAll, SemigroupProduct를 사용한 product 함수 테스트', () => {
  it('product함수 테스트', () => {
    expect(product(1)([1, 2, 3, 4])).toBe(24);
    expect(product(10)([1, 2, 3, 4])).toBe(240);
  });
});

import { SemigroupSum } from 'fp-ts/lib/number';
import { getApplySemigroup } from 'fp-ts/lib/Apply';
import { Apply } from 'fp-ts/lib/Option';

const S = getApplySemigroup(Apply)(SemigroupSum);

describe('Option타입을 지원하는 appliedSemigroup 인스턴스 테스트', () => {
  let result;
  it('appliedSemigroup 테스트 (some + none)', () => {
    result = appliedSemigroup.concat(some(1), none);
    expect(result).toBe(none);
    expect(isNone(result)).toBeTruthy();
  });
  it('appliedSemigroup 테스트 (some + some)', () => {
    result = appliedSemigroup.concat(some(1), some(2));
    expect(result).toMatchObject(some(3));
    expect(isSome(result)).toBeTruthy();
  });
});

interface Customer {
  name: string;
  favouriteThings: Array<string>;
  registeredAt: number;
  lastUpdatedAt: number;
  hasMadePurchase: boolean;
}

import { Semigroup, struct, max, min } from 'fp-ts/lib/Semigroup';
import { getMonoid } from 'fp-ts/lib/Array';
import { Ord } from 'fp-ts/lib/number';
import { contramap } from 'fp-ts/lib/Ord';
import { SemigroupAny } from 'fp-ts/lib/boolean';

const semigroupCustomer: Semigroup<Customer> = struct({
  // 더 긴 이름을 유지한다.
  name: max(contramap((s: string) => s.length)(Ord)),
  // 항목을 축적한다.
  // getMonoid는 Semigroup을 위한 `Array<string>`을 반환한다.
  favouriteThings: getMonoid<string>(),
  // 가장 이전의 날짜를 유지한다.
  registeredAt: min(Ord),
  // 가장 최근의 날짜를 유지한다.
  lastUpdatedAt: max(Ord),
  // 분리된 boolean Semigroup
  hasMadePurchase: SemigroupAny,
});

describe('Semigroup 인터페이스를 구현한 semigroupCustomer 인스턴스 테스트', () => {
  it('semigroupCustomer 인스턴스 concat 함수 테스트', () => {
    expect(
      semigroupCustomer.concat(
        {
          name: 'Giulio',
          favouriteThings: ['math', 'climbing'],
          registeredAt: new Date(2018, 1, 20).getTime(),
          lastUpdatedAt: new Date(2018, 2, 18).getTime(),
          hasMadePurchase: false,
        },
        {
          name: 'Giulio Canti',
          favouriteThings: ['functional programming'],
          registeredAt: new Date(2018, 1, 22).getTime(),
          lastUpdatedAt: new Date(2018, 2, 9).getTime(),
          hasMadePurchase: true,
        }
      )
    ).toMatchObject({
      name: 'Giulio Canti',
      favouriteThings: ['math', 'climbing', 'functional programming'],
      registeredAt: new Date(2018, 1, 20).getTime(),
      lastUpdatedAt: new Date(2018, 2, 18).getTime(),
      hasMadePurchase: true,
    });
  });
});