📕[책] 쏙쏙 들어오는 함수형 코딩 - 33,34

371p ~ 394p

요약

😇 "조회하고 변경하고 설정하는 것을 update()로 교체하기" 리팩터링

/// Step 1: Identify get, modify, set

function halveField(item, field) {
  var value = item[field];		// get
  var newValue = value / 2;		// modify
  var newItem = objectSet(item, field, newValue);	// set
  return newItem;
}

/// Step 2: Replace with call to update()

function halveField(item, field) {
  return update(item, field, function(value) {
    return value / 2;
  });
}

😇 중첩된 데이터에 update() 사용하기

• 같은 방식으로 리팩터링을 여러번 하면 된다.

function incrementSize(item) {
  var options = item.options;	// 1. 조회
  var size = options.size;		// 2. 조회
  var newSize = size + 1;		// 2. 변경
  var newOptions = objectSet(options, 'size', newSize);	// 2. 설정 // 1. 변경
  var newItem = objectSet(item, 'options', newOptions);	// 1. 설정
  return newItem;
}

/// Refactored

function incrementSize(item) {
  var options = item.options;	// 1. 조회
  var newOptions = update(options, 'size', increment);	// here // 1. 변경
  var newItem = objectSet(item, 'options', newOptions);	// 1. 설정
  return newItem;
}

/// Refactored twice

function incrementSize(item) {
  return update(item, 'options', function(options) {	// here
    return update(options, 'size', increment);
  });
}

😇 update2() 도출하기

• 위의 결과와, 암묵적 인자를 드러내기 리팩터링을 이용해,
  2번 중첩된 데이터에 사용 가능한 update2()를 도출할 수 있다.

function incrementSize(item) {	// 1. "Size" -> (option)
  return update(item, 'options', function(options) {
    return update(options, 'size', increment);	// 1. "'size'" -> (option)
  });
}

/// 1. With explicit option argument

function incrementOption(item, option) {	// 2. "increment" -> (modify)
  return update(item, 'options', function(options) {
    return update(options, option, increment);	// 2. "increment" -> (modify)
  });
}

/// 2. With explicit modify argument

function updateOption(item, option, modify) {	// 3-1. "Option" -> (key1)	// 3-2. "option" -> (key2)
  return update(item, 'options', function(options) {	// 3-1. "'options'" -> (key1)		
    return update(options, option, modify);		// 3-2. "option" -> (key2)
  });
}

/// 3. With explicit argument

function update2(object, key1, key2, modify) {
  return update(object, key1, function(value1) {
    return update(value1, key2, modify);
  });
}

/// cc. Original

function incrementSize(item) {
  var options = item.options;
  var size = options.size;
  var newSize = size + 1;
  var newOptions = objectSet(options, 'size', newSize);
  var newItem = objectSet(item, 'options', newOptions);
  return newItem;
}

😇 update3() 도출하기

• 역시나 같은 방법.

function update3(object, key1, key2, key3, modify) {
  return update(object, key1, function(object2) {
    return update2(object2, key2, key3, modify);
  });
}

😇 nestedUpdate() 도출하기

• 재귀 호출 (recursive call)을 활용한다.

function nestedUpdate(object, keys, modify) {
  if(keys.length === 0)	// base case
    return modify(object);
  
  var key1 = keys[0];
  var restOfKeys = drop_first(keys);
  return update(object, key1, function(value1) {
    return nestedUpdate(value1, restOfKeys, modify);
  });
}

😇 깊이 중첩된 데이터에 추상화 벽 사용하기

• 깊이 중첩된 구조에 nestedUpdate()를 쓰려면 긴 key 경로 배열이 필요하다.

• 이것이 너무 길면 중간에 있는 객체들이 어떤 키를 가졌는지, 구조를 기억하기 어렵다.

• 예를 들어, 아래와 같은 코드가 있다.

  httpGet("http://my-blog.com/api/category/blog", function(blogCategory) {
    renderCategory(nestedUpdate(blogCategory, ['posts', '12', 'author', 'name'], capitalize));
  });

  api로 가져온 값 blogCategory 를 콜백을 통해 처리하는 코드이다.
  이 코드는 다음과 같은 이해를 함축하고 있다.

  1. blogCategory는 posts key 아래 "블로그 글"을 담고 있는 구조이다.
  2. 각 "블로그 글"은 ID(12) 를 통해 접근할 수 있다.
  3. "블로그 글"은 author key 아래 "글쓴이"를 담고 있는 구조이다.
  4. "글쓴이"는 name key 아래 "사용자 이름"을 담고 있는 구조이다.

  경로만 보고, 이 모든 정보를 기억하기는 쉽지 않다.

• 그래서, 추상화 벽을 만들고 의미있는 이름을 붙여, 구현을 감추고 기억해야 할 점을 줄일 수 있다.

• 다시 말해, 추상화 벽에 존재하는 함수 자신이 해당 구현을 본문에 품고 있으면 된다.

  1. 주어진 ID로 "블로그 글"을 변경하는 함수를 만든다.

  function updatePostById(category, id, modifyPost) {
    return nestedUpdate(category, ['posts', id], modifyPost);	// modifyPost // 블로그 글 구조에 대해서는 콜백에 맡긴다. -> 2.
    				     // key 경로 배열에 함축된 category의 구조는 추상화 벽 뒤로 숨긴다.
                       // 즉, 이 함수 자신이 여기(본문)에 품는다.
  }

  2. 글쓴이를 수정하는 함수를 만든다.

  function updateAuthor(post, modifyUser) {
    return update(post, 'author', modifyUser);	// modifyUser // 사용자 구조에 대해서는 콜백에 맡긴다. -> 3.
               // 블로그 글의 구조는 이 함수 자신이 여기(본문)에 품는다.
  }

  3. 사용자 이름을 대문자로 바꾸는 함수를 만든다.

  function capitalizeName(user) {
    return update(user, 'name', capitalize);
               // 사용자의 구조는 이 함수 자신이 여기(본문)에 품는다.    
  }

  4. 합치기

  updatePostById(blogCategory, '12', function(post) {
    return updateAuthor(post, capitalizeUserName);
  });

• 기억해야 할 사항이 간단해 졌다.

  • category 안에 블로그 글이 있다는 사실만 알아도 된다. 어떤 키에 어떻게 들어있는지 몰라도 된다.
  • 블로그 글에 글쓴이가 하나 있다는 사실만 알아도 된다. 어떤 키에 어떻게 들어있는지 몰라도 된다.

😇 고차 함수 청리

• 배열 처리
  • forEach(), map(), filter(), reduce()
• 중첩된 데이터 처리
  • update(), nestedUpdate()
• copy-on-write 원칙 적용
  • withArrayCopy(), withObjectCopy()
• try-catch 로깅 규칙 코드화
  • wrapLogging()

발췌

메모

다음 시간부턴 드디어 분산 시스템에 대해서 알아보자.