Throttle a function call snippet

function throttle(fn, ms) {
  let lastRun = 0;                      // the surviving state
  return function throttled(...args) {
    const now = Date.now();
    if (now - lastRun >= ms) {          // window open → fire now (leading)
      lastRun = now;
      fn(...args);
    }
    // inside the window: dropped on the floor
  };
}

const onScroll = throttle(() => render(), 100);
window.addEventListener('scroll', onScroll);

export function throttle<F extends (...args: any[]) => void>(
  fn: F,
  ms: number,
) {
  let lastRun = 0; // per-instance: one gate per throttle() call
  const throttled = (...args: Parameters<F>) => {
    const now = Date.now();
    if (now - lastRun >= ms) {
      lastRun = now;
      fn(...args);
    }
  };
  throttled.cancel = () => { lastRun = Infinity; }; // freeze the gate shut
  return throttled;
}

import (
	"sync"
	"time"
)

type Throttle struct {
	mu       sync.Mutex
	interval time.Duration
	last     time.Time
}

// allow reports whether this event may run; the winner records its time.
func (t *Throttle) allow() bool {
	t.mu.Lock()
	defer t.mu.Unlock()
	now := time.Now()
	if t.last.IsZero() || now.Sub(t.last) >= t.interval {
		t.last = now // leading edge: first event always passes
		return true
	}
	return false
}

// scroll storm:
//	if t.allow() { render() }

use std::sync::Mutex;
use std::time::{Duration, Instant};

struct Throttle {
    interval: Duration,
    last: Mutex<Option<Instant>>, // None = never fired
}

impl Throttle {
    fn new(interval: Duration) -> Self {
        Throttle { interval, last: Mutex::new(None) }
    }

    /// true when this event may run (leading edge).
    fn allow(&self) -> bool {
        let mut last = self.last.lock().unwrap();
        match *last {
            Some(t) if t.elapsed() < self.interval => false,
            _ => {
                *last = Some(Instant::now());
                true
            }
        }
    }
}

// Shared-nothing PHP keeps no closure state between requests, so the
// timestamp lives in a cache keyed by WHAT you are throttling.
function throttled(string $key, callable $fn, int $ms): mixed
{
    $now = (int) (microtime(true) * 1000);
    $success = false;
    $last = apcu_fetch("throttle:{$key}", $success);

    if ($success && $now - $last < $ms) {
        return null;                     // inside the window — drop
    }
    // TTL just above the window: a crashed request cannot wedge the key
    apcu_store("throttle:{$key}", $now, intdiv($ms, 1000) + 1);
    return $fn();
}

// one email per user per minute:
// throttled("email:{$userId}", fn() => $mailer->send($draft), 60_000);

import time

def throttle(interval):
    """Leading-edge gate: first call runs, the rest drop until the interval passes."""
    last_run = 0.0                     # one gate per @throttle line

    def decorator(fn):
        def wrapped(*args, **kwargs):
            nonlocal last_run
            now = time.monotonic()     # NOT time.time() — wall clock jumps
            if now - last_run >= interval:
                last_run = now
                return fn(*args, **kwargs)
            return None
        return wrapped
    return decorator

@throttle(0.1)
def on_scroll(event):
    render(event)

using System;
using System.Threading;

sealed class Throttle
{
    private readonly long _intervalMs;
    private long _last = long.MinValue;          // sentinel: never run

    public Throttle(TimeSpan interval) => _intervalMs = (long)interval.TotalMilliseconds;

    /// true when this event may run (leading edge).
    public bool Allow()
    {
        long now = Environment.TickCount64;       // ms, monotonic
        long last = Interlocked.Read(ref _last);
        if (last != long.MinValue && now - last < _intervalMs) return false;
        // exactly one caller wins each opened window:
        return Interlocked.CompareExchange(ref _last, now, last) == last;
    }
}

import java.util.concurrent.atomic.AtomicReference;

class Throttle {
    private final long intervalNanos;
    private final AtomicReference<Long> last = new AtomicReference<>();

    Throttle(long intervalMs) { this.intervalNanos = intervalMs * 1_000_000; }

    /** true when this event may run (leading edge). */
    boolean allow() {
        while (true) {
            Long prev = last.get();
            long now = System.nanoTime();          // monotonic
            if (prev != null && now - prev < intervalNanos) {
                return false;                      // inside the window
            }
            if (last.compareAndSet(prev, now)) {   // one winner per window
                return true;
            }
            // lost the race — re-read and re-check
        }
    }
}

import QuartzCore

final class Throttle {
    private let interval: Double
    private var lastRun = 0.0            // CACurrentMediaTime — monotonic

    init(seconds: Double) { interval = seconds }

    /// true when this event may run (leading edge). Keep to one thread/actor.
    func allow() -> Bool {
        let now = CACurrentMediaTime()
        guard now - lastRun >= interval else { return false }
        lastRun = now
        return true
    }
}

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.launch

// The channel IS the gate: capacity 1 + DROP_OLDEST collapses the storm
// to "the newest unconsumed event"; the collector's own pace is the interval.
val events = Channel<ScrollEvent>(
    capacity = 1,
    onBufferOverflow = BufferOverflow.DROP_OLDEST,
)

// producer (the storm) — never suspends, never throws, drops when full:
// events.trySend(e)

fun CoroutineScope.startHandler() = launch {
    for (event in events) {
        render(event)      // while this runs, newer events replace older ones
    }
}

def throttle(interval, &block)
  last_run = nil
  lambda do |*args|
    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
    if last_run.nil? || now - last_run >= interval
      last_run = now
      block.call(*args)
    end # inside the window: dropped
  end
end

on_scroll = throttle(0.1) { |e| render(e) }

const std = @import("std");

/// Leading-edge gate: check-and-set one millisecond timestamp under a mutex.
const Throttle = struct {
    mutex: std.Thread.Mutex = .{},
    last_ms: i64 = 0, // 0 = never ran
    interval_ms: i64,

    fn allow(t: *Throttle) bool {
        t.mutex.lock();
        defer t.mutex.unlock();
        const now = std.time.milliTimestamp();
        if (t.last_ms == 0 or now - t.last_ms >= t.interval_ms) {
            t.last_ms = now;
            return true;
        }
        return false;
    }
};