ramda-reference

name	ramda-reference
description	Ramda 0.32.0 전체 함수 레퍼런스 (272개, ramdajs.com/docs 전체 수록). 프론트엔드 코드 작성·수정·리뷰 시 어떤 Ramda 함수를 쓸지 결정할 때 반드시 참고.
user-invocable	false

Ramda 0.32.0 전체 레퍼런스

ramdajs.com/docs 전체 272개 함수를 카테고리별로 수록 (설치된 ramda@0.32.0의 export와 1:1 일치). 프론트엔드 코드에서 네이티브 JS 대신 사용할 함수를 여기서 고른다. ramda 버전을 올리면 이 파일을 재생성할 것 (소스: node_modules/ramda/src/*.js의 JSDoc @category).

핵심 메커니즘

• 모든 함수는 자동 커링 + data-last: R.map(fn)(list) == R.map(fn, list). 데이터를 마지막에 받으므로 R.pipe 합성에 최적.
• R.__ 자리표시자: 중간 인자를 비워 부분 적용 — R.includes(R.__, options).
• 합성: R.pipe(f, g) 왼→오른쪽, R.compose(f, g) 오른→왼쪽. 값을 먼저 주려면 R.flow(x, [f, g]) 또는 R.applyTo(x, fn).
• 비동기: Promise 체인은 R.andThen(then) / R.otherwise(catch)로 합성. async 파이프라인은 R.pipeWith(R.andThen, [...]).
• 렌즈: R.lensProp/R.lensPath/R.lensIndex로 만들고 R.view(읽기)/R.set(쓰기)/R.over(변환).
• 깊은 비교 vs 참조 비교: R.equals는 깊은 동등, R.identical은 Object.is.
• ⚠️ 인자 순서 (0.29+): R.propEq(값, 키, obj), R.pathEq(값, 경로, obj) — 값이 먼저다. 구버전 예제(키 먼저)를 따라 쓰지 말 것.
• ⚠️ R.of는 0.30+에서 R.of(Array, x) 형태 (타입 대표 필요). R.sequence/R.traverse도 첫 인자로 타입 대표를 받는다.

네이티브 → Ramda 필수 치환표 (CLAUDE.md 규칙의 구체화)

네이티브 패턴	Ramda 치환
obj.x, obj?.x (데이터 객체)	R.prop("x"), R.propOr(def, "x"), R.path(["a","b"]), R.pathOr(def, [...])
if (x === null), !x nil 체크	R.isNil, R.isNotNil
arr.length === 0 / > 0	R.isEmpty / R.isNotEmpty
if/else, 데이터 삼항	R.ifElse(pred, onT, onF), R.when(pred, fn), R.unless(pred, fn)
if/else if 체인, switch	R.cond([[pred, fn], ..., [R.T, fallback]])
a || def, a ?? def	R.defaultTo(def, a)
x === y	R.equals(y, x), R.propEq(val, key, obj)
arr.map/filter/find/reduce/...	R.map/R.filter/R.find/R.reduce/...
[...arr, x] / [x, ...arr]	R.append(x, arr) / R.prepend(x, arr)
arr[i], key[1]	R.nth(i, arr), R.nth(1, key)
e.target.value 핸들러	R.pipe(R.path(["target", "value"]), setter)
Object.keys/values/entries	R.keys / R.values / R.toPairs
!pred(x)	R.complement(pred), R.not
p(x) && q(x) / || 술어 합성

원칙: Ramda로 표현 가능한 것은 전부 Ramda로 작성한다. 네이티브가 허용되는 예외는 Ramda로 표현이 불가능한 것뿐이다:

• 호스트 객체 조작: window/document/DOM/location의 쓰기·메서드 호출. 주의 — R.assocPath(["location", "href"], url, window)는 복사본 객체만 만들 뿐 네비게이션하지 않는다 (조용한 버그). 읽기도 실익이 없으므로 호스트 객체는 통째로 예외.
• React hooks 호출: rules of hooks 때문에 조건부 합성 불가. hook 호출 자체는 항상 네이티브.
• 함수·Tauri 커맨드 호출 자체: invoke(...), 콜백 실행, 이벤트 핸들러 등록.
• Set/Map 조작: Ramda 미지원. Rust로 보내기 전 Array.from 변환 (CLAUDE.md gotcha).
• JSX 문법 자체, 함수 파라미터 구조분해.
• 언어 구문: import/export, async 함수 정의, throw.
• Ramda 대응이 없는 내장: JSON.parse/stringify, Math.ceil/round/floor/random, parseInt/parseFloat/isNaN, Date, 타이머. String(x) 강제변환도 예외 (R.toString("a")는 '"a"'로 따옴표가 붙어 대체 불가).
• iframe 주입용 템플릿 리터럴 내부 코드 (샌드박스에 Ramda 로드 불가), 문자열 보간용 템플릿 리터럴 자체.

promise.then/catch·async try/catch·문자열 메서드는 예외가 아니다 — 각각 R.andThen/R.otherwise, R.replace/R.trim 등으로 반드시 치환한다.

Function (55)

• R.F() — 항상 false 반환
• R.T() — 항상 true 반환
• R.__ — 부분 적용 자리표시자
• R.addIndex(iterFn) — map/filter류에 (item, idx, list) 콜백 시그니처 부여
• R.addIndexRight(iterFn) — addIndex의 오른쪽→왼쪽 순회 버전
• R.always(x) — 항상 x를 반환하는 함수 생성
• R.andThen(fn, promise) — Promise 성공 값에 fn 적용 (.then)
• R.ap(fnList, list) — 함수 컨테이너를 값 컨테이너에 적용 (Apply)
• R.apply(fn, argsList) — 인자 배열을 펼쳐 호출
• R.applySpec(spec) — 스펙 객체 모양대로 각 함수 결과를 채운 객체 생성
• R.applyTo(x, fn) — x를 fn에 적용 (값 우선)
• R.ascend(fn) — fn 결과 기준 오름차순 비교자 생성 (sortWith용)
• R.ascendNatural(locales, fn) — localeCompare 자연 정렬 오름차순 비교자
• R.binary(fn) — 인자 2개로 제한한 함수
• R.bind(fn, thisObj) — this를 고정한 함수
• R.call(fn, ...args) — fn을 즉시 호출
• R.comparator(pred) — (a,b)→bool 술어를 -1/0/1 비교자로 변환
• R.compose(...fns) — 오른쪽→왼쪽 함수 합성
• R.composeWith(transformer, fns) — 각 단계 결과를 변환기로 연결하며 합성
• R.construct(Ctor) — 생성자를 new 없이 쓰는 커링 함수로
• R.constructN(n, Ctor) — arity를 지정한 construct
• R.converge(after, branchFns) — 같은 인자로 분기 함수들 실행 후 결과들을 after에 전달
• R.curry(fn) — 자동 커링
• R.curryN(n, fn) — arity를 명시한 커링 (default 파라미터가 있으면 필수)
• R.descend(fn) — fn 결과 기준 내림차순 비교자
• R.descendNatural(locales, fn) — 자연 정렬 내림차순 비교자
• R.empty(x) — 같은 타입의 빈 값 ([], "", {})
• R.flip(fn) — 첫 두 인자 순서를 바꾼 함수
• R.flow(x, [f, ...fns]) — 값 x를 파이프라인에 통과 (pipe의 값-우선형)
• R.identity(x) — x 그대로 반환
• R.invoker(arity, method) — 메서드를 data-last 함수로 ()

List (92)

• R.adjust(idx, fn, list) — 해당 인덱스 요소에 fn 적용한 새 배열
• R.all(pred, list) — 모든 요소가 술어 만족?
• R.any(pred, list) — 하나라도 만족?
• R.aperture(n, list) — n개짜리 연속 슬라이딩 윈도우 목록
• R.append(x, list) — 끝에 추가한 새 배열
• R.chain(fn, list) — flatMap (매핑 후 1단계 평탄화)
• R.collectBy(keyFn, list) — 키 함수 결과가 같은 요소끼리 서브리스트로 분할
• R.concat(a, b) — 배열/문자열 연결
• R.count(pred, list) — 술어 만족 개수
• R.drop(n, list) — 앞 n개 제거
• R.dropLast(n, list) — 뒤 n개 제거
• R.dropLastWhile(pred, list) — 뒤에서 술어 만족하는 동안 제거
• R.dropRepeats(list) — 연속 중복 제거
• R.dropRepeatsBy(fn, list) — fn 결과 기준 연속 중복 제거
• R.dropRepeatsWith(eqFn, list) — 동치 함수 기준 연속 중복 제거
• R.dropWhile(pred, list) — 앞에서 술어 만족하는 동안 제거
• R.endsWith(suffix, list) — 접미 일치 여부
• R.filter(pred, list) — 술어 만족 요소만
• R.find(pred, list) — 첫 만족 요소 (없으면 undefined)
• R.findIndex(pred, list) — 첫 만족 인덱스 (없으면 -1)
• R.findLast(pred, list) — 마지막 만족 요소
• R.findLastIndex(pred, list) — 마지막 만족 인덱스
• R.flatten(list) — 모든 중첩 완전 평탄화
• R.forEach(fn, list) — 부수효과 순회 (원본 반환)
• R.fromPairs(pairs) — [[k,v],...] → 객체
• R.groupBy(keyFn, list) — 키 함수 결과별로 그룹한 객체
• R.groupWith(eqFn, list) — 인접 동치 요소끼리 그룹
• R.head(list) — 첫 요소
• R.includes(x, list) — 포함 여부 (equals 기준)
• R.indexBy(keyFn, list) — 키→요소 객체 (마지막 값 우선)
• R.indexOf(x, list) — 첫 위치 (equals 기준)
• R.init(list) — 마지막 요소 제외 전부
• R.insert(idx, x, list) — 위치에 삽입
• R.insertAll(idx, xs, list) — 위치에 여러 개 삽입

Logic (19)

• R.allPass(preds) — 모든 술어를 만족하는지 검사하는 술어
• R.and(a, b) — 논리곱 (값)
• R.anyPass(preds) — 하나라도 만족 술어
• R.both(f, g) — f(x) && g(x) 술어 합성
• R.complement(pred) — 술어 부정
• R.cond(pairs) — [[술어, 결과fn], ...] 다중 분기 (switch/if-chain 대체)
• R.defaultTo(def, x) — x가 null/undefined/NaN이면 def
• R.either(f, g) — f(x) || g(x) 술어 합성
• R.ifElse(pred, onTrue, onFalse) — 조건 분기 함수
• R.isEmpty(x) — 타입의 빈 값인지 ([], "", {})
• R.isNotEmpty(x) — isEmpty의 부정
• R.not(x) — 논리 부정
• R.or(a, b) — 논리합 (값)
• R.pathSatisfies(pred, path, obj) — 경로 값이 술어 만족?
• R.propSatisfies(pred, key, obj) — prop 값이 술어 만족?
• R.unless(pred, fn, x) — 불만족 시 fn(x), 만족 시 x
• R.until(pred, fn, x) — 만족할 때까지 fn 반복 적용
• R.when(pred, fn, x) — 만족 시 fn(x), 불만족 시 x
• R.xor(a, b) — 배타적 논리합

Math (13)

• R.add(a, b) — 덧셈
• R.dec(n) — n - 1
• R.divide(a, b) — 나눗셈
• R.inc(n) — n + 1
• R.mathMod(m, p) — 수학적 모듈로 (음수 안전)
• R.mean(list) — 평균
• R.median(list) — 중앙값
• R.modulo(a, b) — JS % 연산
• R.multiply(a, b) — 곱셈
• R.negate(n) — 부호 반전
• R.product(list) — 전체 곱
• R.subtract(a, b) — 뺄셈
• R.sum(list) — 전체 합

Object (55)

• R.assoc(key, val, obj) — 프로퍼티 설정한 얕은 복제본
• R.assocPath(path, val, obj) — 중첩 경로에 값 설정
• R.clone(x) — 깊은 복제
• R.dissoc(key, obj) — 프로퍼티 제거한 복제본
• R.dissocPath(path, obj) — 중첩 경로 제거
• R.eqProps(key, a, b) — 두 객체의 해당 prop이 equals?
• R.evolve(spec, obj) — 스펙의 함수들로 해당 프로퍼티만 변환
• R.forEachObjIndexed(fn, obj) — (값, 키, obj) 부수효과 순회
• R.has(key, obj) — own 프로퍼티 존재?
• R.hasIn(key, obj) — 프로토타입 포함 존재?
• R.hasPath(path, obj) — 중첩 경로 존재?
• R.invert(obj) — 값→[키 배열] 반전
• R.invertObj(obj) — 값→키 반전 (마지막 우선)
• R.keys(obj) — own 키 배열
• R.keysIn(obj) — 프로토타입 포함 키 배열
• R.lens(getter, setter) — 커스텀 렌즈 생성
• R.lensIndex(n) — 배열 인덱스 렌즈
• R.lensPath(path) — 중첩 경로 렌즈
• R.lensProp(key) — 프로퍼티 렌즈
• R.mapKeys(fn, obj) — 키를 fn으로 변환한 객체
• R.mapObjIndexed(fn, obj) — (값, 키, obj)로 값 매핑
• R.mergeDeepLeft(l, r) — 깊은 병합, 왼쪽 우선
• R.mergeDeepRight(l, r) — 깊은 병합, 오른쪽 우선
• R.mergeDeepWith(fn, l, r) — 충돌 시 fn(lVal, rVal)로 깊은 병합
• R.mergeDeepWithKey(fn, l, r) — 충돌 시 fn(key, lVal, rVal) 깊은 병합
• R.mergeLeft(l, r) — 얕은 병합, 왼쪽 우선
• R.mergeRight(l, r) — 얕은 병합, 오른쪽 우선 ({...l, ...r} 대체)
• R.mergeWith(fn, l, r) — 충돌 키만 fn으로 병합
• R.mergeWithKey(fn, l, r) — 충돌 시 키 포함 fn 병합
• R.modify(key, fn, obj) — 해당 prop에 fn 적용한 복제본
• R.modifyPath(path, fn, obj) — 중첩 경로에 fn 적용
• R.objOf(key, val) — 단일 프로퍼티 객체 생성
• R.omit(keys, obj) — 지정 키 제외한 복제본
• — 렌즈 초점에 fn 적용

Relation (25)

• R.clamp(min, max, n) — 범위로 제한
• R.countBy(fn, list) — fn 결과별 개수 객체
• R.difference(a, b) — a에만 있는 요소
• R.differenceWith(eqFn, a, b) — 동치 함수 기준 차집합
• R.eqBy(fn, a, b) — fn 적용 후 equals
• R.equals(a, b) — 깊은 구조 동등 비교
• R.gt(a, b) — a > b
• R.gte(a, b) — a >= b
• R.identical(a, b) — Object.is 참조 동일성
• R.innerJoin(pred, records, ids) — 관계형 inner join
• R.intersection(a, b) — 교집합
• R.lt(a, b) — a < b
• R.lte(a, b) — a <= b
• R.max(a, b) — 큰 값
• R.maxBy(fn, a, b) — fn 결과가 큰 쪽의 원본
• R.min(a, b) — 작은 값
• R.minBy(fn, a, b) — fn 결과가 작은 쪽의 원본
• R.pathEq(val, path, obj) — 경로 값이 val과 equals? (값이 첫 인자)
• R.propEq(val, key, obj) — prop 값이 val과 equals? (값이 첫 인자)
• R.sortBy(fn, list) — fn 결과 기준 오름차순 정렬
• R.sortWith(comparators, list) — 비교자 배열 순차 적용 정렬
• R.symmetricDifference(a, b) — 한쪽에만 있는 요소들
• R.symmetricDifferenceWith(eqFn, a, b) — 동치 함수 기준 대칭차
• R.union(a, b) — 합집합 (중복 제거)
• R.unionWith(eqFn, a, b) — 동치 함수 기준 합집합

String (8)

• R.match(regex, str) — 매치 결과 배열 (없으면 [])
• R.replace(pattern, replacement, str) — 치환
• R.split(sep, str) — 분할 배열
• R.test(regex, str) — 정규식 매치 여부
• R.toLower(str) — 소문자로
• R.toString(x) — 값의 문자열 표현 (재귀적)
• R.toUpper(str) — 대문자로
• R.trim(str) — 앞뒤 공백 제거

Type (5)

• R.is(Ctor, x) — 생성자 기반 타입 검사 (R.is(Array, x))
• R.isNil(x) — null 또는 undefined?
• R.isNotNil(x) — nil 아님?
• R.propIs(Ctor, key, obj) — prop이 해당 타입?
• R.type(x) — 타입명 문자열 ("Object", "Array", "Null" 등)