Why 'type type type type' runs three times in Bash

In Bash, when we run the command type type type type, we observe a peculiar behavior: it executes three times instead of once or four times. This phenomenon is fascinating and is due to how Bash processes arguments and how the type command specifically works.

The behavior of type

The type command is a Bash builtin used to determine how Bash would interpret a command name. When we execute:

type type type type

We get an output similar to this:

type is a shell builtin
type is a shell builtin
type is a shell builtin

The reason behind the behavior

The behavior can be explained by analyzing how Bash processes the command line:

1. First, Bash identifies the initial type command.
2. Everything that follows is considered as arguments for that command.
3. Key point: The type command processes each argument independently, trying to determine what kind of command each one is.

The reason we see three outputs and not four is due to left-to-right argument processing:

1. The first type is the command that will be executed
2. The following three type words are arguments to the first type

Why this doesn’t happen with other commands

This behavior is specific to type because it’s a command designed to analyze command names. Let’s compare with other commands:

echo echo echo echo

This would produce:

echo echo echo

The difference lies in that echo simply prints its arguments as text, while type analyzes each argument as a potential command.

The case of other builtins

Other Bash builtins have their own specific behaviors:

which which which which  # Different behavior
command command command command  # Different behavior

The type command is special because:

1. It’s a builtin designed for command introspection
2. It processes each argument independently
3. It’s designed to answer the question “what is this command?” for each argument

Verification using strace

We can verify this behavior using strace to see exactly what’s happening at the system level:

strace -e trace=execve bash -c 'type type type type'

This would show us that there are no execve calls because type is a builtin, and would confirm that it’s being executed three times within the Bash process.

Conclusion

This seemingly strange behavior is actually consistent with the design and purpose of the type command. It’s an excellent example of how Bash builtins can have specific behaviors that differ from regular external commands, and how argument processing in Bash can lead to results that initially seem counterintuitive but are completely logical once you understand the underlying mechanism.