Number and BigInt Predicates

import { match, P } from 'ts-pattern';
 
const fn = (input: number) =>
  match(input)
    .with(P.number.between(1, 5), () => '✅ Between 1 and 5')
    .otherwise(() => '❌ Outside range');
 
console.log(fn(3)); // ✅ Between 1 and 5
console.log(fn(1)); // ✅ Between 1 and 5 (inclusive)
console.log(fn(5)); // ✅ Between 1 and 5 (inclusive)
console.log(fn(7)); // ❌ Outside range

const fn = (input: number) =>
  match(input)
    .with(P.number.lt(0), () => 'Negative')
    .with(P.number.lt(10), () => 'Less than 10')
    .otherwise(() => '10 or greater');
 
console.log(fn(-5)); // Negative
console.log(fn(5)); // Less than 10
console.log(fn(15)); // 10 or greater

const fn = (input: number) =>
  match(input)
    .with(P.number.gt(100), () => 'Large number')
    .with(P.number.gt(0), () => 'Positive')
    .otherwise(() => 'Zero or negative');
 
console.log(fn(150)); // Large number
console.log(fn(50)); // Positive
console.log(fn(-10)); // Zero or negative

const fn = (input: number) =>
  match(input)
    .with(P.number.lte(0), () => 'Zero or negative')
    .otherwise(() => 'Positive');
 
console.log(fn(0)); // Zero or negative
console.log(fn(-5)); // Zero or negative
console.log(fn(5)); // Positive

const fn = (input: number) =>
  match(input)
    .with(P.number.gte(18), () => 'Adult')
    .otherwise(() => 'Minor');
 
console.log(fn(18)); // Adult
console.log(fn(25)); // Adult
console.log(fn(15)); // Minor

const fn = (input: number) =>
  match(input)
    .with(P.number.int(), () => 'Integer')
    .otherwise(() => 'Decimal');
 
console.log(fn(42)); // Integer
console.log(fn(-7)); // Integer
console.log(fn(3.14)); // Decimal

const fn = (input: number) =>
  match(input)
    .with(P.number.finite(), (n) => `Finite: ${n}`)
    .otherwise(() => 'Infinite');
 
console.log(fn(42)); // Finite: 42
console.log(fn(Infinity)); // Infinite
console.log(fn(-Infinity)); // Infinite

const fn = (input: number) =>
  match(input)
    .with(P.number.positive(), () => 'Positive')
    .otherwise(() => 'Zero or negative');
 
console.log(fn(5)); // Positive
console.log(fn(0)); // Zero or negative
console.log(fn(-5)); // Zero or negative

const fn = (input: number) =>
  match(input)
    .with(P.number.negative(), () => 'Negative')
    .otherwise(() => 'Zero or positive');
 
console.log(fn(-5)); // Negative
console.log(fn(0)); // Zero or positive
console.log(fn(5)); // Zero or positive

match(value)
  .with(P.bigint.between(0n, 100n), () => 'Small bigint')
  .with(P.bigint.gt(100n), () => 'Large bigint')
  .with(P.bigint.positive(), () => 'Positive bigint')
  .otherwise(() => 'Other');

match(age)
  .with(
    P.number.int().positive().gte(18).lte(65),
    () => 'Working age adult'
  )
  .otherwise(() => 'Other');

type Product = {
  price: number;
  stock: number;
};
 
match(product)
  .with(
    {
      price: P.number.positive().lt(100),
      stock: P.number.gt(0),
    },
    (p) => 'Affordable and in stock'
  )
  .with(
    { stock: P.number.lte(0) },
    () => 'Out of stock'
  )
  .otherwise(() => 'Expensive');

match(data)
  .with(
    { score: P.number.between(90, 100).select() },
    (score) => {
      // score: number (between 90 and 100)
      return `A grade: ${score}`;
    }
  )
  .otherwise(() => 'Lower grade');

match(temperatures)
  .with(
    P.array(P.number.between(20, 25)),
    (temps) => 'All comfortable temperatures'
  )
  .otherwise(() => 'Mixed temperatures');

type User = { age: number };
 
const validateAge = (user: User) =>
  match(user)
    .with(
      { age: P.number.int().gte(0).lte(120) },
      () => ({ valid: true })
    )
    .otherwise(() => ({ valid: false, error: 'Invalid age' }));

type PriceRange = 'budget' | 'mid' | 'premium';
 
const getPriceRange = (price: number): PriceRange =>
  match(price)
    .with(P.number.lt(50), () => 'budget' as const)
    .with(P.number.between(50, 200), () => 'mid' as const)
    .with(P.number.gt(200), () => 'premium' as const)
    .exhaustive();

const handleStatus = (code: number) =>
  match(code)
    .with(P.number.between(200, 299), () => 'Success')
    .with(P.number.between(300, 399), () => 'Redirect')
    .with(P.number.between(400, 499), () => 'Client Error')
    .with(P.number.between(500, 599), () => 'Server Error')
    .otherwise(() => 'Unknown');

type Temperature = { celsius: number };
 
const describeTemperature = (temp: Temperature) =>
  match(temp)
    .with(
      { celsius: P.number.lt(0) },
      () => 'Freezing'
    )
    .with(
      { celsius: P.number.between(0, 15) },
      () => 'Cold'
    )
    .with(
      { celsius: P.number.between(15, 25) },
      () => 'Comfortable'
    )
    .with(
      { celsius: P.number.gt(25) },
      () => 'Hot'
    )
    .exhaustive();

type PaginationParams = {
  page: number;
  pageSize: number;
};
 
const validatePagination = (params: PaginationParams) =>
  match(params)
    .with(
      {
        page: P.number.int().positive(),
        pageSize: P.number.int().between(1, 100),
      },
      (p) => ({ valid: true, params: p })
    )
    .otherwise(() => ({ valid: false, error: 'Invalid pagination' }));

const getGrade = (score: number) =>
  match(score)
    .with(P.number.between(90, 100), () => 'A')
    .with(P.number.between(80, 89), () => 'B')
    .with(P.number.between(70, 79), () => 'C')
    .with(P.number.between(60, 69), () => 'D')
    .with(P.number.lt(60), () => 'F')
    .otherwise(() => 'Invalid score');