Code explainers tagged #async

use axum::{extract::{Path, State}, http::StatusCode, Json};
use dashmap::DashMap;
use serde::Serialize;
use std::sync::Arc;

from functools import wraps
import asyncio
 
from fastapi import APIRouter, FastAPI, Request

export async function copyToClipboard(text: string): Promise<boolean> {
  if (navigator.clipboard && window.isSecureContext) {
    try {
      await navigator.clipboard.writeText(text);

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,

import { useEffect, useState } from 'react';
 
export function useJobStatus(jobId, { interval = 3000 } = {}) {
  const [status, setStatus] = useState('pending');

import slugify from "slugify";
 
interface SlugRepository {
  exists(slug: string): Promise<boolean>;

use axum::{
    body::Body,
    extract::State,
    http::{header, StatusCode},

public class RequestCoalescer<K, V> {
 
    private final ConcurrentHashMap<K, CompletableFuture<V>> inFlight = new ConcurrentHashMap<>();
    private final Function<K, V> loader;

import logging
import uuid
from contextvars import ContextVar
 

use std::sync::Arc;
use std::time::Duration;
 
use axum::{

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

class InfiniteScroll {
  constructor(sentinel, { loadMore, root = null, rootMargin = '200px' } = {}) {
    this.sentinel = sentinel;
    this.loadMore = loadMore;

import { useState, useCallback } from 'react';
 
type Todo = {
  id: string;

use axum::{
    body::{Body, Bytes},
    extract::Request,
    http::StatusCode,

use axum::{
    extract::State,
    response::sse::{Event, KeepAlive, Sse},
};

import { db } from '@/lib/db'
 
const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? 'https://example.com'
 

final class DebouncedSessionStore
{
    private array $pending = [];
    private array $timers = [];

use std::collections::HashSet;
use std::path::PathBuf;
use std::time::Duration;