Subject: Urgent: Heating Repair Required – Unit [Your Unit Number] – 3 Weeks Without Heat

Dear [Landlord's Name / Property Manager's Name],

I am writing to formally request the immediate repair of the heating system in my unit, [Unit Number]. As of today, the heating has been non-functional for three weeks (since [Date of initial report]).

Despite my previous requests on [Date 1] and [Date 2], the issue remains unresolved. Current indoor temperatures are hovering around [Current Temp]°F, which is well below the [State/City] legal requirement for habitable premises (typically 68°F during the day/55°F–65°F at night).

This is no longer a maintenance inconvenience; it is a health and safety issue and a breach of the implied warranty of habitability / our lease agreement.

I am not looking to escalate this dispute, but I need a concrete resolution immediately. Please confirm by 5:00 PM on [Date - 2 business days from now] the following:

1. The specific date and time a licensed HVAC technician will be on-site to complete the repair.

2. The name and contact information of the company dispatched.

If the repair cannot be completed within 48 hours of your receipt of this email, I will need to discuss temporary alternative accommodations (such as a hotel stay) at your expense, or pursue the remedies available to me under [State] landlord-tenant law, including repair-and-deduct or rent abatement procedures.

I value being a reliable tenant and I want to resolve this cooperatively. Please treat this as the urgent priority it is.

Sincerely,

[Your Full Name] [Your Phone Number] [Your Unit Number] [Date]

Attachments (Highly Recommended)

• [ ] Photos/Videos of thermostat reading vs. actual room temperature (timestamped).

• [ ] Screenshots/Copies of previous communication (emails, texts, portal tickets) reporting the issue.

• [ ] Copy of relevant local housing code excerpt regarding minimum heat requirements.

Why this works

• Paper Trail: "Formally request," "confirm by [date]," and "receipt of this email" create legal evidence.

• Specifics: Mentioning the exact indoor temperature and the legal code requirement shifts this from "complaining" to "citing a violation."

• Deadline: The 48-hour/2-business-day deadline forces action without sounding like a tantrum.

• Exit Ramp: Explicitly stating "I am not looking to escalate... I want to resolve this cooperatively" signals you are reasonable, making them more likely to fix it to avoid the legal remedies you calmly listed.

Here is a robust, type-safe useDebounce hook.

It handles cleanup on unmount (canceling the pending timeout), supports leading/trailing edge execution (like Lodash), and correctly types the callback using Parameters<T> so you don't lose argument types.

import { useEffect, useRef, useCallback } from 'react';

interface UseDebounceOptions {
  /** Fire on the leading edge (first call) instead of trailing (last call). Default: false */
  leading?: boolean;
  /** Fire on the trailing edge (last call). Default: true */
  trailing?: boolean;
}

/**
 * Debounces a callback function.
 * 
 * @param callback The function to debounce.
 * @param delay Milliseconds to wait.
 * @param options Configuration for leading/trailing edge.
 * @returns A debounced version of the callback with a `.cancel()` method.
 */
export function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(
  callback: T,
  delay: number,
  options: UseDebounceOptions = {}
): T & { cancel: () => void } {
  const { leading = false, trailing = true } = options;
  
  // Refs to hold latest values without causing re-renders
  const callbackRef = useRef(callback);
  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const lastArgsRef = useRef<Parameters<T> | null>(null);
  const isFirstRunRef = useRef(true);

  // Keep callbackRef current without recreating the debounced function
  useEffect(() => {
    callbackRef.current = callback;
  }, [callback]);

  // Cleanup on unmount
  useEffect(() => {
    return () => {
      if (timeoutRef.current) {
        clearTimeout(timeoutRef.current);
      }
    };
  }, []);

  const debouncedFn = useCallback(
    (...args: Parameters<T>) => {
      lastArgsRef.current = args;
      const { current: callback } = callbackRef;

      const invokeCallback = () => {
        if (lastArgsRef.current) {
          callback(...lastArgsRef.current);
          lastArgsRef.current = null;
        }
      };

      // Handle Leading Edge
      if (leading && isFirstRunRef.current) {
        isFirstRunRef.current = false;
        invokeCallback();
        // If trailing is also true, we still need to set a timer to reset the "first run" flag
        // after the delay so the next click counts as "first" again.
        if (trailing) {
           if (timeoutRef.current) clearTimeout(timeoutRef.current);
           timeoutRef.current = setTimeout(() => {
             isFirstRunRef.current = true;
           }, delay);
        }
        return;
      }

      // Handle Trailing Edge (Standard Debounce)
      if (trailing) {
        if (timeoutRef.current) {
          clearTimeout(timeoutRef.current);
        }
        timeoutRef.current = setTimeout(() => {
          invokeCallback();
          isFirstRunRef.current = true; // Reset for next leading edge
        }, delay);
      }
    },
    [delay, leading, trailing]
  );

  const cancel = useCallback(() => {
    if (timeoutRef.current) {
      clearTimeout(timeoutRef.current);
      timeoutRef.current = null;
    }
    lastArgsRef.current = null;
    isFirstRunRef.current = true;
  }, []);

  // Attach cancel to the function object
  // We use 'as' because we are augmenting the function prototype with a property
  return Object.assign(debouncedFn, { cancel }) as T & { cancel: () => void };
}

Simpler Alternative: useDebouncedValue

If you just want to debounce a value (state) rather than a callback (event handler), use this lighter version:

import { useState, useEffect } from 'react';

/**
 * Debounces a value. Returns the delayed value.
 * Automatically cancels on unmount or when value/delay changes.
 */
export function useDebouncedValue<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Cleanup function: cancels timeout if value/delay changes or component unmounts
    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]);

  return debouncedValue;
}

Usage Examples

1. Debouncing an Event Handler (Search Input)

Use useDebouncedCallback when you need to call an API or trigger a side effect.

import { useState } from 'react';
import { useDebouncedCallback } from './hooks';

function SearchComponent() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState<string[]>([]);

  // Debounce the API call by 300ms
  const fetchResults = useDebouncedCallback(
    async (searchTerm: string) => {
      if (!searchTerm) { setResults([]); return; }
      const res = await fetch(`/api/search?q=${searchTerm}`);
      const data = await res.json();
      setResults(data);
    },
    300,
    { leading: false, trailing: true } // Default behavior
  );

  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const val = e.target.value;
    setQuery(val);
    fetchResults(val); // Call debounced function
  };

  // Optional: Cancel pending request if component unmounts (handled automatically by hook cleanup)
  // But you can manually cancel too:
  // useEffect(() => () => fetchResults.cancel(), []);

  return (
    <div>
      <input value={query} onChange={handleChange} placeholder="Search..." />
      <ul>{results.map(r => <li key={r}>{r}</li>)}</ul>
    </div>
  );
}

2. Debouncing a Value (Deferred Rendering)

Use useDebouncedValue to delay a heavy render (e.g., a large list) while keeping the input responsive.

import { useDebouncedValue } from './hooks';

function HeavyList({ filter }: { filter: string }) {
  // The list only re-renders 200ms after user stops typing
  const debouncedFilter = useDebouncedValue(filter, 200);
  
  // Expensive filtering logic runs against debouncedFilter
  const visibleItems = expensiveFilter(items, debouncedFilter);

  return <VirtualizedList items={visibleItems} />;
}

Key TypeScript Details

1. T extends (...args: unknown[]) => unknown: Constrains the generic to a function type.

2. Parameters<T>: Extracts the argument tuple type from the passed callback, ensuring debouncedFn accepts the exact same arguments as the original.

3. ReturnType<typeof setTimeout>: Correctly types the timer ID (NodeJS.Timeout in Node, number in browsers).

4. Object.assign(fn, { cancel }) as T & { cancel: () => void }: Safely augments the function type with the cancellation method.

The probability is approximately 33%.

Here is the step-by-step breakdown using a hypothetical population of 10,000 people:

1. The Setup

• Prevalence (Base Rate): 0.5% use the drug.

  • Users: 50 people ($10,000 \times 0.005$)

  • Non-users: 9,950 people

• Test Accuracy: 99% (meaning 99% True Positive rate, 99% True Negative rate).

  • False Positive Rate: 1%

  • False Negative Rate: 1%

2. The Results

3. The Calculation (Positive Predictive Value)

You tested positive. You are in the "Test Positive" column (149 people total). Only 49.5 of those people actually use the drug.

$$P(\text{User} | \text{Positive}) = \frac{\text{True Positives}}{\text{Total Positives}} = \frac{49.5}{149} \approx \mathbf{33.2\%}$$

Why the Answer Surprises People

1. Base Rate Neglect (The Base Rate Fallacy)

Human intuition focuses on the test accuracy (99%) and ignores the base rate (0.5%).

• People think: "The test is wrong only 1% of the time, so if it says positive, there's a 99% chance it's right."

• Reality: The test is applied to a massive population of innocent people (9,950). Even a tiny 1% error rate on a huge group generates more false alarms (99.5) than the total number of actual users (50).

2. Confusing $P(\text{Positive} | \text{User})$ with $P(\text{User} | \text{Positive})$

• $P(\text{Positive} | \text{User}) = 99\%$: "If you are a user, the test catches you." (Sensitivity)

• $P(\text{User} | \text{Positive}) = 33\%$: "If the test caught you, you are a user." (Positive Predictive Value) These are mathematically distinct (related by Bayes' Theorem), but linguistically feel identical.

3. The "Rare Event" Paradox

When a condition is rare, false positives dominate true positives unless the test specificity is extraordinarily high (e.g., 99.99%+).

• To get 99% confidence from a positive test on a 0.5% base rate, you would need a test with 99.95% specificity (a false positive rate of 0.05%), not 99%.

Real-World Implication

This is why confirmatory testing exists (e.g., a second, different test like GC-MS after an immunoassay screen). A single positive on a low-prevalence screening test is merely an indicator for further investigation, not proof of guilt.