시니어 개발자가 ChatGPT와 페어프로그래밍하는 법 (feat. DEVIEW 2023 코드 구현하기)

class Either {
  static left(value) {
    return new Left(value);
  }

  static right(value) {
    return new Right(value);
  }

  // 이 메서드는 서브클래스에서 구현해야 합니다.
  map() {
    throw new Error('Not implemented');
  }

  // 이 메서드는 서브클래스에서 구현해야 합니다.
  flatMap() {
    throw new Error('Not implemented');
  }
}

class Left extends Either {
  constructor(value) {
    super();
    this.value = value;
  }

  map() {
    return this;
  }

  flatMap() {
    return this;
  }
}

class Right extends Either {
  constructor(value) {
    super();
    this.value = value;
  }

  map(fn) {
    return new Right(fn(this.value));
  }

  flatMap(fn) {
    return fn(this.value);
  }
}

abstract class Either<L, R> {
  static left<L, R>(value: L): Either<L, R> {
    return new Left(value);
  }

  static right<L, R>(value: R): Either<L, R> {
    return new Right(value);
  }

  abstract map<R2>(fn: (value: R) => R2): Either<L, R2>;
  abstract flatMap<R2>(fn: (value: R) => Either<L, R2>): Either<L, R2>;
}

class Left<L, R> extends Either<L, R> {
  constructor(private readonly value: L) {
    super();
  }

  map<R2>(): Either<L, R2> {
    return this;
  }

  flatMap<R2>(): Either<L, R2> {
    return this;
  }

  getValue(): L {
    return this.value;
  }
}

class Right<L, R> extends Either<L, R> {
  constructor(private readonly value: R) {
    super();
  }

  map<R2>(fn: (value: R) => R2): Either<L, R2> {
    return new Right(fn(this.value));
  }

  flatMap<R2>(fn: (value: R) => Either<L, R2>): Either<L, R2> {
    return fn(this.value);
  }

  getValue(): R {
    return this.value;
  }
}

export { Either, Left, Right };

const { expect } = require('chai');
const { Either, Left, Right } = require('./either');

describe('Either', () => {
  describe('Left', () => {
    it('should not apply the function to the value when mapping', () => {
      const left = Either.left('error');
      const mappedLeft = left.map(value => value.toUpperCase());
      expect(mappedLeft).to.be.instanceOf(Left);
      expect(mappedLeft.value).to.equal('error');
    });
  });

  describe('Right', () => {
    it('should apply the function to the value when mapping', () => {
      const right = Either.right('success');
      const mappedRight = right.map(value => value.toUpperCase());
      expect(mappedRight).to.be.instanceOf(Right);
      expect(mappedRight.value).to.equal('SUCCESS');
    });
  });

  describe('Usage Example', () => {
    function divide(a, b) {
      if (b === 0) {
        return Either.left(new Error('Division by zero'));
      } else {
        return Either.right(a / b);
      }
    }

    it('should handle successful division', () => {
      const result = divide(4, 2);
      expect(result).to.be.instanceOf(Right);
      expect(result.value).to.equal(2);
    });

    it('should handle division by zero error', () => {
      const result = divide(4, 0);
      expect(result).to.be.instanceOf(Left);
      expect(result.value).to.be.instanceOf(Error);
      expect(result.value.message).to.equal('Division by zero');
    });
  });
});

abstract class CustomEither<L, R> extends Either<L, R> {
  // ... 기존 코드와 추가 기능 ...
}

class CustomRight<L, R> extends Right<L, R> {
  constructor(value: R) {
    super(value);
  }

  // ... 기존 코드와 추가 기능 ...
}

class CustomLeft<L, R> extends Left<L, R> {
  constructor(value: L) {
    super(value);
  }

  // ... 기존 코드와 추가 기능 ...
}

abstract class CustomEither<L, R> extends Either<L, R> {
  // 공통 로직을 정의하는 메서드
  abstract print(): void;
}

class CustomRight<L, R> extends Right<L, R> {
  constructor(value: R) {
    super(value);
  }

  // 공통 로직을 오버라이드하거나 확장하는 메서드
  print(): void {
    console.log(`CustomRight: ${this.getValue()}`);
  }
}

class CustomLeft<L, R> extends Left<L, R> {
  constructor(value: L) {
    super(value);
  }

  // 공통 로직을 오버라이드하거나 확장하는 메서드
  print(): void {
    console.log(`CustomLeft: ${this.getValue()}`);
  }
}

abstract class CustomEither<L, R> extends Either<L, R> {
  // 공통 로직을 정의하는 메서드
  abstract print(): void;
}

class CustomRight<L, R> extends CustomEither<L, R> {
  private value: R;

  constructor(value: R) {
    super();
    this.value = value;
  }

  isRight(): this is Right<L, R> {
    return true;
  }

  isLeft(): this is Left<L, R> {
    return false;
  }

  getValue(): R {
    return this.value;
  }

  // 공통 로직을 오버라이드하거나 확장하는 메서드
  print(): void {
    console.log(`CustomRight: ${this.getValue()}`);
  }
}

class CustomLeft<L, R> extends CustomEither<L, R> {
  private value: L;

  constructor(value: L) {
    super();
    this.value = value;
  }

  isRight(): this is Right<L, R> {
    return false;
  }

  isLeft(): this is Left<L, R> {
    return true;
  }

  getValue(): L {
    return this.value;
  }

  // 공통 로직을 오버라이드하거나 확장하는 메서드
  print(): void {
    console.log(`CustomLeft: ${this.getValue()}`);
  }
}

abstract class Either<L, R> {
  // ...

  abstract recover(fn: (value: L) => R): Either<L, R>;
}

class Left<L, R> extends Either<L, R> {
  // ...

  recover(fn: (value: L) => R): Either<L, R> {
    return new Right(fn(this.value));
  }
}

class Right<L, R> extends Either<L, R> {
  // ...

  recover(fn: (value: L) => R): Either<L, R> {
    return this;
  }
}

// 취소 가능한 비동기 작업 함수를 작성합니다.
function fetchWithAbort(url, signal) {
  return new Promise(async (resolve, reject) => {
    if (signal.aborted) {
      reject(new Error('Operation was aborted'));
      return;
    }

    try {
      const response = await fetch(url, { signal });
      resolve(response);
    } catch (error) {
      if (error.name === 'AbortError') {
        reject(new Error('Operation was aborted'));
      } else {
        reject(error);
      }
    }
  });
}

(async () => {
  const controller = new AbortController();
  const signal = controller.signal;

  // 작업을 실행합니다.
  const fetchData = fetchWithAbort('https://api.example.com/data', signal);

  // 일정 시간 후 작업을 취소합니다.
  setTimeout(() => {
    controller.abort();
  }, 3000); // 3초 후 작업 취소

  try {
    const response = await fetchData;
    console.log('Success:', response);
  } catch (error) {
    console.log('Error:', error.message);
  }
})();

class CancellationToken {
  constructor() {
    this.isCancelled = false;
  }

  cancel() {
    this.isCancelled = true;
  }
}

function createCancellablePromise(task, cancellationToken) {
  return new Promise(async (resolve, reject) => {
    try {
      const result = await task(cancellationToken);
      resolve(result);
    } catch (error) {
      reject(error);
    }
  });
}

// 예제 작업 함수
function exampleTask(cancellationToken) {
  return new Promise((resolve) => {
    const timer = setInterval(() => {
      if (cancellationToken.isCancelled) {
        clearInterval(timer);
        reject(new Error('Task cancelled'));
      }
    }, 100);

    setTimeout(() => {
      clearInterval(timer);
      if (!cancellationToken.isCancelled) {
        resolve('Task completed');
      }
    }, 5000);
  });
}

(async () => {
  const cancellationToken = new CancellationToken();
  const cancellablePromise = createCancellablePromise(exampleTask, cancellationToken);

  // 일정 시간 후 작업을 취소합니다.
  setTimeout(() => {
    cancellationToken.cancel();
  }, 3000); // 3초 후 작업 취소

  try {
    const result = await cancellablePromise;
    console.log('Success:', result);
  } catch (error) {
    console.log('Error:', error.message);
  }
})();

function createCancellablePromise(generatorFunc) {
  let generator;
  let isCancelled = false;

  const cancel = () => {
    isCancelled = true;
    if (generator) {
      generator.return();
    }
  };

  const runGenerator = async (gen) => {
    let result;
    try {
      while (!isCancelled) {
        result = gen.next();
        if (result.done) break;
        await result.value;
      }
    } catch (error) {
      throw error;
    }

    if (isCancelled) {
      throw new Error('Task cancelled');
    } else {
      return result.value;
    }
  };

  const promise = (async () => {
    generator = generatorFunc();
    return await runGenerator(generator);
  })();

  return { promise, cancel };
}

// 예제 작업 generator 함수
function* exampleTask() {
  yield new Promise((resolve) => setTimeout(resolve, 1000));
  console.log('Step 1');
  yield new Promise((resolve) => setTimeout(resolve, 1000));
  console.log('Step 2');
  yield new Promise((resolve) => setTimeout(resolve, 1000));
  console.log('Step 3');

  return 'Task completed';
}

(async () => {
  const { promise, cancel } = createCancellablePromise(exampleTask);

  // 일정 시간 후 작업을 취소합니다.
  setTimeout(() => {
    cancel();
  }, 2500); // 2.5초 후 작업 취소

  try {
    const result = await promise;
    console.log('Success:', result);
  } catch (error) {
    console.log('Error:', error.message);
  }
})();

function createCancellablePromise(promise) {
  let cancel;

  const cancelToken = new Promise((_, reject) => {
    cancel = () => {
      reject(new Error('Promise cancelled'));
    };
  });

  const cancellablePromise = Promise.race([promise, cancelToken]);

  return {
    promise: cancellablePromise,
    cancel,
  };
}

// 예제 작업 프로미스
function exampleTask() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('Task completed');
    }, 5000);
  });
}

(async () => {
  const { promise, cancel } = createCancellablePromise(exampleTask());

  // 일정 시간 후 작업을 취소합니다.
  setTimeout(() => {
    cancel();
  }, 3000); // 3초 후 작업 취소

  try {
    const result = await promise;
    console.log('Success:', result);
  } catch (error) {
    console.log('Error:', error.message);
  }
})();

class AbortToken {
    private _prevTokens: IAbortToken[] = [];

    abort(data: unknown): void {
        this._prevTokens.forEach(token => token.abort(data));
    }

    addPrevToken(token: IAbortToken): void {
        this._prevTokens.push(token);
    }
}

class AsyncAbortToken<T = unknown> extends AbortToken {
    private _defer = new Deferred<T>();

    constructor(private readonly _parentToken?: IAbortToken) {
        super();
    }

    get promise(): Promise<T> {
        return this._defer.promise;
    }

    abort(data: unknown): void {
        super.abort(data);

        if (this._parentToken) {
            this._parentToken.abort(data);
        }

        this._defer.reject({[aborted]: true, reason: data});
    }
}