The Master List

This issue is a broad master checklist covering TypeScript definitions for many functions, including addIndex, compose, curry, and sequence, rather than naming a single file or entry point. Start by selecting one unchecked function and reviewing its existing definition and related tests; completion means resolving that function's listed concern and adding or updating the requested tests.

This is the Master list for all the types and the tl;dr for what needs to happen for all

Note: "acts as a transducer" is not something can, nor should, see for more details

Overall things to do:

• Uniform type names for coming things (eg using T, U, etc)a
• Idx should be a type Idx = string | number | Symbol and used throughout when constraining anything that is an object key (this will match documentation as well)
• Ord and Ordering types need to be used more

Functions:

• add - done
• addIndex - need to figure out how to automatically infer source function correctly. normalize return type names, needs tests
• adjust - done
• all - figure out { all } and how it can work with compose
• allPass - need to evaluate
• always - done
• and - fix tests
• andThen - needs tests
• any - needs review
• anyPass - need to evaluate
• ap - need to evaluate
• aperture - need to evaluate
• append - needs tests
• apply - needs tests
• applySpec - could have a better type, look into infering function arity and argument types
• applyTo - needs tests
• ascend - needs tests, documentation should be updated to final return Ordering and not Number
• assoc - needs tests
• assocPath - needs overloaded types like path, needs tests
• binary - needs tests
• bind - needs tests
• both - look into PredTypeguard variant, needs tests
• call - needs tests
• chain - should be good, need to double check, needs tests
• clamp - need to property curry, constrain T extends Ord, needs tests
• clone - redo types completely, needs tests
• collectBy - needs tests
• comparator - needs tests
• complement - look into TFiltered variant, needs tests, look into if "can be applied to any functor" needs specific typings
• compose - re-order, array variant looks wrong, needs tests
• composeWith - needs overloads, look into AtLeastOneFunctionsFlowFromRightToLeft, needs tests
• concat - needs tests, needs types for "Dispatches to the concat method", double check currying
• cond - needs tests
• construct - needs tests, can improve typing with ConstructorParameters
• constructN - needs tests, can improve typing with ConstructorParameters
• converge - needs full investigation, needs tests
• count - needs tests
• countBy - look into, needs tests
• curry - basically a re-export of ts-toolbelt's Curry, not testing because not our responsibility to test another lib's code
• curryN - doublecheck that it's good
• dec - done
• defaultTo - needs tests
• descend - needs tests
• difference - needs tests
• differenceWith - needs tests
• dissoc - needs tests
• dissocPath - overload the hell out of it, needs tests
• divide - currying looks good, needs tests
• drop - needs tests
• dropLast - needs tests
• dropLastWhile - add specific type for handling strings, needs tests
• dropRepeats - add specific type for handling strings, needs tests
• dropRepeatsBy - add specific type for handling strings, needs tests
• dropRepeatsWith - add specific type for handling strings, needs tests
• dropWhile - add specific type for handling strings, needs tests
• either - needs tests, types for Applicatives
• empty - needs test, types for Monoid
• endsWith - needs tests
• eqBy - needs tests
• eqProps - needs tests, the Record constraint variant should be all that is needed
• equals - needs tests, add specific typings for handing Setoids
• evolve - look into
• F - done
• filter - look into
• find - look into type narrowing variants, test if those definitions actually do anything, types for "find method"
• findIndex - needs tests
• findLast - documents should mention "find method", types to support that, needs tests
• findLastIndex - needs tests
• flatten - re-export of ts-toolbelt's
• flip - look into
• forEach - done!
• forEachObjIndexed - needs tests
• fromPairs - needs tests, look into
• groupBy - types for "groupBy method" variant, needs tests
• groupWith - full currying, better string support, needs tests
• gt - full currying, switch to T extends Ord, needs tests
• gte - full currying, switch to T extends Ord, needs tests, fantasy-land Ord support?
• has - better typing for inference, needs tests, look into ObjectHavingSome
• hasIn - full currying, needs tests
• hasPath - full currying, needs tests
• head - fix T extends any (can be just T), needs tests
• identical - needs tests
• identity - done
• ifElse - should infer returns, needs tests
• inc - done
• includes - readonly string[] | string doesn't seem right, needs tests
• indexBy - look into, needs tests
• indexOf - string[] | string doesn't seem right, needs tests
• init - needs tests
• innerJoin - curry, needs tests
• insert - curry, needs tests
• insertAll - curry, needs tests
• intersection - done
• intersperse - handle "intersperse method", needs tests
• into - very wrong, redo completely
• invert - although non Idx types are automatically coerced into string, should the typings for this limit the object values to be Idx for practical purposes? it would be practical as this function doesn't hold much value for objects with values that aren't Idx (eg, anon-funcs and objects, the later coerced to '[object Object]')
• invertObj - same as above
• invoker - typescript can be used to infer things if desired
• is - needs tests
• isEmpty - needs tests
• isNil - needs tests
• isNotNil - needs tests (also this is not on 0.28.0, it's new)
• join - needs tests
• juxt - need to review
• keys - needs tests
• keysIn - return type should be Idx[]
• last - needs review of populated array overload
• lastIndexOf - review readonly string[] | string of string overload
• length - docs say that arg should be an array, type is for any object that has length prop, need to confirm if that is the intent
• lens - need to confirm defined types
• lensIndex - same
• lensPath - need to work out path arity overloads
• lensProp - same
• lift - needs full review
• liftN - needs full review
• lt - should be typed with Ord
• lte - should be typed with Ord
• map - need to review Functor,
• mapAccum - need to curry, need tests
• mapAccumRight - need to curry, need tests
• mapObjIndexed - need full review
• match - need to curry, need tests
• mathMod - need tests
• max - need tests
• maxBy - better currying, need tests
• mean - tests? (no real value in test)
• median - tests? (no real value in test)
• memoizeWith - needs review, doesn't look right
• mergeAll - review MergeAll
• mergeDeepLeft - needs tests
• mergeDeepRight - needs tests
• mergeDeepWith - needs to be completely redone
• mergeDeepWithKey - needs to be completely redone
• mergeLeft - need tests
• mergeRight - need tests
• mergeWith- needs to be completely redone
• mergeWithKey- needs to be completely redone
• min - need tests
• minBy - better currying, tests
• modify - needs review, needs tests
• modulo - need tests
• move - double-check currying order, need tests
• multiply - need tests
• nAry - needs review
• negate - tests? (no real value)
• none - currying, tests, handle "method all" variant
• not - test? (no real value)
• nth - needs tests
• nthArg - could do a lot better, need to look into
• o - review currying, tests
• objOf - currying, tests
• of - test? (no real value)
• omit - currying, tests
• on - currying ordering needs to be reversed, type names could be better, tests
• once - needs tests
• or - usage of Falsy doesn't really apply in typings, review and add currying
• otherwise - currying, tests
• over - currying, tests
• pair - currying, tests
• partial - types cover arity 2 to 4, could do more, or find a fully automated way, return func should not be curried
• partialObject - needs full review
• partialRight - needs full review
• partition - string[] variety serves no purpose, curry and test
• path - currying, tests
• pathEq - needs to be overloaded like path, currying, tests
• pathOr - needs to be overloaded like path, currying, tests
• paths - will be extremely hard to overload, probably should just leave in it's most basic form, needs curry and test
• pathSatisfies - needs to be overloaded like path, currying, tests
• pick - K[] should be K keyof U, since properties that don't exist are ignored, it makes no sense to constrain this to only known keys. Return value Pick<> can be used directly in this case
• pickAll - needs full review
• pickBy - since returned keys are unknown at build time, return type should be just Partial<U>. Curry and Test
• pipe - spread variety needs to be fixed, tests
• pipeWith - needs full review
• pluck - needs review, most of the overloads are redundant, need to add Functor support
• prepend - currying, tests
• product - test? (no real value)
• project - can be redone using Pick<>, curry and test
• promap - support obj.promap variety, curry and test
• prop - needs tests
• propEq - currying, tests
• propIs - typing is very wrong, needs to be completely redo
• propOr - docs should say Idx, not String for key, typing should be K keyof U, needs curing and tests
• props - look into better way to type this
• propSatisfies - needs review, curry and test
• range - curry and test
• reduce - curry and test
• reduceBy - curry and test
• reduced - test? (no real value)
• reduceRight - needs Reduced<T> to return value of reducer func, curry and test
• reduceWhile - needs Reduced<T> to return value of reducer func, curry and test
• reject - needs full revue
• remove - curry and test
• repeat - curry and test
• replace - curry and test
• reverse - test? (no real value)
• scan - fix reduce function return type, currying and test
• set - curry and test
• sequence - MISSING
• slice - curry and test, handle "slice method" variant
• sort - curry and test, fn return type should be Ordering
• sortBy - curry and test
• sortWith - curry and test, fn return type should be Ordering
• split - curry and test
• splitAt - curry and test
• splitEvery - curry and test
• splitWhen - curry and test
• splitWhenever - curry and test
• startsWith - curry and test
• subtract - curry and test
• sum -test? (no real value)
• symmetricDifference - curry and test
• symmetricDifferenceWith - curry and test
• T - test? (no real value)
• tail - extends any in unnecessary, curry and test
• take - take<T>(n: number): (xs: readonly T[]) => T[] overload should be removed, curry and test, handle "take method" variation
• takeLast - tests
• takeLastWhile - curry and test
• takeWhile - curry and test
• tap - asserts a is R overload is completely wrong, curry and test
• test - curry and test
• thunkify - test? (no real value)
• times - curring and tests
• toLower - tests
• toPairs - need to review
• toPairsIn - need to review
• toString - test? (no real value)
• toUpper - tests
• transduce - need to review
• transpose - test? (no real value)
• traverse - handle "traverse method" variant, and review in general
• trim - test? (no real value)
• tryCatch - need to review
• type - test? (no real value)
• unapply - can infer typing for input function's array argument, tests
• unary - test
• uncurryN - need to review
• unfold - curry and test
• union - curry and test
• unionWith - curry and test
• uniq - test? (no real value)
• uniqBy - curry and test
• uniqWith - look into why there is a U in the generic, curry and test
• unless - curry and test
• unnest - since is the same as chain(identity) need to handle "chain method" variant. curry and test
• until - curry and test
• unwind - MISSING
• update - curry and test
• useWith - needs full review
• values - need to test ValueOfUnion,
• valuesIn - there is zero inference, that may be the way it should be, needs review
• view - curry and test
• when - need to review
• where - would make sense to constrain testObj to defined keys of spec, curry and test
• whereAny - MISSING
• whereEq - same issues as where
• without - curry and test
• xor - curry and test
• xprod - likely cannot restrict bs to have same length as as, curry and test
• zip - curry and test
• zipObj - curry and test
• zipWith - curry and test