Ramda’s R.multiply() multiplies two numbers. It is equivalent to a * b, but curried. The official docs samples are double(3) → 6, triple(4) → 12, and R.multiply(2, 5) → 10. Added in v0.1.0. See also R.divide.
Because multiplication is commutative, fixing the first argument is enough to name a scaler: R.multiply(2) is already “times two.” That is why the docs never need R.__ here — unlike R.divide.
Syntax
Call R.multiply. Start with this line.
Ramda
R.multiply(a, b)
Call
What it does
R.multiply(a, b)
Primary signature.
R.multiply(...)
Call the math helper.
Prefer import { multiply } from "ramda" when you want a named import.
Library declarations
Ramda
R.multiply(a, b)
Parameters
Parameter
Description
a
Required. the first factor.
b
Required. the second factor.
Return Value
Return Value
Description
*
Returns a Number: a * b.
Ramda Examples
📚 Getting Started
The official 2 * 5 sample, then the official double and triple helpers.
R.multiply returns a * b. 2 * 5 is 10 — the official sample. Swapping to 5 * 2 is still 10 because multiplication is commutative. That is the big difference from R.divide.
Example 2 — Official double and triple
The docs build reusable scalers by fixing the first factor.
Ramda
var double = R.multiply(2);
var triple = R.multiply(3);
double(3); //=> 6
triple(4); //=> 12
double(2); //=> 4
R.multiply(2) returns a function that still needs the second factor. Calling it with 3 computes 2 * 3, which is 6 — the official double sample. You do not need R.__ here. R.multiply(2) already means “times two.”
📈 Practical Patterns
Map a double helper, pairwise products, and a scale-then-offset pipeline.
Example 3 — Point-Free Map with double
Drop the official double helper into R.map to scale every item.
R.pipe runs left to right. 3 is doubled to 6, then R.add(1) makes 7. The second line is triple(4) + 1 → 13. Both helpers are curried, so they drop into the pipeline with no lambdas.
Compatibility
Browser Support
R.multiply() is plain JavaScript multiplication — it runs anywhere Ramda loads: every modern browser plus Node.js. Logos use the shared browser-image-sprite.png sprite from this project.
✓ Ramda 0.1.0+ · Any JS runtime
Ramda.js R.multiply()
Load Ramda via CDN or npm, then call R.multiply(a, b). Because it only uses a * b, behavior is identical across engines.
100%With Ramda loaded
Google ChromeAll versions · Desktop & Mobile
Full support
Mozilla FirefoxAll versions · Desktop & Mobile
Full support
Apple SafariAll versions · macOS & iOS
Full support
Microsoft EdgeAll versions · Chromium & Legacy
Full support
Internet ExplorerIE 6+ · Legacy environments
Full support
OperaAll modern versions
Full support
R.multiply()Universal
Bottom line: Safe in any project that includes Ramda. Use a CDN build such as ramda.min.js in the browser or install ramda from npm for Node.
Frequently Asked Questions
R.multiply(a, b) returns a * b. It is Ramda's curried multiplication helper — the functional equivalent of the * operator — so it can be partially applied and dropped into point-free pipelines.
The docs build const double = R.multiply(2) and const triple = R.multiply(3), then double(3) returns 6 and triple(4) returns 12. They also show R.multiply(2, 5) returning 10. Added in v0.1.0. See also R.divide.
Yes. R.multiply has arity 2 and is automatically curried, so R.multiply(2, 5) and R.multiply(2)(5) both return 10. Calling it with one argument returns a scaler — that is the official double / triple pattern.
Usually no. Multiplication is commutative, so R.multiply(2) already means “times 2.” Contrast with R.divide: R.divide(2) is 2 / n, not a half. You only need R.__ when you want to fill the second slot first.
R.multiply returns a * b and is commutative. R.divide returns a / b and is not. R.product multiplies every number in a list; R.multiply takes exactly two numbers (or a curried scaler).
No. R.multiply is a stable Ramda math helper from v0.1.0. It is not deprecated, experimental, or non-standard.