identity

import { identity } from '@accelint/core';

// Returns the same value
identity(4); // 4
identity('hello'); // 'hello'
identity([1, 2, 3]); // [1, 2, 3]

function identity<A>(x: A): A

import { identity, map } from '@accelint/core';

const numbers = [1, 2, 3, 4, 5];

// Identity mapping - returns a shallow copy
const copy = map(identity)(numbers);
// [1, 2, 3, 4, 5]

import { identity, filter } from '@accelint/core';

const mixed: (number | null | undefined)[] = [1, null, 2, undefined, 3, 0, 4];

// Filter truthy values
const truthy = filter(identity)(mixed);
// [1, 2, 3, 4] (removes null, undefined, and 0)

import { identity, pipe } from '@accelint/core';

// Identity is the neutral element for composition
const double = (x: number) => x * 2;

// compose(identity, f) === f
pipe(identity, double)(5); // 10
pipe(double, identity)(5); // 10

import { identity } from '@accelint/core';

function transform<T>(
  value: T,
  shouldTransform: boolean,
  transformer: (v: T) => T
): T {
  return shouldTransform ? transformer(value) : identity(value);
}

transform(10, true, (x) => x * 2); // 20
transform(10, false, (x) => x * 2); // 10

import { identity } from '@accelint/core';

// Identity can help with type narrowing
const value: unknown = 'hello';

// Type assertion
const str = identity(value as string);
// str: string

import { identity } from '@accelint/core';

interface Config {
  transform?: <T>(value: T) => T;
}

const config: Config = {
  // Use identity as default transform (no-op)
  transform: identity
};

const result = config.transform?.(42) ?? 42;
// 42