@ibnlanre/types

In TypeScript, the type system provides a powerful tool for developers to ensure type safety and predictability in their code. One such feature is the ability to create parameterized interfaces and types, which can be used to model complex behaviors such as function composition.

The core concept revolves around the Fn interface, a parameterized interface that represents a function with arguments and a return value. The Fn interface uses TypeScript's unknown type, which is a type-safe counterpart of the any type. The unknown type is useful in this context because when it is used in an intersection type (e.g., unknown & {}), it is replaced by the other part of the intersection.

This behavior allows for the creation of complex types that represent composed functions, where the output of one function is the input of another. By leveraging TypeScript's advanced type features, we can create type-safe representations of function composition, leading to more predictable and reliable code.

Installation

npm install @ibnlanre/types

Usage

The library provides two types of interfaces: those starting with "T" and those without the "T". The interfaces without the "T" are base interfaces that can be used as normal generics. Some of them can accept a parameterized function as an argument. On the other hand, the interfaces starting with "T" are pre-built function models that extend the Fn interface. These pre-built models can be used to create complex and type-safe function compositions.

The typescript playground url for the following example is here.

Let's dive in! 🚀

import {
  Map,
  Pipe,
  TAdd,
  TAppend,
  TJoin,
  TMap,
  TMultiply,
  TParseInt,
  TRange,
  TSliceTo,
  TStringify,
  TSubtraction,
  TWith,
} from "@ibnlanre/types";

type Test1 = Pipe<
  // ^? type Test1 = "🔥 HotScript 📜"
  7,
  [
    TRange<1>, // [1, 2, 3, 4, 5, 6, 7]
    TSliceTo<2>, // [1, 2]
    TWith<0, "🔥">, // ["🔥", 2]
    TWith<1, "📜">, // ["🔥", "📜"]
    TJoin<" HotScript "> // "🔥 HotScript 📜"
  ]
>;

type Test2 = Pipe<
  //  ^? type Test2 = -223
  [1, 2, 3, 4, 5],
  [
    TMap<TAdd<3>>, // [4, 5, 6, 7, 8]
    TMap<TStringify>, // ["4", "5", "6", "7", "8"]
    TMap<TAppend<"1">>, // ["41", "51", "61", "71", "81"]
    TMap<TParseInt>, // [14, 15, 16, 17, 18]
    TSubtraction // -223
  ]
>;

type Test3 = Map<TMultiply<3>, [1, 2, 3, 4]>;
//   ^? type Test3 = [3, 6, 9, 12]

Other TypeScript Type Libraries

• ts-toolbelt: 👷 TypeScript's largest type utility library
• hotscript: A library of composable functions for the type-level!
• type-fest: A collection of essential TypeScript types
• type-zoo: A menagerie of useful type operators for TypeScript
• type-plus: More than 200 type utilities for TypeScript.
• ts-arithmetic: Basic arithmetic operations at the Type Level.
• ts-calc: Compute with typescript type system.
• tsmath: Math in the TypeScript type system.
• ts-essentials: All essential TypeScript types in one place 🤙
• conditional-type-checks: Reusable conditional types to help test your types.
• simply-typed: Yet another typing library.
• ts-expect: Checks values in TypeScript match expectations.
• type-level-regexp: TypeScript type-level RegExp parser and matcher.
• just-types: A collection of handy Typescript types.
• type-space: A suite of utility types for enhancing your TypeScript code.
• readonly-types: A collection of readonly TypeScript types.
• utilitypes: Provides supplementary TypeScript types
• utility-types: A collection of very useful TypeScript type declarations
• type2type: Data structures implemented in TypeScript type system
• type-sort: Sorting algorithm implemented using only TypeScript types
• ts-types-utils: Type utilities for typescript
• extended-typescript-types: Collection of generic types for TypeScript
• utility-types: Collection of utility types, complementing TypeScript built-in mapped types
• typescript-helper-types: Random Typescript types
• typepark: A new type collection offering tuple manipulation and Pipe.
• typelevel-ts: Type level programming in TypeScript.
• typical: A playground of type-level operations for TypeScript.
• common-types: Tiny library of simple Typescript typings which are highly reusable
• type-helpers: Useful common Typescript types.
• @gilbarbara/types: Reusable typescript typings.
• typeroo: TypeScript types collection.

Worth the read

• Implementing Advanced Type-Level Arithmetic in TypeScript part 1
• Implementing Advanced Type-Level Arithmetic in TypeScript part 2