Implementing Functions

Steps

1. Data first: Accept data as the first parameter
2. Curry when sensible: Typically for 2-parameter functions
3. Provide both curried variants for most functions

Reference

Currying Pattern

// Base function - data first
export const split = (value: string, separator: string): string[] => { ... }

// *On variant - data first, returns function waiting for second arg
export const splitOn = Fn.curry(split)
// Usage: Str.splitOn(data)(separator)

// *With variant - flipped, returns function waiting for data
export const splitWith = Fn.flipCurried(Fn.curry(split))
// Usage: Str.splitWith(separator)(data)

When to Use Each Variant

*On

const data = 'name,age,city'
const splitData = Str.splitOn(data)
splitData(',')  // ['name', 'age', 'city']
splitData('')   // individual chars

*With

const splitByComma = Str.splitWith(',')
splitByComma('john,25')     // ['john', '25']
splitByComma('laptop,999')  // ['laptop', '999']

Universal Operations

Maintain consistent names across data structures:

merge

Arr.merge

Obj.merge

Str.merge

by

Group.by(array, 'field')

is

Arr.is

Obj.is

Undefined.is

Namespace Name Elision

Do NOT repeat the namespace name in function names:

// Correct
Group.by(array, key)
Undefined.is(value)
Str.merge(a, b)

// Incorrect
Group.groupBy(array, key)
Undefined.isUndefined(value)

Type-Level Transformations

Prefer conditional types over function overloads for type mappings:

// ✅ Good - Type-level transformation
type Abs<T extends number> =
  T extends Negative ? Positive :
  T extends NonPositive ? NonNegative :
  NonNegative

const abs = <T extends number>(value: T): Abs<T> => ...

// ❌ Avoid - Function overloads
function abs(value: Negative): Positive
function abs(value: NonPositive): NonNegative
function abs(value: number): NonNegative

Benefits: Cleaner API, better type inference, easier to maintain.

Notes

• Some functions have only data parameters → only

  *On

  variant needed
• Functions with >2 parameters: currying less common, use judgment
• Data-first enables natural left-to-right composition