lens

import { lens, get, set, lensProp, composeLens } from '@accelint/core';

interface Person {
  name: string;
  address: {
    city: string;
    street: string;
  };
}

const person: Person = {
  name: 'Alice',
  address: {
    city: 'New York',
    street: '123 Main St'
  }
};

// Create a simple lens
const nameLens = lensProp<Person>()('name');

get(nameLens)(person);
// 'Alice'

const updated = set(nameLens)('Bob')(person);
// { name: 'Bob', address: { ... } }

// Compose lenses for nested access
const addressLens = lensProp<Person>()('address');
const cityLens = lensProp<Address>()('city');
const personCityLens = composeLens(addressLens, cityLens);

get(personCityLens)(person);
// 'New York'

function lens<T, V>(
  getter: (source: T) => V,
  setter: (source: T) => (value: V) => T
): Lens<T, V>

type Lens<T, V> = {
  get: (source: T) => V;
  set: (source: T) => (value: V) => T;
};

function composeLens<A, B, C>(
  ab: Lens<A, B>,
  bc: Lens<B, C>
): Lens<A, C>

function get<T, V>(lensVal: Lens<T, V>): (obj: T) => V

function set<T, V>(lensVal: Lens<T, V>): (value: V) => (obj: T) => T

function lensProp<T extends object>(): <K extends keyof T>(prop: K) => Lens<T, T[K]>

function lensOptionalProp<T extends object>(): <K extends keyof T>(prop: K) => Lens<T, T[K] | undefined>

import { lens, property, associateDeep } from '@accelint/core';

interface User {
  id: number;
  email: string;
}

const emailLens = lens(
  (user: User) => property(user)('email'),
  (user) => (email) => associateDeep(user)('email')(email)
);

const user = { id: 1, email: 'old@example.com' };

emailLens.get(user);
// 'old@example.com'

emailLens.set(user)('new@example.com');
// { id: 1, email: 'new@example.com' }

import { lensProp, composeLens, get, set } from '@accelint/core';

interface Address {
  city: string;
  zipCode: string;
}

interface Person {
  name: string;
  address: Address;
}

const addressLens = lensProp<Person>()('address');
const cityLens = lensProp<Address>()('city');

// Compose to access nested city
const personCityLens = composeLens(addressLens, cityLens);

const person: Person = {
  name: 'Alice',
  address: { city: 'New York', zipCode: '10001' }
};

get(personCityLens)(person);
// 'New York'

set(personCityLens)('San Francisco')(person);
// { name: 'Alice', address: { city: 'San Francisco', zipCode: '10001' } }

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

interface User {
  name: string;
}

const nameLens = lensProp<User>()('name');
const user = { name: 'Alice' };

// Law 1: SetGet - Getting after setting returns the set value
nameLens.get(nameLens.set(user)('Bob'));
// 'Bob'

// Law 2: GetSet - Setting with the current value doesn't change the object
nameLens.set(user)(nameLens.get(user));
// { name: 'Alice' } (structurally equal to user)

// Law 3: SetSet - Setting twice is same as setting once with the final value
nameLens.set(nameLens.set(user)('Bob'))('Charlie');
// Equivalent to:
nameLens.set(user)('Charlie');

import { lensProp, composeLens, get } from '@accelint/core';

interface City { name: string; }
interface Address { city: City; }
interface Person { address: Address; }
interface User { profile: Person; }

const user: User = {
  profile: {
    address: {
      city: { name: 'Boston' }
    }
  }
};

const profileLens = lensProp<User>()('profile');
const addressLens = lensProp<Person>()('address');
const cityLens = lensProp<Address>()('city');
const cityNameLens = lensProp<City>()('name');

// Compose all the way down
const userCityNameLens = composeLens(
  composeLens(
    composeLens(profileLens, addressLens),
    cityLens
  ),
  cityNameLens
);

get(userCityNameLens)(user);
// 'Boston'

import { lensOptionalProp, get } from '@accelint/core';

interface User {
  name: string;
  email?: string;
}

const emailLens = lensOptionalProp<User>()('email');

const withEmail = { name: 'Alice', email: 'alice@example.com' };
const withoutEmail = { name: 'Bob' };

get(emailLens)(withEmail);
// 'alice@example.com'

get(emailLens)(withoutEmail);
// undefined