THE "IMPROVE IT" TRAP

<?php

$x = 100;

while ($x > 0)
{
    echo $x--;
}

What it does: Counts down from 100 to 1. That's it. That's the whole thing.

Time to write: 30 seconds

Time to understand: 5 seconds

Bugs: None

Satisfaction: Complete

#!/usr/bin/env php
<?php

declare(strict_types=1);

function countdown(int $from, int $to = 1): void
{
    if ($from < $to) {
        throw new InvalidArgumentException("Start ($from) must be >= end ($to)");
    }

    for ($i = $from; $i >= $to; $i--) {
        echo $i . PHP_EOL;
    }
}

$start = (int) ($argv[1] ?? 100);
$end = (int) ($argv[2] ?? 1);

try {
    countdown($start, $end);
} catch (InvalidArgumentException $e) {
    fwrite(STDERR, "Error: " . $e->getMessage() . PHP_EOL);
    exit(1);
}

Okay, fine. This is actually reasonable. Maybe even... good? Don't worry, it gets worse.

You know what a countdown script really needs? JSON output. For when you need to serialize your decreasing integers. For the API. The countdown API.

Finally! I can count down from 100 to 1 in ROMAN NUMERALS while seeing a PROGRESS BAR of my progress through a COUNTDOWN. The progress of the count. Being progressed.

Ah yes, the famous Collatz conjecture countdown. Nothing says "I just want to print 100 to 1" like a mathematical sequence that may or may not halt.

#!/usr/bin/env php
<?php

declare(strict_types=1);

const VERSION = '2.0.0';

// Signal handling for graceful shutdown
$interrupted = false;
if (function_exists('pcntl_signal')) {
    pcntl_signal(SIGINT, function () use (&$interrupted) {
        $interrupted = true;
    });
    pcntl_signal(SIGTERM, function () use (&$interrupted) {
        $interrupted = true;
    });
}

/**
 * ANSI color codes for terminal output.
 */
final class Color
{
    public const RESET = "\033[0m";
    public const BOLD = "\033[1m";
    public const DIM = "\033[2m";
    public const ITALIC = "\033[3m";
    public const RED = "\033[31m";
    public const GREEN = "\033[32m";
    public const YELLOW = "\033[33m";
    public const BLUE = "\033[34m";
    public const MAGENTA = "\033[35m";
    public const CYAN = "\033[36m";

    private static ?bool $enabled = null;

    public static function enabled(): bool
    {
        if (self::$enabled === null) {
            self::$enabled = posix_isatty(STDOUT) && getenv('NO_COLOR') === false;
        }
        return self::$enabled;
    }

    public static function disable(): void
    {
        self::$enabled = false;
    }

    public static function apply(string $text, string ...$codes): string
    {
        if (!self::enabled()) {
            return $text;
        }
        return implode('', $codes) . $text . self::RESET;
    }

    public static function strip(string $text): string
    {
        return preg_replace('/\033\[[0-9;]*m/', '', $text) ?? $text;
    }
}

/**
 * Convert number to various representations.
 */
final class NumberFormat
{
    private const ONES = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
        'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
    private const TENS = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
    private const ROMANS = ['M' => 1000, 'CM' => 900, 'D' => 500, 'CD' => 400, 'C' => 100,
        'XC' => 90, 'L' => 50, 'XL' => 40, 'X' => 10, 'IX' => 9, 'V' => 5, 'IV' => 4, 'I' => 1];
    private const BIG_DIGITS = [
        '0' => ['┏━┓', '┃ ┃', '┗━┛'],
        '1' => [' ┓ ', ' ┃ ', ' ╹ '],
        '2' => ['┏━┓', '┏━┛', '┗━━'],
        '3' => ['┏━┓', ' ━┫', '┗━┛'],
        '4' => ['╻ ╻', '┗━┫', '  ╹'],
        '5' => ['┏━━', '┗━┓', '┗━┛'],
        '6' => ['┏━┓', '┣━┓', '┗━┛'],
        '7' => ['┏━┓', '  ┃', '  ╹'],
        '8' => ['┏━┓', '┣━┫', '┗━┛'],
        '9' => ['┏━┓', '┗━┫', '┗━┛'],
        '-' => ['   ', '━━━', '   '],
    ];

    public static function format(int $n, string $type, bool $locale = false): string
    {
        if ($locale && $type === 'dec') {
            return number_format($n);
        }

        return match ($type) {
            'hex' => '0x' . strtoupper(dechex($n)),
            'bin' => '0b' . decbin($n),
            'oct' => '0o' . decoct($n),
            'roman' => self::toRoman($n),
            'words' => self::toWords($n),
            'ordinal' => self::toOrdinal($n),
            'big' => self::toBig($n),
            default => (string) $n,
        };
    }

    public static function toRoman(int $n): string
    {
        if ($n < 1 || $n > 3999) {
            return (string) $n;
        }
        $result = '';
        foreach (self::ROMANS as $roman => $value) {
            while ($n >= $value) {
                $result .= $roman;
                $n -= $value;
            }
        }
        return $result;
    }

    public static function toWords(int $n): string
    {
        if ($n === 0) return 'zero';
        if ($n < 0) return 'negative ' . self::toWords(abs($n));
        if ($n >= 1_000_000_000) return self::toWords((int)($n / 1_000_000_000)) . ' billion' . ($n % 1_000_000_000 ? ' ' . self::toWords($n % 1_000_000_000) : '');
        if ($n >= 1_000_000) return self::toWords((int)($n / 1_000_000)) . ' million' . ($n % 1_000_000 ? ' ' . self::toWords($n % 1_000_000) : '');
        if ($n >= 1000) return self::toWords((int)($n / 1000)) . ' thousand' . ($n % 1000 ? ' ' . self::toWords($n % 1000) : '');
        if ($n >= 100) return self::ONES[(int)($n / 100)] . ' hundred' . ($n % 100 ? ' ' . self::toWords($n % 100) : '');
        if ($n >= 20) return self::TENS[(int)($n / 10)] . ($n % 10 ? '-' . self::ONES[$n % 10] : '');
        return self::ONES[$n];
    }

    public static function toOrdinal(int $n): string
    {
        $abs = abs($n);
        $suffix = match (true) {
            ($abs % 100 >= 11 && $abs % 100 <= 13) => 'th',
            ($abs % 10 === 1) => 'st',
            ($abs % 10 === 2) => 'nd',
            ($abs % 10 === 3) => 'rd',
            default => 'th',
        };
        return $n . $suffix;
    }

    public static function toBig(int $n): string
    {
        $str = (string) $n;
        $lines = ['', '', ''];
        foreach (str_split($str) as $char) {
            $digit = self::BIG_DIGITS[$char] ?? self::BIG_DIGITS['0'];
            for ($i = 0; $i < 3; $i++) {
                $lines[$i] .= $digit[$i] . ' ';
            }
        }
        return implode(PHP_EOL, $lines);
    }
}

/**
 * Mathematical sequence generators.
 */
final class Sequence
{
    /** @return Generator<int, int> */
    public static function range(int $from, int $to, int $step = 1): Generator
    {
        $step = abs($step);
        $index = 0;
        if ($from <= $to) {
            for ($i = $from; $i <= $to; $i += $step) {
                yield $index++ => $i;
            }
        } else {
            for ($i = $from; $i >= $to; $i -= $step) {
                yield $index++ => $i;
            }
        }
    }

    /** @return Generator<int, int> */
    public static function fibonacci(int $limit): Generator
    {
        $a = 0;
        $b = 1;
        $index = 0;
        while ($a <= $limit) {
            yield $index++ => $a;
            [$a, $b] = [$b, $a + $b];
        }
    }

    /** @return Generator<int, int> */
    public static function primes(int $limit): Generator
    {
        $index = 0;
        for ($n = 2; $n <= $limit; $n++) {
            if (self::isPrime($n)) {
                yield $index++ => $n;
            }
        }
    }

    public static function isPrime(int $n): bool
    {
        if ($n < 2) return false;
        if ($n === 2) return true;
        if ($n % 2 === 0) return false;
        for ($i = 3; $i * $i <= $n; $i += 2) {
            if ($n % $i === 0) return false;
        }
        return true;
    }

    /** @return Generator<int, int> */
    public static function squares(int $limit): Generator
    {
        $index = 0;
        for ($n = 1; $n * $n <= $limit; $n++) {
            yield $index++ => $n * $n;
        }
    }

    /** @return Generator<int, int> */
    public static function triangular(int $limit): Generator
    {
        $index = 0;
        $n = 1;
        $tri = 1;
        while ($tri <= $limit) {
            yield $index++ => $tri;
            $n++;
            $tri = $n * ($n + 1) / 2;
        }
    }

    /** @return Generator<int, int> */
    public static function powers(int $base, int $limit): Generator
    {
        $index = 0;
        $val = 1;
        while ($val <= $limit) {
            yield $index++ => $val;
            $val *= $base;
        }
    }

    /** @return Generator<int, int> */
    public static function factorial(int $limit): Generator
    {
        $index = 0;
        $n = 0;
        $fact = 1;
        while ($fact <= $limit) {
            yield $index++ => $fact;
            $n++;
            $fact *= $n;
        }
    }

    /** @return Generator<int, int> */
    public static function collatz(int $start): Generator
    {
        $index = 0;
        $n = $start;
        while ($n !== 1) {
            yield $index++ => $n;
            $n = ($n % 2 === 0) ? $n / 2 : 3 * $n + 1;
        }
        yield $index => 1;
    }

    public static function count(Generator $gen): int
    {
        $count = 0;
        foreach ($gen as $_) {
            $count++;
        }
        return $count;
    }
}

/**
 * Apply transformations and filters to numbers.
 */
final class Transform
{
    public static function apply(int $n, string $transform): int
    {
        return match ($transform) {
            'square' => $n * $n,
            'cube' => $n * $n * $n,
            'double' => $n * 2,
            'half' => (int) ($n / 2),
            'abs' => abs($n),
            'neg' => -$n,
            default => $n,
        };
    }

    public static function filter(int $n, string $filter): bool
    {
        return match ($filter) {
            'even' => $n % 2 === 0,
            'odd' => $n % 2 !== 0,
            'positive' => $n > 0,
            'negative' => $n < 0,
            'prime' => Sequence::isPrime($n),
            default => true,
        };
    }
}

/**
 * Template engine for custom output formatting.
 */
final class Template
{
    public static function render(string $template, int $n, int $index, int $total): string
    {
        $replacements = [
            '{n}' => (string) $n,
            '{N}' => (string) $n,
            '{i}' => (string) $index,
            '{index}' => (string) $index,
            '{total}' => (string) $total,
            '{percent}' => (string) round(($index + 1) / $total * 100),
            '{hex}' => dechex($n),
            '{HEX}' => strtoupper(dechex($n)),
            '{bin}' => decbin($n),
            '{oct}' => decoct($n),
            '{roman}' => NumberFormat::toRoman($n),
            '{words}' => NumberFormat::toWords($n),
            '{ordinal}' => NumberFormat::toOrdinal($n),
            '{pad2}' => str_pad((string) $n, 2, '0', STR_PAD_LEFT),
            '{pad3}' => str_pad((string) $n, 3, '0', STR_PAD_LEFT),
            '{pad4}' => str_pad((string) $n, 4, '0', STR_PAD_LEFT),
            '{square}' => (string) ($n * $n),
            '{cube}' => (string) ($n * $n * $n),
            '\\n' => PHP_EOL,
            '\\t' => "\t",
        ];
        return str_replace(array_keys($replacements), array_values($replacements), $template);
    }
}

/**
 * Progress and ETA display.
 */
final class Progress
{
    private float $startTime;
    private int $total;

    public function __construct(int $total)
    {
        $this->startTime = microtime(true);
        $this->total = $total;
    }

    public function render(int $current, string $currentValue, int $width = 30): string
    {
        $percent = $this->total > 0 ? $current / $this->total : 1;
        $filled = (int) round($width * $percent);
        $empty = $width - $filled;

        $bar = Color::apply(str_repeat('█', $filled), Color::GREEN)
             . Color::apply(str_repeat('░', $empty), Color::DIM);

        $eta = $this->getEta($current);
        $etaStr = $eta > 0 ? sprintf(' ETA: %s', $this->formatTime($eta)) : '';

        return sprintf("\r[%s] %3d%% %s%s   ",
            $bar,
            (int) ($percent * 100),
            Color::apply($currentValue, Color::CYAN),
            Color::apply($etaStr, Color::DIM)
        );
    }

    private function getEta(int $current): float
    {
        if ($current === 0) return 0;
        $elapsed = microtime(true) - $this->startTime;
        $rate = $current / $elapsed;
        $remaining = $this->total - $current;
        return $remaining / $rate;
    }

    private function formatTime(float $seconds): string
    {
        if ($seconds < 60) return sprintf('%.0fs', $seconds);
        if ($seconds < 3600) return sprintf('%dm %ds', $seconds / 60, $seconds % 60);
        return sprintf('%dh %dm', $seconds / 3600, ($seconds % 3600) / 60);
    }
}

/**
 * Output handler with multiple format support.
 */
final class Output
{
    private $handle;
    private string $format;
    private bool $first = true;

    public function __construct(?string $file, string $format)
    {
        $this->handle = $file ? fopen($file, 'w') : STDOUT;
        $this->format = $format;

        if (!$this->handle) {
            throw new RuntimeException("Cannot open file for writing: $file");
        }
    }

    public function write(string $value): void
    {
        $output = match ($this->format) {
            'json' => $this->first ? "[$value" : ",$value",
            'csv' => $this->first ? $value : ",$value",
            default => $value . PHP_EOL,
        };
        fwrite($this->handle, $output);
        $this->first = false;
    }

    public function close(): void
    {
        if ($this->format === 'json') {
            fwrite($this->handle, ']' . PHP_EOL);
        } elseif ($this->format === 'csv') {
            fwrite($this->handle, PHP_EOL);
        }

        if ($this->handle !== STDOUT) {
            fclose($this->handle);
        }
    }
}

/**
 * Statistics collector.
 */
final class Stats
{
    private float $startTime;
    private int $count = 0;
    private int $sum = 0;
    private ?int $min = null;
    private ?int $max = null;

    public function __construct()
    {
        $this->startTime = microtime(true);
    }

    public function record(int $n): void
    {
        $this->count++;
        $this->sum += $n;
        $this->min = $this->min === null ? $n : min($this->min, $n);
        $this->max = $this->max === null ? $n : max($this->max, $n);
    }

    public function display(): void
    {
        $elapsed = microtime(true) - $this->startTime;

        echo PHP_EOL;
        echo Color::apply('Statistics:', Color::BOLD) . PHP_EOL;
        echo Color::apply('  Count:    ', Color::DIM) . number_format($this->count) . PHP_EOL;
        echo Color::apply('  Sum:      ', Color::DIM) . number_format($this->sum) . PHP_EOL;
        echo Color::apply('  Min:      ', Color::DIM) . number_format($this->min ?? 0) . PHP_EOL;
        echo Color::apply('  Max:      ', Color::DIM) . number_format($this->max ?? 0) . PHP_EOL;
        echo Color::apply('  Average:  ', Color::DIM) . ($this->count > 0 ? number_format($this->sum / $this->count, 2) : 'N/A') . PHP_EOL;
        echo Color::apply('  Time:     ', Color::DIM) . sprintf('%.3fs', $elapsed) . PHP_EOL;
        echo Color::apply('  Rate:     ', Color::DIM) . number_format($this->count / max($elapsed, 0.001)) . '/sec' . PHP_EOL;
    }
}

function showHelp(): void
{
    $c = Color::enabled();
    $bold = fn($t) => $c ? Color::apply($t, Color::BOLD) : $t;
    $cyan = fn($t) => $c ? Color::apply($t, Color::CYAN) : $t;
    $dim = fn($t) => $c ? Color::apply($t, Color::DIM) : $t;
    $yellow = fn($t) => $c ? Color::apply($t, Color::YELLOW) : $t;

    echo $bold('COUNT') . " v" . VERSION . " - A feature-rich number sequence generator" . PHP_EOL . PHP_EOL;

    echo $bold('USAGE') . PHP_EOL;
    echo "  count [options] [start] [end]" . PHP_EOL;
    echo "  count --seq=<sequence> [limit]" . PHP_EOL . PHP_EOL;

    echo $bold('ARGUMENTS') . PHP_EOL;
    echo "  " . $cyan('start') . "              Starting number " . $dim('(default: 100)') . PHP_EOL;
    echo "  " . $cyan('end') . "                Ending number " . $dim('(default: 1)') . PHP_EOL . PHP_EOL;

    echo $bold('OPTIONS') . PHP_EOL;
    echo "  " . $cyan('-s, --step=N') . "       Step increment " . $dim('(default: 1)') . PHP_EOL;
    echo "  " . $cyan('-d, --delay=N') . "      Delay between numbers in seconds" . PHP_EOL;
    echo "  " . $cyan('-f, --format=FMT') . "   Output: line, csv, json " . $dim('(default: line)') . PHP_EOL;
    echo "  " . $cyan('-n, --number=FMT') . "   Format: dec, hex, bin, oct, roman, words, ordinal, big" . PHP_EOL;
    echo "  " . $cyan('-t, --template=STR') . " Custom template " . $dim('(e.g., "Item {n}: {words}")') . PHP_EOL;
    echo "  " . $cyan('--seq=TYPE') . "         Sequence: fibonacci, primes, squares, triangular, powers:N, collatz:N" . PHP_EOL;
    echo "  " . $cyan('--filter=TYPE') . "      Filter: even, odd, positive, negative, prime" . PHP_EOL;
    echo "  " . $cyan('--transform=TYPE') . "   Transform: square, cube, double, half, abs, neg" . PHP_EOL;
    echo "  " . $cyan('-w, --pad=N') . "        Pad numbers to N digits with leading zeros" . PHP_EOL;
    echo "  " . $cyan('-l, --locale') . "       Use locale-aware formatting (thousands separator)" . PHP_EOL;
    echo "  " . $cyan('-o, --output=FILE') . "  Write output to file" . PHP_EOL;
    echo "  " . $cyan('-p, --progress') . "     Show progress bar with ETA" . PHP_EOL;
    echo "  " . $cyan('-v, --stats') . "        Show statistics (count, sum, min, max, avg)" . PHP_EOL;
    echo "  " . $cyan('-q, --quiet') . "        Suppress number output (useful with --stats)" . PHP_EOL;
    echo "  " . $cyan('-b, --bell') . "         Ring terminal bell on completion" . PHP_EOL;
    echo "  " . $cyan('--no-color') . "         Disable colored output" . PHP_EOL;
    echo "  " . $cyan('-h, --help') . "         Show this help" . PHP_EOL;
    echo "  " . $cyan('-V, --version') . "      Show version" . PHP_EOL . PHP_EOL;

    echo $bold('TEMPLATE PLACEHOLDERS') . PHP_EOL;
    echo "  " . $yellow('{n}') . " number  " . $yellow('{i}') . " index  " . $yellow('{total}') . " total  " . $yellow('{percent}') . " progress" . PHP_EOL;
    echo "  " . $yellow('{hex}') . " " . $yellow('{bin}') . " " . $yellow('{oct}') . " " . $yellow('{roman}') . " " . $yellow('{words}') . " " . $yellow('{ordinal}') . " format conversions" . PHP_EOL;
    echo "  " . $yellow('{pad2}') . " " . $yellow('{pad3}') . " " . $yellow('{pad4}') . " zero-padded  " . $yellow('{square}') . " " . $yellow('{cube}') . " math" . PHP_EOL;
    echo "  " . $yellow('\\n') . " newline  " . $yellow('\\t') . " tab" . PHP_EOL . PHP_EOL;

    echo $bold('EXAMPLES') . PHP_EOL;
    echo "  " . $dim('# Basic countdown with progress') . PHP_EOL;
    echo "  count -p 100 1" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Fibonacci sequence up to 1000') . PHP_EOL;
    echo "  count --seq=fibonacci 1000" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Prime numbers up to 100 as words') . PHP_EOL;
    echo "  count --seq=primes -n words 100" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Collatz sequence starting at 27') . PHP_EOL;
    echo "  count --seq=collatz:27" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Custom template') . PHP_EOL;
    echo "  count -t 'Line {pad3}: {n} is {words}' 1 5" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Even numbers only, as hex JSON array') . PHP_EOL;
    echo "  count --filter=even -n hex -f json 1 20" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Big ASCII art numbers') . PHP_EOL;
    echo "  count -n big -d 1 3 1" . PHP_EOL . PHP_EOL;
    echo "  " . $dim('# Statistics only (quiet mode)') . PHP_EOL;
    echo "  count -qv 1 1000000" . PHP_EOL;
}

function showVersion(): void
{
    echo "count version " . VERSION . PHP_EOL;
    echo "A feature-rich number sequence generator" . PHP_EOL;
    echo "PHP " . PHP_VERSION . PHP_EOL;
}

// Parse CLI options
$shortOpts = 's:d:f:n:t:w:o:pvqbhlV';
$longOpts = [
    'step:', 'delay:', 'format:', 'number:', 'template:', 'seq:', 'filter:', 'transform:',
    'pad:', 'locale', 'output:', 'progress', 'stats', 'quiet', 'bell', 'no-color', 'help', 'version'
];
$options = getopt($shortOpts, $longOpts, $optind);
$args = array_slice($argv, $optind);

// Handle --no-color early
if (isset($options['no-color'])) {
    Color::disable();
}

if (isset($options['h']) || isset($options['help'])) {
    showHelp();
    exit(0);
}

if (isset($options['V']) || isset($options['version'])) {
    showVersion();
    exit(0);
}

// Parse options with defaults
$step = (int) ($options['s'] ?? $options['step'] ?? 1);
$delay = (float) ($options['d'] ?? $options['delay'] ?? 0);
$format = (string) ($options['f'] ?? $options['format'] ?? 'line');
$numFormat = (string) ($options['n'] ?? $options['number'] ?? 'dec');
$template = $options['t'] ?? $options['template'] ?? null;
$sequence = $options['seq'] ?? null;
$filter = $options['filter'] ?? null;
$transform = $options['transform'] ?? null;
$padding = isset($options['w']) ? (int) $options['w'] : (isset($options['pad']) ? (int) $options['pad'] : 0);
$useLocale = isset($options['l']) || isset($options['locale']);
$outputFile = $options['o'] ?? $options['output'] ?? null;
$showProgress = isset($options['p']) || isset($options['progress']);
$showStats = isset($options['v']) || isset($options['stats']);
$quiet = isset($options['q']) || isset($options['quiet']);
$ringBell = isset($options['b']) || isset($options['bell']);

// Validation
$validFormats = ['line', 'csv', 'json'];
if (!in_array($format, $validFormats, true)) {
    fwrite(STDERR, Color::apply('Error: ', Color::RED) . "Invalid format. Use: " . implode(', ', $validFormats) . PHP_EOL);
    exit(1);
}

$validNumFormats = ['dec', 'hex', 'bin', 'oct', 'roman', 'words', 'ordinal', 'big'];
if (!in_array($numFormat, $validNumFormats, true)) {
    fwrite(STDERR, Color::apply('Error: ', Color::RED) . "Invalid number format. Use: " . implode(', ', $validNumFormats) . PHP_EOL);
    exit(1);
}

if ($filter && !in_array($filter, ['even', 'odd', 'positive', 'negative', 'prime'], true)) {
    fwrite(STDERR, Color::apply('Error: ', Color::RED) . "Invalid filter. Use: even, odd, positive, negative, prime" . PHP_EOL);
    exit(1);
}

if ($transform && !in_array($transform, ['square', 'cube', 'double', 'half', 'abs', 'neg'], true)) {
    fwrite(STDERR, Color::apply('Error: ', Color::RED) . "Invalid transform. Use: square, cube, double, half, abs, neg" . PHP_EOL);
    exit(1);
}

// Build the generator based on sequence type or range
if ($sequence) {
    $limit = (int) ($args[0] ?? 100);
    $generator = match (true) {
        $sequence === 'fibonacci' => Sequence::fibonacci($limit),
        $sequence === 'primes' => Sequence::primes($limit),
        $sequence === 'squares' => Sequence::squares($limit),
        $sequence === 'triangular' => Sequence::triangular($limit),
        $sequence === 'factorial' => Sequence::factorial($limit),
        str_starts_with($sequence, 'powers:') => Sequence::powers((int) substr($sequence, 7), $limit),
        str_starts_with($sequence, 'collatz:') => Sequence::collatz((int) substr($sequence, 8)),
        default => throw new InvalidArgumentException("Unknown sequence: $sequence"),
    };
    // For sequences, we don't know total upfront for progress
    $total = 0;
} else {
    $start = (int) ($args[0] ?? 100);
    $end = (int) ($args[1] ?? 1);
    $generator = Sequence::range($start, $end, $step);
    $total = (int) (abs($end - $start) / $step) + 1;
}

// Initialize components
$output = new Output($outputFile, $format);
$stats = new Stats();
$progress = $total > 0 ? new Progress($total) : null;

// Process the sequence
$count = 0;
$startTime = microtime(true);

foreach ($generator as $index => $n) {
    if (function_exists('pcntl_signal_dispatch')) {
        pcntl_signal_dispatch();
    }

    if ($interrupted) {
        if (posix_isatty(STDOUT)) {
            echo PHP_EOL . Color::apply('Interrupted!', Color::YELLOW) . PHP_EOL;
        }
        break;
    }

    // Apply filter
    if ($filter && !Transform::filter($n, $filter)) {
        continue;
    }

    // Apply transform
    if ($transform) {
        $n = Transform::apply($n, $transform);
    }

    $stats->record($n);
    $count++;

    // Format the number
    if ($template) {
        $formatted = Template::render($template, $n, $index, $total ?: $count);
    } else {
        $formatted = NumberFormat::format($n, $numFormat, $useLocale);
        if ($padding > 0 && $numFormat === 'dec') {
            $formatted = str_pad($formatted, $padding, '0', STR_PAD_LEFT);
        }
    }

    // Handle delay
    if ($delay > 0 && $count > 1) {
        usleep((int) ($delay * 1_000_000));
    }

    // Output
    if (!$quiet) {
        if ($showProgress && $progress && posix_isatty(STDOUT) && $numFormat !== 'big') {
            echo $progress->render($count, $formatted);
            flush();
        } else {
            if ($numFormat === 'big') {
                echo $formatted . PHP_EOL . PHP_EOL;
            } else {
                $output->write($formatted);
            }
        }
    }
}

// Cleanup
if ($showProgress && posix_isatty(STDOUT) && $numFormat !== 'big') {
    echo PHP_EOL;
}

if ($numFormat !== 'big') {
    $output->close();
}

if ($showStats) {
    $stats->display();
}

if ($ringBell && posix_isatty(STDOUT)) {
    echo "\007";
}

exit($interrupted ? 130 : 0);

Show Full 728-Line Horror