# What Does the `requires_output` Flag in TheFuck Rules Indicate?

> Learn how the requires_output flag in TheFuck rules determines if standard output or error streams are needed for fixes. Understand its default and when it's set to False for syntax errors.

- Repository: [Vladimir Iakovlev/thefuck](https://github.com/nvbn/thefuck)
- Tags: internals
- Published: 2026-02-27

---

**The `requires_output` flag in TheFuck indicates whether a rule needs the failed command's standard output or error stream to determine if it can provide a fix, defaulting to `True` but set to `False` for rules that match syntax errors before any output is generated.**

TheFuck is a command-line correction tool that matches patterns in failed console commands to suggest fixes. When developing custom rules for TheFuck, understanding the **`requires_output` flag** is essential for controlling whether your rule depends on the previous command's output stream to function correctly.

## Understanding the `requires_output` Flag in TheFuck

The `requires_output` attribute is defined in the `Rule` class within [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py). It controls the behavior of the `is_match()` method during rule evaluation, determining whether a rule should be skipped when a command fails silently.

### How `requires_output` Controls Rule Matching

When TheFuck evaluates whether a rule applies to a failed command, it checks the `is_match()` method. The logic specifically handles cases where no output was captured:

```python

# From thefuck/types.py, lines 74-78

if command.output is None and self.requires_output:
    return False

```

This check ensures that rules requiring output are automatically skipped when the command failed silently, preventing errors in rules that attempt to parse non-existent error messages.

## When to Set `requires_output` to True vs False

The default value of `requires_output` is `True`, which suits most rules that analyze error messages. However, certain scenarios demand setting it to `False`.

- **`requires_output = True` (default)**: Use when your rule parses error messages, stack traces, or stderr content to identify the specific failure type.
- **`requires_output = False`**: Use when your rule detects syntax errors, command structure issues, or early failures that occur before the program generates any output.

### Rules That Require Output (Default Behavior)

Most built-in rules rely on the default `requires_output = True` setting. For example, in [`thefuck/rules/apt_get.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/rules/apt_get.py), the rule matches only when the output contains specific error text:

```python

# thefuck/rules/apt_get.py

priority = 3000

# requires_output defaults to True

def match(command):
    return 'Unable to locate package' in command.output

```

This rule would be irrelevant if the command produced no output, so the default behavior prevents unnecessary evaluation when `command.output` is `None`.

### Rules That Work Without Output

Rules that catch typos or syntax errors often set `requires_output = False`. In [`thefuck/rules/wrong_hyphen_before_subcommand.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/rules/wrong_hyphen_before_subcommand.py), the rule detects when a user types a hyphen instead of a space between a command and its subcommand:

```python

# thefuck/rules/wrong_hyphen_before_subcommand.py

priority = 4500
requires_output = False  # Explicit override

def match(command):
    first_part = command.script_parts[0]
    return ("-" in first_part and
            first_part.split("-", 1)[0] in get_all_executables())

```

This rule functions even when the shell returns "command not found" without additional output because it analyzes the script structure rather than error messages.

## Technical Implementation in the TheFuck Source Code

The `requires_output` flag is implemented in the `Rule` class constructor in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py) (lines 90-100):

```python

# thefuck/types.py

class Rule:
    def __init__(self, name, match, get_new_command,
                 priority=DEFAULT_PRIORITY, requires_output=True):
        self.name = name
        self.match = match
        self.get_new_command = get_new_command
        self.priority = priority
        self.requires_output = requires_output

```

The evaluation logic resides in the `is_match()` method (lines 74-78), which short-circuits the matching process when output is required but not present:

```python
def is_match(self, command):
    # Skip rules that need output when none is present

    if command.output is None and self.requires_output:
        return False
    try:
        return self.match(command)
    except Exception:
        logs.rule_failed(self, sys.exc_info())

```

## Summary

- The **`requires_output` flag** controls whether a TheFuck rule needs the failed command's output to evaluate a match.
- It defaults to **`True`** in the `Rule` class constructor in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py).
- When set to **`True`**, the rule is skipped if `command.output` is `None`, preventing errors in rules that parse error messages.
- When set to **`False`**, rules can match syntax errors or early failures that occur before any output is generated, such as typos in command names.

## Frequently Asked Questions

### What is the default value of requires_output in TheFuck rules?

The default value is **`True`**, defined in the `Rule` class constructor in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py). This ensures that most rules, which rely on parsing error messages from the command's output, are only evaluated when output is actually present.

### Can a TheFuck rule match if the command produced no output?

Yes, but only if the rule explicitly sets **`requires_output = False`**. This setting is necessary for rules that detect structural errors, typos, or syntax issues that cause the command to fail before generating any standard output or error stream.

### Where is the requires_output flag checked in TheFuck's source code?

The flag is checked in the **`is_match()`** method of the `Rule` class, located in [`thefuck/types.py`](https://github.com/nvbn/thefuck/blob/main/thefuck/types.py) at lines 74-78. The method returns `False` immediately if `command.output` is `None` and `requires_output` is `True`, short-circuiting further evaluation.

### Why would I set requires_output to False in a custom rule?

Set **`requires_output` to `False`** when your rule matches patterns in the command script itself rather than the output. This is common for fixing typos in command names (like `git-status` instead of `git status`), correcting argument order, or handling failures that occur during shell parsing before the program executes and produces output.