at |
|
t.at(pathAt, object) |
at |
atOr |
|
t.atOr(fallback, pathAt, object) |
atOr |
addIndex |
|
t.addIndex((value, index) => {}, object) |
addIndex |
adjust |
|
t.adjust(index, R.toUpper, list) |
adjust |
and |
|
t.any([a → Boolean, b → Boolean]) |
and |
anyOf |
✔️ |
t.anyOf([a → Boolean, b → Boolean, ...]) |
anyOf |
allOf |
✔️ |
t.allOf([a → Boolean, b → Boolean, ...]) |
allOf |
append |
|
t.append(object, object) |
append |
compose |
|
t.compose(t.toUpper ,(a => ${a} ))) |
compose |
concat |
|
t.concat(object, object) |
concat |
dropLast |
|
t.dropLast(n, array/string ) |
dropLast |
endsWith |
|
t.endWith(object, listOfObjects) |
endsWith |
equals |
|
t.equals(object, object) |
equals |
eq |
✔️ |
t.eq(object, object) |
shorthand for equals |
neq |
✔️ |
t.neq(object, object) |
pipe(equals, not) |
filter |
|
t.filter(fn, list) |
filter |
find |
|
t.find(fn, list) |
find |
findIndex |
|
t.findIndex(fn, list) |
findIndex |
flatten |
|
t.flatten([replaced, [remainder, toAdd]]) |
flatten |
forEach |
|
t.forEach(fn, object) |
forEach |
forEachObjIndexed |
|
t.forEachObjIndexed((value, key), object) |
forEachObjIndexed |
fromPairs |
|
t.fromPairs(objectOfPairs) |
fromPairs |
groupBy |
|
t.groupBy(fn) |
groupBy |
gt |
|
t.gt(a-> int/string, b-> int/string) |
gt |
gte |
|
t.gte(a-> int/string, b-> int/string) |
gte |
has |
|
t.has(key)({ key: value }) |
has |
hasIn |
|
t.hasIn(prop, object) |
hasIn |
head |
|
t.head(list/string) |
head |
includes |
|
t.includes(object, list/string) |
includes |
isEmpty |
|
t.isEmpty(object/list) |
isEmpty |
notEmpty |
|
t.notEmpty(object/list) |
pipe(isEmpty, not) |
isNil |
|
t.isNil(value) |
isNil |
notNil |
|
t.notNil(value) |
pipe(isNil, not) |
keys |
|
t.keys(object) |
keys |
keysIn |
|
t.keysIn(object) |
keysIn |
last |
|
t.last(list/string) |
last |
length |
|
t.length(list/string) |
length |
len |
|
t.len(list/string) |
shorthand for length
|
lt |
|
t.lt(a → int/string, b → int/string) |
lt |
lte |
|
t.lte(a → int/string, b → int/string) |
lte |
map |
|
t.map(fn, list) |
map |
mapIndexed |
✔️ |
t.mapIndex((value, index) => {}, list) |
addIndex(map) |
mapObjIndexed |
|
t.mapObjIndexed(fn, list) |
mapObjIndexed |
merge |
|
t.merge(object/list, object/list) |
merge |
mergeAll |
|
t.mergeAll(object/list, object/list) |
mergeAll |
mergeDeepRight |
|
t.mergeDeepRight(object/list, object/list) |
mergeDeepRight |
not |
|
t.not(boolean) |
not |
omit |
|
t.omit([keyA,keyB], list/object) |
omit |
or |
|
t.or(a → Boolean, b → Boolean, ...) |
or |
path |
|
t.path([key, ...], object) |
path |
pathOr |
|
t.pathOr(fallback, [key, ...], object) |
pathOr |
pick |
|
t.pick([keys], object) |
pick |
pipe |
|
t.pipe(fn,fn,...) |
pipe |
pluck |
|
t.pluck(prop) |
pluck |
prepend |
|
t.prepend(item, object) |
prepend |
prop |
|
t.prop(key, object/list) |
prop |
range |
|
t.range(from, to) |
range |
reduce |
|
t.reduce(fn, object, list) |
reduce |
repeat |
|
t.repeat(object/list/string, x) |
repeat |
replace |
|
t.replace(toReplace, replceWith, string) |
replace |
sort |
|
t.sort((a,b) => a - b) |
sort |
sortBy |
|
t.sortBy(t.prop(0)) |
sortBy |
sortWith |
|
t.sortWith([fn, fn, ...]) |
sortWith |
descend |
|
t.sort(t.descend(t.Prop(0)), list) |
descend |
ascend |
|
t.sort(t.ascend(t.Prop(0)), list) |
ascend |
reverse |
|
t.reverse(list/string) |
reverse |
split |
|
t.split(toSplitOn, string) |
split |
startsWith |
|
t.startsWith(string,string) |
startsWith |
slice |
|
t.slice(fromIndex(inclusive), toIndex(exclusive), string, string) |
split |
sum |
|
t.sum(list) |
sum |
tail |
|
t.tail(list) |
tail |
take |
|
t.take(number, list) |
take |
takeLast |
|
t.takeLast(number, list) |
takeLast |
toPairs |
|
t.toPairs(object) |
[toPairs])(https://ramdajs.com/docs/#toPairs) |
toString |
|
t.toString(number/object/list) |
toString |
trim |
|
t.trim(string) |
trim |
tryCatch |
|
t.tryCatch(fn, fn) |
tryCatch |
type |
|
t.type(*) |
type |
update |
|
t.update(index, value, list) |
update |
uniq |
|
t.uniq(list) |
uniq |
values |
|
t.values(object) |
values |
isType |
✔️ |
t.isType(object, string) |
equals(toLower(rType(subject)), toLower(matcher)) |
ofType |
✔️ |
t.ofType(matcher, subject) |
ofType |
notType |
✔️ |
t.notType(fn,'Object') |
(subject, typeKey) => not(isType(subject, typeKey)) |
when |
|
t.when(a → Boolean, fn) |
when |
isZeroLen |
✔️ |
t.isZeroLen(list/string) |
isZeroLen |
notZeroLen |
✔️ |
t.notZeroLen(]) |
pipe(isZeroLen, not) |
noLen |
✔️ |
t.noLen(list/string) |
isZeroLen |
hasLen |
✔️ |
t.hasLen(list/string) |
notZeroLen |
valPipe |
✔️ |
t.valPipe |
val => (...args) => pipe(...args)(val) |
vPipe |
✔️ |
t.vPipe |
valPipe |
runMatch |
✔️ |
t.runMatch() |
runMatch |
getMatch |
✔️ |
t.getMatch(prop.match)(match) |
getMatch |
match |
✔️ |
|
match |
to |
|
t.to.fn(string) |
to |
caseTo |
|
t.caseTo(string) |
Same as above to fn |
html |
|
t.html(string) |
html |
safeHtml |
|
t.safeHtml(string) |
safeHtml |
oneLine |
|
t.oneLine(multiline string ) |
oneLine |
oneLineTrim |
|
t.oneLineTrim(multiline string ) |
oneLineTrim |
stripIndent |
|
t.stripIndent(string) |
stripIndent |
stripIndents |
|
t.stripIndents(string) |
stripIndents |
inlineLists |
|
t.lineLists(string) |
inlineLists |
oneLineInlineLists |
|
t.oneLineInlineLists(list) |
oneLineInlineLists |
commaLists |
|
t.commaLists(list) |
commaLists |
oneLineCommaLists |
|
t.oneLineCommaLists(list) |
oneLineCommaLists |
globrex |
|
t.globrex(pattern).regex.test(string) |
globrex |
throttle |
|
t.throttle(fn, number [options={}]) |
throttle |
trampoline |
✔️ |
t.trampoline(async function rollup(props){}) |
trampoline |