Browse the library

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;
 

class Typed:
    """A data descriptor that enforces a type and optional validation."""
 
    def __init__(self, expected_type, validator=None):

import java.util.*;
 
public class TopologicalSort {
 

package handlers
 
import (
	"net/http"

// Sliding window maximum using a monotonic decreasing deque.
// Returns an array of the maximum value within each window of size k.
function maxSlidingWindow(nums, k) {
  const result = [];

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

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

from collections import Counter
 
 
def word_frequencies(text):

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

package main
 
import "fmt"
 

use std::thread;
 
pub fn parallel_map_reduce<T, M, R, F, G, H>(
    data: &[T],

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"