🏠 Curring

수학과 컴퓨터 과학에서 커링이란 다중 인수 을 갖는 함수를 단일 인수를 갖는 함수들의 함수열로 바꾸는 것을 말한다. 모지즈 쇤핑클에 의해 도입되었고, 이후 하스켈 커리에 의해 발전하였다. 예를 들어, 세 개의 인수를 가지는 함수를 커링하면 다음과 같은 세 개의 함수가 만들어진다.

커링은 튜플(tuple)에서 여러 개의 인수를 인수로 받는 함수를, 단 하나의 인수만 받고 나머지 튜플에서 원래 함수가 받을 추가 인수를 하나씩 받는 다른 함수를 반환하는 함수로 변환하는 프로세스입니다.

🌈 일반적인 커링

// 커링 변환을 하는 curry(f) 함수 (일반함수 ver1)
function curry(f) {
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}

// 커링 변환을 하는 curry(f) 함수 (화살표함수 ver)
const curry = f => a => b => f(a, b);

// f에 전달된 함수
const sum = (a, b) => a + b;

const curriedSum = curry(sum);

console.log(curriedSum(1)(2)); // 3


// 커링 변환을 하는 curry(f) 함수 (일반함수 ver2)
function curryLog(date) {
  return function(level) {
    return function(message) {
      console.log(`[${date.toLocaleTimeString()}] [${level}] ${message}`);
    };
  };
}
const now = new Date();
const logNow = curryLog(now);
const logError = logNow('ERROR');
const logWarning = logNow('WARNING');

logError('서버 연결 실패');
logWarning('메모리 사용량 높음');

예제 1의 함수는 다음의 순서로 동작 됩니다.

• curry(func)의 반환 값은 function(a) 형태입니다.
• curriedSum(1) 과 같은 함수가 호출되었을 때, 1은 렉시컬 환경에 저장이 되고 function(b)가 반환됩니다.
• 반환된 function(b) 함수가 2를 인수로 호출됩니다. 반환 값이 원래의 sum으로 넘겨져서 호출됩니다.
• 최종적으로 sum(1, 2) 가 호출되어 1 + 2인 3이 반환됩니다.

🌸 커링의 장점

• 특수화: 일반적인 함수로부터 특수화된 함수 생성 가능
• 조합성: 함수 조합이 더 쉬워짐
• 부분 적용: 일부 인자는 지금, 나머지는 나중에 적용 가능
• 가독성: 코드를 더 선언적으로 작성할 수 있음

커링은 일부 매개변수를 미리 설정하여 함수의 변형을 만들고 싶을 때 특히 유용합니다.

## 🌈 객체 데이터를 가져오는 커링

🌸 커링을 사용하지 않은 경우

const todos = [
  { id: 3, content: 'HTML', completed: false },
  { id: 2, content: 'CSS', completed: true },
  { id: 1, content: 'Javascript', completed: false }
];

const getTodosIdArr = todos => todos.map(todo => todo.id);
const getTodosContentArr = todos => todos.map(todo => todo.content);
const getTodosCompletedArr = todos => todos.map(todo => todo.completed);

console.log(getTodosIdArr(todos)); // [ 3, 2, 1 ]
console.log(getTodosContentArr(todos)); // [ 'HTML', 'CSS', 'Javascript' ]
console.log(getTodosCompletedArr(todos)); // [ false, true, false ]

일반적인 경우 코드를 작성하면 위와 같이 작성하게 됩니다. 여기에 커링을 적용하면 아래와 같이 코드를 작성할 수 있습니다.

🌸 커링 사용 후

const todos = [
  { id: 3, content: 'HTML', completed: false },
  { id: 2, content: 'CSS', completed: true },
  { id: 1, content: 'Javascript', completed: false }
];

const get = property => object => object[property];

const getId = get('id');
const getContent = get('content');
const getCompleted = get('completed');

const getTodosIdArr = todos => todos.map(getId);
const getTodosContentArr = todos => todos.map(getContent);
const getTodosCompletedArr = todos => todos.map(getCompleted);

console.log(getTodosIdArr(todos)); // [ 3, 2, 1 ]
console.log(getTodosContentArr(todos)); // [ 'HTML', 'CSS', 'Javascript' ]
console.log(getTodosCompletedArr(todos)); // [ false, true, false ]

커링을 사용하는 경우 인자의 순서는 중요한데, 앞에 존재하는 인자일 수록 변동가능성이 적고 뒤에 있는 인자일 수록 변동가능성이 높기 때문에 이 순서를 고려하여 코드를 설계하는 것이 중요하다.

🌸 커링의 활용

정보를 형식화하고 출력하는 로그함수가 있다고 가정하고, 실제 프로젝트에서 이러한 함수는 네트워크를 통해 로그를 보내는 것과 같은 많은 유용한 기능을 제공한다.

function log(date, importance, message) {
  alert(`[${date.getHours()}:${date.getMinutes()}] [${importance}] ${message}`);
}

lodash를 이용한 커링

log = _.curry(log);


log(new Date(), "DEBUG", "some debug"); // log(a, b, c)
log(new Date())("DEBUG")("some debug"); // log(a)(b)(c)

이 경우 둘다 정상적으로 작동이 됩니다.

이 이후 아래처럼 현재 시간으로 로그를 출력하는데 편리하도록 log함수를 작성해서 사용할 수 있습니다

// logNow는 log의 첫 번째 인수가 고정된 partial
const logNow = log(new Date());

logNow("INFO", "message"); // [HH:mm] INFO message

const debugNow = logNow("DEBUG");

debugNow("message"); // [HH:mm] DEBUG message

최종적으로 커링한 후에 잃은 것은 없으며, log는 아직 보통때처럼 호출할 수 있습니다. 더하여 partial함수를 쉽게 작성하여 고정 값들은 고정시켜 원하는 값만 도출되게하여 디버깅하는데 편리하게 해줍니다.

🌸 일반 함수와 주요 차이점

🐣 호출 방식:

• 일반 함수: func(a, b, c)
• 커링 함수: func(a)(b)(c)

🐣 재사용성:

• 일반 함수: 매번 모든 인자를 전달해야 함
• 커링 함수: 부분적으로 적용하여 새로운 함수 생성 가능

🐣 유연성:

• 일반 함수: 인자 순서가 고정됨
• 커링 함수: 인자를 단계별로 적용 가능
  
  

🌈 lodash를 통한 커링

lodash를 사용하면 좀 더 간단하게 커링을 구현할 수 있습니다.

🌸 lodash Syntax

_.curry(func, [arity=func.length])

🌸 lodash Arguments

func (Function) − The function to curry.

[arity=func.length] (number) − The arity of func.

🌸 lodash Output

(Function) − Returns the new curried function.

example 1.

const _ = require('lodash');
const getArray = function(a, b, c) {
   return [a, b, c];
};
 
const curried = _.curry(getArray);
console.log(curried(1)(2)(3));
console.log(curried(1, 2)(3));
console.log(curried(1, 2, 3));

lodash 라이브러리를 사용하여 curry함수를 사용자가 직접 정의할 필요 없이, _.curry를 사용하여 함수를 인수로 전달하여 curriedSum을 정의하였습니다.

example 2.

1) 문자열 처리 함수

const _ = require('lodash');

function concatenateStrings(a, b, c) {
  return `${a} ${b} ${c}`;
}

const curriedConcat = _.curry(concatenateStrings);

// 부분 적용 예제
const greet = curriedConcat('안녕하세요');
const greetTo = greet('김철수님');

console.log(greetTo('반갑습니다!')); // "안녕하세요 김철수님 반갑습니다!"

2) API 요청 함수

const _ = require('lodash');
const axios = require('axios');

function fetchAPI(baseURL, endpoint, params) {
  return axios.get(`${baseURL}/${endpoint}`, { params });
}

const curriedFetch = _.curry(fetchAPI);

// API 기본 설정
const fetchMyAPI = curriedFetch('https://api.example.com');

// 특정 엔드포인트에 대한 함수 생성
const getUser = fetchMyAPI('users');
const getProduct = fetchMyAPI('products');

// 사용 예
getUser({ id: 123 })
  .then(response => console.log(response.data))
  .catch(error => console.error(error));

getProduct({ category: 'electronics' })
  .then(response => console.log(response.data))
  .catch(error => console.error(error));

3) 인자 순서 변경 (placeholder 사용)

const _ = require('lodash');

function divide(a, b) {
  return a / b;
}

const curriedDivide = _.curry(divide);

// 일반적인 사용
const divideBy10 = curriedDivide(_, 10); // 첫 번째 인자 나중에 받음

console.log(divideBy10(100)); // 10 (100 / 10)

4) 객체 변환 함수

const _ = require('lodash');

function createUser(role, name, age) {
  return {
    role,
    name,
    age,
    id: Math.random().toString(36).substr(2, 9)
  };
}

const curriedCreateUser = _.curry(createUser);

// 관리자 생성 함수
const createAdmin = curriedCreateUser('admin');

// 특정 연령대 관리자 생성
const createAdminIn30s = createAdmin(_, 35);

console.log(createAdminIn30s('김관리자'));
/*
{
  role: 'admin',
  name: '김관리자',
  age: 35,
  id: '4f6g7h8j9'
}
*/

5) 메모이제이션과 함께 사용

const _ = require('lodash');

function expensiveCalculation(a, b, c) {
  console.log('계산 수행 중...');
  // 복잡한 계산 가정
  return a * b * c;
}

const curriedCalculation = _.curry(expensiveCalculation);
const memoizedCalculation = _.memoize(curriedCalculation);

// 첫 호출 - 계산 수행
console.log(memoizedCalculation(2)(3)(4)); // 24, "계산 수행 중..." 출력

// 동일 인자로 재호출 - 캐시된 결과 반환
console.log(memoizedCalculation(2)(3)(4)); // 24, 출력 없음

6) 함수 파이프라인 구성

const _ = require('lodash');

// 변환 함수들
function add(a, b) { return a + b; }
function multiply(a, b) { return a * b; }
function square(n) { return n * n; }

// 커링 적용
const curriedAdd = _.curry(add);
const curriedMultiply = _.curry(multiply);

// 파이프라인 구성
const calculate = _.flow([
  curriedAdd(10),     // 첫 번째 인자에 10을 더함
  curriedMultiply(5), // 결과에 5를 곱함
  square              // 결과를 제곱함
]);

console.log(calculate(5)); // ((5 + 10) * 5)^2 = 5625

7) 검색 필터링

const _ = require('lodash');

// 제품 데이터
const products = [
  { id: 1, name: '노트북', category: '전자제품', price: 1200000 },
  { id: 2, name: '스마트폰', category: '전자제품', price: 800000 },
  { id: 3, name: '의자', category: '가구', price: 150000 },
  { id: 4, name: '책상', category: '가구', price: 200000 }
];

// 필터 함수
function filterByCategory(category, items) {
  return items.filter(item => item.category === category);
}

function filterByMaxPrice(maxPrice, items) {
  return items.filter(item => item.price <= maxPrice);
}

// Lodash 커링 적용
const curriedFilterByCategory = _.curry(filterByCategory);
const curriedFilterByPrice = _.curry(filterByMaxPrice);

// 카테고리 필터 생성
const filterElectronics = curriedFilterByCategory('전자제품');
const filterFurniture = curriedFilterByCategory('가구');

// 가격 필터 생성
const filterUnder1Million = curriedFilterByPrice(1000000);

// 필터 조합
const getAffordableElectronics = _.flow([
  filterElectronics,
  filterUnder1Million
]);

console.log(getAffordableElectronics(products));
/*
[
  { id: 2, name: '스마트폰', category: '전자제품', price: 800000 }
]
*/

Lodash의 _.curry 함수를 사용하면:

• 기존 함수를 쉽게 커링할 수 있음
• 인자를 원하는 순서대로 부분 적용 가능
• _ 플레이스 홀더로 특정 인자만 나중에 전달 가능
• 함수 조합성이 크게 향상됨

커링은 특히 복잡한 함수 파이프라인을 구성하거나 고차 함수를 만들 때 유용하게 사용할 수 있습니다.

🌈 Lodash 사용 감소 추세의 주요 이유

🌸 ES6+의 발전:

• 최신 JavaScript(ES6+)에서 Lodash의 핵심 기능들(map, filter, reduce 등)이 대부분 기본 제공되면서 필요성이 감소
• 예: _.find() 대신 Array.prototype.find() 사용 가능

🌸 성능 차이:

대부분의 기본 연산에서 네이티브 JavaScript가 더 빠른 성능을 보임
단, .uniq(), .throttle() 등 일부 함수는 여전히 Lodash가 우수한 경우 있음59

🌸 번들 크기 문제:

트리 쉐이킹이 완벽하지 않아 사용하지 않는 함수도 번들에 포함될 수 있음6

특히 프론트엔드 환경에서 번들 크기 민감할 때 문제됨

🌸 타입스크립트 지원 문제:

• JavaScript로 작성되어 타입 정의가 별도로 필요(@types/lodash)
• 타입 안정성이 낮아 런타임 오류 가능성 존재

🌈 여전히 Lodash를 사용하는 경우

🌸 레거시 프로젝트:

기존에 Lodash에 의존하는 대형 프로젝트들은 마이그레이션 비용 때문에 계속 사용

🌸 특수 기능 필요 시:

• .debounce(), .throttle() 같은 유틸리티 함수
• _.cloneDeep() 같은 깊은 복사 기능
• .groupBy(), .orderBy() 등 복잡한 데이터 처리

🌸 크로스 브라우징:

• 오래된 브라우저 지원이 필요한 경우

🌈 현실적인 선택 가이드

✅ Lodash를 대체할 수 있는 경우:

• 간단한 배열/객체 조작은 네이티브 메소드 사용
• [...new Set(arr)]으로 중복 제거
• Object.entries()로 객체 순회

⚠️ Lodash를 고려해볼 경우:

• 복잡한 데이터 변환 필요 시
• 성능 테스트 결과 Lodash가 우수한 경우
• 이미 Lodash에 익숙한 팀의 생산성 향상을 위해

🌸 대안 라이브러리 추천

• lodash-es: ESM 모듈 지원 버전
• ramda: 함수형 프로그래밍에 특화
• remeda: 타입스크립트 최적화 유틸리티
• just: 특정 기능만 필요한 경우 모듈식 사용 가능

🌈 결론

커링을 사용하지 않은 일반 함수가 더 직관적이고 간단한 경우가 많지만, 커링은 함수의 재사용성과 조합성을 높여주는 장점이 있습니다.

Lodash는 점점 필수 라이브러리에서 "선택적" 라이브러리로 변화 중입니다. 2025년 현재는 전체 번들을 설치하기보다는 필요한 기능만 선택적으로 사용하거나, 네이티브 기능으로 대체하는 추세입니다. 특히 신규 프로젝트에서는 최신 JavaScript 기능을 우선적으로 고려한 후, 부족한 부분만 Lodash나 다른 라이브러리로 보완하는 접근이 권장됩니다.

"과거에는 Lodash가 필수였지만, 이제는 선택의 문제가 되었습니다. 프로젝트 요구사항과 팀의 숙련도를 고려해 현명하게 선택해야 합니다."

🌈 참고 자료

https://ko.javascript.info/currying-partials
https://wiki.haskell.org/index.php?title=Currying
https://velog.io/@hustle-dev/Javascript-%EC%BB%A4%EB%A7%81%EC%97%90-%EB%8C%80%ED%95%B4-%EC%95%8C%EC%95%84%EB%B3%B4%EC%9E%90
https://www.tutorialspoint.com/lodash/lodash_curry.htm
https://if1live.github.io/posts/escape-from-lodash-just/