Union types in PHP - Time & Space Complexity

Time Complexity: Union types

O(n)

Understanding Time Complexity

Let's explore how using union types in PHP affects the time it takes for code to run.

We want to see how the program's work changes as input grows when union types are involved.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function processValue(int|string $value): string {
    if (is_int($value)) {
        return (string)($value * 2);
    } else {
        return strtoupper($value);
    }
}

$inputs = [1, "hello", 3, "world"];
foreach ($inputs as $item) {
    echo processValue($item) . "\n";
}
    

This code processes a list of values that can be either numbers or words, using union types to accept both.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each item in the input array and calling processValue.
• How many times: Once for each item in the input list.

How Execution Grows With Input

As the number of items grows, the code runs the process for each item one by one.

Input Size (n)	Approx. Operations
10	About 10 calls to processValue
100	About 100 calls to processValue
1000	About 1000 calls to processValue

Pattern observation: The work grows directly with the number of items; doubling items doubles work.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line with the number of inputs.

Common Mistake

[X] Wrong: "Using union types makes the code slower because it checks types every time."

[OK] Correct: The type check is simple and happens once per item, so it doesn't change how the total work grows with more inputs.

Interview Connect

Understanding how union types affect performance helps you write clear code without worrying about slowing things down as data grows.

Self-Check

"What if the input array was nested arrays instead of simple values? How would the time complexity change?"

Practice

1. What does a union type in PHP allow you to do?
function example(int|string $value) {}

easy

A. Only accept integer values

B. Accept multiple types for a parameter or return value

C. Only accept string values

D. Combine two functions into one

Solution

1. Step 1: Understand union type syntax

   The | symbol between types means the parameter can be either type.

2. Step 2: Analyze the example function

   The function accepts either an int or a string as input.

3. Final Answer:

   Accept multiple types for a parameter or return value -> Option B

4. Quick Check:

   Union types allow multiple types [OK]

Hint: Look for the | symbol to spot union types [OK]

Common Mistakes:

• Thinking union types combine functions
• Assuming only one type is allowed
• Confusing union types with type casting

2. Which of the following is the correct syntax for a union type in PHP 8+?
function test(?? $param) {}

easy

A. int|string, float $param

B. int&string $param

C. int|string&float $param

D. int|string $param

Solution

1. Step 1: Recall union type syntax

   Union types use the | symbol between types, e.g., int|string.

2. Step 2: Check each option

   int|string $param uses | correctly. int&string $param uses & which is intersection, not union. int|string&float $param mixes union and intersection incorrectly. int|string, float $param uses a comma which is invalid.

3. Final Answer:

   int|string $param -> Option D

4. Quick Check:

   Union types use | symbol [OK]

Hint: Union types always use | between types [OK]

Common Mistakes:

• Using & instead of | for union types
• Separating types with commas
• Mixing intersection and union syntax incorrectly

3. What will be the output of this PHP code?

function showType(int|string $value) {
    if (is_int($value)) {
        return "Integer: $value";
    } else {
        return "String: $value";
    }
}

echo showType(10) . "\n";
echo showType("hello") . "\n";

medium

A. 10\nhello

B. String: 10\nInteger: hello

C. Integer: 10\nString: hello

D. Error: Type mismatch

Solution

1. Step 1: Understand the function behavior

   The function checks if the input is an integer or string and returns a formatted string accordingly.

2. Step 2: Trace the calls

   Calling with 10 (int) returns "Integer: 10". Calling with "hello" (string) returns "String: hello".

3. Final Answer:

   Integer: 10\nString: hello -> Option C

4. Quick Check:

   Type check returns correct output [OK]

Hint: Check type with is_int or is_string inside function [OK]

Common Mistakes:

• Assuming output is just values without labels
• Confusing string and int outputs
• Expecting a type error for valid union types

4. Identify the error in this PHP function using union types:

function add(int|float $a, int|float $b): int|float {
    return $a + $b;
}

add(5, "10");

medium

A. Passing a string "10" instead of int or float causes a type error

B. Return type should be only int

C. Union types cannot be used in return types

D. Function should not accept two parameters

Solution

1. Step 1: Check parameter types

   The function expects parameters of type int or float only.

2. Step 2: Analyze the function call

   The call passes 5 (int) and "10" (string). String is not allowed, causing a type error.

3. Final Answer:

   Passing a string "10" instead of int or float causes a type error -> Option A

4. Quick Check:

   Parameter types must match union types exactly [OK]

Hint: Check argument types match union types exactly [OK]

Common Mistakes:

• Assuming string '10' is accepted as int
• Thinking union types disallow return types
• Ignoring parameter count

5. You want a function that accepts either an array of integers or a single integer and returns the sum. Which union type and code is correct?

function sumValues(?? $input): int {
    if (is_array($input)) {
        return array_sum($input);
    }
    return $input;
}

hard

A. int|array $input

B. int|string $input

C. array|float $input

D. int|bool $input

Solution

1. Step 1: Identify input types needed

   The function accepts either a single integer or an array of integers.

2. Step 2: Match union type to input

   int|array $input uses int|array, which matches the requirement. Others include wrong types like string, float, or bool.

3. Final Answer:

   int|array $input -> Option A

4. Quick Check:

   Union type matches all accepted input types [OK]

Hint: Match union types exactly to all input types needed [OK]

Common Mistakes:

• Using string or bool instead of array
• Not including all input types in union
• Confusing float with int