Union types in PHP - Step-by-Step Execution

Concept Flow - Union types

Function with Union Type

↓

Call function with value

↓

Check if value matches any type

↓

Run function

↓

Return result

The function accepts values of multiple types. It checks the input type and runs if it matches any allowed type, else it errors.

Execution Sample

PHP

<?php
function example(int|string $value): string {
  return "Value is: $value";
}

echo example(10);
echo example("hello");

This code defines a function that accepts either an int or a string and returns a string showing the value.

Execution Table

Step	Function Call	Parameter Type	Type Check Result	Action	Output
1	example(10)	int	Matches int|string	Function runs	Value is: 10
2	example("hello")	string	Matches int|string	Function runs	Value is: hello
3	example(3.14)	float	Does not match int|string	Type error thrown	Fatal error

💡 Execution stops on type error when input does not match any union type.

Variable Tracker

Variable	Start	Call 1	Call 2	Call 3
$value	undefined	10 (int)	"hello" (string)	3.14 (float)

Key Moments - 2 Insights

Why does example(3.14) cause an error?

Because 3.14 is a float and the function only accepts int or string, as shown in execution_table row 3.

Can the function accept both int and string in the same call?

No, each call passes one value. The union means the value can be either int or string, not both at once.

Visual Quiz - 3 Questions

Look at the execution table, what is the output when calling example(10)?

A "Value is: hello"

B Fatal error

C "Value is: 10"

D No output

💡 Hint

Check row 1 in the execution_table for output of example(10).

At which step does the type check fail?

A Step 3

B Step 2

C Step 1

D No failure

💡 Hint

Look at the 'Type Check Result' column in execution_table.

If the function accepted float as well, what would happen at step 3?

A Output is empty string

B Function runs and outputs value

C Type error still thrown

D Program crashes

💡 Hint

If float was added to union, step 3 would match and function would run.

Concept Snapshot

Union types allow a function parameter or return to accept multiple types.
Syntax: function foo(int|string $param): string
The function runs if input matches any type in the union.
If input type does not match, a type error occurs.
Useful for flexible but type-safe code.

Full Transcript

This example shows how PHP union types work. The function example accepts either an int or a string as input. When called with 10 (an int), it runs and returns 'Value is: 10'. When called with 'hello' (a string), it runs and returns 'Value is: hello'. But when called with 3.14 (a float), it causes a type error because float is not in the union. The execution table traces each call, showing the parameter type, type check result, action, and output. The variable tracker shows how the input variable changes with each call. Key moments clarify why the error happens and that the function accepts one type per call. The quiz tests understanding of outputs and type checks. The snapshot summarizes union types as a way to accept multiple types safely in PHP functions.

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