I’ve oft thought JSX an under-utilized syntax. In the current day, JSX is cruelly relegated to frontend component architectures. In my view, there’s much to explore re using JSX as a way to represent other interesting things.
React is a library for declaratively specifying user interfaces. Jotai is a complementary library for declaratively modeling state in a monadic way. When these are used purposefully, what arises is a very sane MVC architecture built with boring technology [1].
As part of my efforts on ts-unify, I needed a way to represent ‘capturing’ and transforming values in a data structure from one form to another. This article elucidates those extraction semantics.
I’ve been playing with codemod transformations for TypeScript using
jscodeshift (from Facebook) and
ts-pattern. Working closely with
these has made me want a declarative type-aware codemod engine for TypeScript,
which I haven’t yet been able to find.
This interactive tool demonstrates a steganographic technique using Unicode variation selectors (U+E0100-U+E017F) to encode hidden text within visible strings. By mapping ASCII characters to these invisible codepoints, messages can be embedded undetected - a potential vector for prompt injection attacks whereby LLMs may process hidden instructions.
The hkt-toolbelt library introduces kind reification - transforming abstract type-level functions into concrete runtime signatures. This enables point-free programming where compositions like Pipe<[Map<Inc>, Filter<IsEven>, Reduce<Add>]> become executable functions with 1:1 corresponding types. By bridging TypeScript’s type system with runtime code, we can write type-level pipelines that are both type-safe and actually invokable.
to reify: make (something abstract) more concrete or real.
Implementing point-free (tacit) programming patterns in TypeScript using Higher Kinded Types to overcome traditional type system limitations. Point-free style eliminates explicit arguments, composing functions like pipe(map(inc), filter(isEven), reduce(add)) instead of x => x.map(inc).filter(isEven).reduce(add). Through HKT encodings, we achieve true tacit programming where type inference flows through the entire pipeline, enabling cleaner functional abstractions without sacrificing TypeScript’s type safety.
Extending Higher Kinded Types with variadic composition patterns, enabling clean functional composition while preserving complete type information. Building on HKT foundations, this explores variadic compositions where Compose<[F, G, H, ...]> handles arbitrary function chains with full type inference. Using advanced tuple manipulation and distributive conditional types, we achieve compositions like pipe(map, flatten, filter, reduce) that maintain type safety across any number of transformations - a significant advancement in TypeScript’s functional programming capabilities.
A comprehensive introduction to Higher Kinded Types in TypeScript, exploring how to encode and utilize these powerful abstractions from functional programming. HKTs enable type constructors that take other type constructors as arguments - imagine Functor<F> that works for any F<T> whether it’s Array<T>, Promise<T>, or Option<T>. Through encoding techniques using interface augmentation and symbol keys, we can simulate HKTs in TypeScript, making possible advanced functional patterns like monadic composition and type-safe algebraic structures previously impossible in the language.
Building composable type guard systems in TypeScript where runtime validation seamlessly integrates with compile-time type narrowing. Type guards like isString(x): x is string enable safe runtime checks, but composing them requires careful design. This explores combinators for union guards or(isNumber, isString): x is number | string, intersection guards and(hasName, hasAge): x is Person, and variadic patterns that preserve type inference. The result: elegant runtime validation that TypeScript’s control flow fully understands.