Code explainers tagged #higher-order-functions

class Pipeline
  def initialize
    @middlewares = []
  end

type AsyncMethod = (...args: any[]) => Promise<any>;
 
function LogExecutionTime(thresholdMs = 0) {
  return function <T extends AsyncMethod>(

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);

type SortDirection = "asc" | "desc";
 
interface SortKey<T> {
  selector: (row: T) => string | number | Date | null | undefined;

function memoize(fn, resolver) {
  const cache = new Map();
 
  function memoized(...args) {

function makeTableSorter(rows) {
  const state = { key: null, dir: 1 };
 
  const compareBy = (key) => (a, b) => {

import { inject } from '@angular/core';
import {
  CanActivateFn,
  Router,

const { validationResult, matchedData } = require('express-validator');
 
function validate(schema) {
  const runners = schema.map((rule) => rule.run.bind(rule));

const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};
 

function memoize(callable $fn): callable
{
    $cache = [];
 

function groupBy(items, keySelector) {
  const resolveKey = typeof keySelector === 'function'
    ? keySelector
    : (item) => item[keySelector];

interface TokenBucketOptions {
  capacity: number;
  refillPerSecond: number;
}

from collections import OrderedDict
from typing import Callable, Hashable, Iterable, Iterator, TypeVar
 
T = TypeVar("T")

<?php
 
namespace App\Support;
 

# Curry a multi-argument lambda so it can be applied one argument at a time.
add = ->(a, b, c) { a + b + c }
 
# Proc#curry returns a curried version that collects arguments incrementally.

function debounce(fn, delay) {
  let timeoutId = null;
 
  function debounced(...args) {

function throttle(fn, wait) {
  let lastCall = 0;
  let timeoutId = null;
  let lastArgs = null;