List Comprehension Compression

List & Dict Comprehension Compression Protocol

Overview

When generating data transformations, filtering, or index construction, default LLM outputs frequently write verbose procedural Accumulator Loops: initializing an empty array, running a multi-line for loop with nested if statements, and appending items one by one.

Procedural accumulator loops consume 6 to 10 lines of code and 80+ tokens for transformations that idiomatic languages express in a single, highly-optimized line (12 tokens).

The List & Dict Comprehension Protocol enforces idiomatic functional expressions: using Python List/Dict/Set Comprehensions, Generator Expressions, and JavaScript Functional Pipelines to reduce code size by 60% while improving runtime execution speed.

Procedural Accumulator vs. Idiomatic Comprehension

┌─────────────────────────────────────────────────────────────┐
│                 Loop Code Density Comparison                │
│                                                             │
│  Procedural Accumulator Loop (10 Lines / 95 Tokens):        │
│  active_user_emails = []                                    │
│  for user in user_list:                                     │
│      if user.is_active:                                     │
│          if user.email is not None:                         │
│              active_user_emails.append(user.email.lower())  │
│                                                             │
│  user_id_map = {}                                           │
│  for u in active_user_emails:                               │
│      user_id_map[u.id] = u                                  │
│                                                             │
│  Idiomatic Comprehension (2 Lines / 24 Tokens - 74.7% Cut): │
│  active_emails = [u.email.lower() for u in users if u.is_active and u.email]│
│  user_id_map = {u.id: u for u in users if u.is_active}      │
└─────────────────────────────────────────────────────────────┘

The Master Comprehension Archetypes

1. Python List, Dict, and Set Comprehensions

# Filtering and mapping in 1 expression
active_ids = [u.id for u in users if u.status == "ACTIVE"]

# Fast O(1) Dictionary Index construction
user_lookup = {u.email: u for u in users}

# Set comprehension for unique deduplicated values
unique_domains = {u.email.split("@")[1] for u in users if "@" in u.email}

2. Python Generator Expressions (Zero-Memory Stream Aggregation)

Never allocate an intermediate list if only computing a scalar aggregate (sum, any, all, max):

# Optimal: O(1) memory generator stream
total_revenue = sum(item.price * item.quantity for item in order.items)
has_expired_tokens = any(t.is_expired() for t in session.tokens)

3. JavaScript / TypeScript Functional Pipelines

// Compact filter-map pipeline
const activeEmails = users
  .filter((u) => u.isActive && u.email)
  .map((u) => u.email.toLowerCase());

// Fast lookup record from array
const userMap = Object.fromEntries(users.map((u) => [u.id, u]));

The 2-Clause Readability Constraint

┌───────────────────────────────────────────────────────────────────────────┐
│ 🟢 CLEAN COMPREHENSION (Allowed):                                         │
│ • Maximum 1 transformation + 1 filter clause                              │
│   `[x * 2 for x in data if x > 0]`                                        │
│                                                                           │
│ ❌ OVER-COMPLEX COMPREHENSION (Forbidden - Split into loop or helper):    │
│ • Nested loops with $>2$ `for` or complex branching                       │
│   `[a for b in c for a in b if a.ok if a.val > 10 else False]`           │
└───────────────────────────────────────────────────────────────────────────┘

Benchmark Comparison

Evaluation across 40 data transformation and mapping routines:

Agent Operational Directive

MANDATORY: For array transformations, filtering, and dictionary indexing, agents must generate idiomatic list/dict comprehensions and generator expressions. Never generate multi-line procedural accumulator loops for basic mapping operations.