JavaScript

const user = {
  profile: {
    name: "Marcus",
    address: {
      city: "Berlin",
      zip: "10115"
    }
  },
  getSubscription: () => ({
    plan: "pro",
    features: ["analytics", "exports"]
  })
};

const city       = user?.profile?.address?.city;
const country    = user?.profile?.address?.country?.toUpperCase();
const firstFeature = user?.getSubscription?.()?.features?.[0];
const adminRole  = user?.roles?.[0]?.name ?? "guest";

console.log(city, country, firstFeature, adminRole);

function createUser(
  name,
  role = "viewer",
  permissions = { read: true, write: false },
  level = permissions.write ? 2 : 1
) {
  return { name, role, permissions, level };
}

const user1 = createUser("Carlos");
const user2 = createUser("Diana", "editor", { read: true, write: true });
const user3 = createUser("Eve", "admin", undefined, 5);

console.log(user1.role, user1.level);
console.log(user2.role, user2.level);
console.log(user3.role, user3.level);

const flags = {
  READ:    0b0001,
  WRITE:   0b0010,
  EXECUTE: 0b0100,
  DELETE:  0b1000,
};

const userPermissions = flags.READ | flags.WRITE | flags.EXECUTE;
const adminPermissions = userPermissions | flags.DELETE;

const canDelete = (adminPermissions & flags.DELETE) !== 0;
const readOnly  = userPermissions & ~flags.WRITE;

const toggled = userPermissions ^ flags.EXECUTE;
const shifted = (flags.DELETE << 2) | (flags.READ >> 0);

console.log(canDelete, readOnly, toggled, shifted);

const obj = {
  name: "Quantum",
  regular: function () {
    return this.name;
  },
  arrow: () => {
    return this?.name;
  },
  nested: function () {
    const inner = () => this.name;
    return inner();
  },
};

console.log(obj.regular());
console.log(obj.arrow());
console.log(obj.nested());

const curry = (fn) => {
  const arity = fn.length;
  return function curried(...args) {
    if (args.length >= arity) {
      return fn(...args);
    }
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
};

const volume = (l, w, h) => l * w * h;
const curriedVolume = curry(volume);

const withLength5 = curriedVolume(5);
const withLength5Width3 = withLength5(3);

console.log(typeof withLength5);
console.log(typeof withLength5Width3);
console.log(withLength5Width3(2));
console.log(curriedVolume(5)(3)(2) === withLength5(3)(2));

console.log('start');

setTimeout(() => console.log('timeout 1'), 0);

Promise.resolve()
  .then(() => {
    console.log('promise 1');
    setTimeout(() => console.log('timeout 2'), 0);
  })
  .then(() => console.log('promise 2'));

setTimeout(() => console.log('timeout 3'), 0);

queueMicrotask(() => console.log('microtask'));

console.log('end');

class Pipeline {
  #value;
  #steps = [];

  constructor(value) {
    this.#value = value;
  }

  map(fn) {
    this.#steps.push({ type: 'map', fn });
    return this;
  }

  filter(fn) {
    this.#steps.push({ type: 'filter', fn });
    return this;
  }

  execute() {
    return this.#steps.reduce((acc, step) => {
      if (step.type === 'map') return acc.map(step.fn);
      if (step.type === 'filter') return acc.filter(step.fn);
      return acc;
    }, this.#value);
  }
}

const result = new Pipeline([1, 2, 3, 4, 5, 6])
  .filter(x => x % 2 === 0)
  .map(x => x ** 2)
  .filter(x => x > 10)
  .map(x => x - 1)
  .execute();

console.log(result);

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);

const double = x => x * 2;
const addTen = x => x + 10;
const square = x => x ** 2;
const negate = x => -x;

const transform1 = compose(negate, square, addTen, double);
const transform2 = pipe(negate, square, addTen, double);

console.log(transform1(3));
console.log(transform2(3));