Returns the result of calling its first argument with the remaining arguments (official Ramda docs). Think of it as fn(a, b, c) with the function written first — handy when the function is dynamic, or as a converging function for R.converge.
Stable since v0.9.0:R.call is a core Ramda helper — not deprecated, experimental, or non-standard. It takes the function first and does not set this (unlike native Function.prototype.call). For array args, use R.apply.
Syntax
Call R.call. Start with this line.
Ramda
R.call(fn, ...args)
Call
What it does
R.call(fn, ...args)
Primary signature.
R.call(...)
Call the function helper.
Prefer import { call } from "ramda" when you want a named import.
Library declarations
Ramda
R.call(fn, ...args)
Parameters
Parameter
Description
fn
Required. Function to apply to the remaining arguments
args
Optional. Any number of positional arguments
Return Value
Return Value
Description
*
Whatever fn(...args) returns
Ramda Examples
Example 1 — Official R.add
Call a function with two numbers — the sample from the Ramda docs.
Table lookup.ops.add / ops.multiply are functions stored by name.
call runs them. Arguments follow after the chosen function.
Results.2 + 3 → 5, 2 × 3 → 6.
Pattern. Useful when the operation name is data (config, UI choice, message type).
Compatibility
Browser & Runtime Support
R.call() is ordinary JavaScript once Ramda is loaded. It needs no special browser API — only a JS runtime that can run Ramda (v0.9.0+).
✓ Ramda 0.9.0+ · Any JS runtime
Ramda.js R.call()
Works in every modern browser and runtime where you can load Ramda (CDN or npm). Internet Explorer needs a build that targets that environment; there is no native IE API to polyfill.
100%With Ramda loaded
Google ChromeSupported · Desktop & Mobile
Full support
Mozilla FirefoxSupported · Desktop & Mobile
Full support
Apple SafariSupported · macOS & iOS
Full support
Microsoft EdgeSupported · Chromium
Full support
Internet ExplorerNo native support · Use a polyfill
Polyfill
OperaSupported · Modern versions
Full support
Samsung InternetSupported · Android
Full support
BunSupported · JavaScript runtime
Supported
DenoSupported · JavaScript runtime
Supported
Node.jsSupported · Server runtime
Supported
Android WebViewSupported · Modern WebView
Full support
R.call()Universal
Bottom line: Safe in any project that includes Ramda 0.9.0 or later. Load ramda.min.js from a CDN in the browser, or npm install ramda for Node, Bun, and Deno.
Frequently Asked Questions
R.call(fn, ...args) runs fn with the remaining arguments and returns the result. It is fn(a, b, c) written with the function first. The docs sample is R.call(R.add, 1, 2) which returns 3.
R.call(R.add, 1, 2); //=> 3. The docs also use R.call as the converging function in R.converge so the first branch can produce a function and the other branches produce its arguments. Added in v0.9.0. See also R.apply.
R.call(fn, a, b, c) passes arguments one by one. R.apply(fn, [a, b, c]) passes the same arguments from an array. Use call when you already have separate values; use apply when they live in a list.
Native fn.call(thisArg, a, b) sets this first, then the arguments. R.call(fn, a, b) takes the function first and does not take a thisArg. They share a name and solve different jobs.
converge calls one function with the results of several branches. If the first branch returns a function and the rest return values, R.call is the combiner: it invokes that function with those values. The official indent formatter is that pattern.
No. R.call is a stable Ramda function helper from v0.9.0. It is not deprecated, experimental, or non-standard.