Intermediate code explainers

# 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.

<?php
 
class Entity
{

/// A custom iterator that yields Fibonacci numbers up to a maximum value.
pub struct Fibonacci {
    current: u64,
    next: u64,

from collections import deque
 
 
def bfs(graph, start):

package middleware
 
import (
	"net/http"

function depthFirstSearch(graph, start) {
  const visited = new Set();
  const order = [];
 

// A module-scoped Singleton: the single instance lives in this module's
// closure and is never exposed directly.
 
interface AppConfig {

class ThreadSafeCounter
  def initialize(initial = 0)
    @count = initial
    @mutex = Mutex.new

<?php
 
namespace App\Models;
 

import java.util.*;
 
public class TopologicalSort {
 

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 

interface RetryOptions {
  retries?: number;
  baseDelayMs?: number;
  maxDelayMs?: number;

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

package main
 
import "fmt"
 

import java.util.Arrays;
 
public class SlidingWindow {
    // Returns the maximum sum of any contiguous subarray of length k.

def two_sum_sorted(numbers, target):
    """Find indices of two values that sum to target in a sorted array."""
    left, right = 0, len(numbers) - 1
    while left < right:

package main
 
import "sync"
 

# Binary search using Ruby's built-in Array#bsearch.
#
# There are two modes:
#   1. find-minimum mode  -> block returns true/false (monotonic)