Composition interview questions

Implement a function that composes functions right-to-left so the output of each feeds into the next.

Run async tasks in sequence, feeding each result into the next, stopping the chain on the first rejection.

Implement a simplified cva that builds class names from base styles, variant tables, and default values.

Implement a function that transforms a multi-argument function into a chain of single-argument calls.

Implement flow — compose functions left to right so each output feeds the next.

Build a schema-driven form validator with composable per-field rules, cross-field checks, and async validators that report all errors.

Build an axios-style client whose request and response interceptors transform each call as it passes through the chain.

Build a Redux core with createStore, combineReducers, and applyMiddleware over a subscribe/dispatch loop.

Implement negate, overEvery, and overSome — build new predicates by combining existing ones.

Implement a function that combines the results of two promises into a single value using a merger function.

Implement the curried Redux middleware chain with working thunk and logger middleware.

Implement a small schema library that validates primitives and flat object shapes with composable rules.

Build a tiny schema validation library that supports chainable min and max rules on primitive types.

Build a tabs component that shows one panel at a time based on the currently selected tab.

Build a small test runner that supports nested describe suites and reports tests with their full spec names.

Extend a tiny test runner with beforeEach and afterEach hooks that are inherited from outer suites.

Build a generic, reusable data table that supports column-driven sorting and pagination for any dataset.

Build an in-memory query builder inspired by Drizzle with table helpers, filters, sorting, and pagination.

Extend an in-memory query builder inspired by Drizzle with select projections and column aliases.

Implement an async middleware composer that chains functions Koa-style, threading a shared context through next.