Why DNF types (Disjunctive Normal Form) in PHP? - Purpose & Use Cases

The Big Idea

What if you could tame wild, tangled conditions into neat, easy-to-understand groups?

The Scenario

Imagine you have to check many different conditions for a user input manually, like if the input is a number or a string, and if it meets several rules combined with ANDs and ORs.

Writing all these checks by hand can get very confusing and messy.

The Problem

Manually writing complex condition checks is slow and easy to mess up.

You might forget a case or mix up ANDs and ORs, causing bugs that are hard to find.

The Solution

DNF types let you organize conditions clearly as a list of OR groups, each with AND conditions inside.

This makes your code easier to read, check, and maintain.

Before vs After

✗ Before

$valid = (is_int($x) && $x > 0) || (is_string($x) && strlen($x) > 3);

✓ After

type DNF = array<array<string>>; // groups of conditions combined with AND inside OR groups

What It Enables

It lets you handle complex condition checks cleanly and safely, avoiding mistakes and saving time.

Real Life Example

Validating user input where multiple different formats are allowed, like a number in a range OR a string with certain length.

Key Takeaways

Manual condition checks get confusing fast.

DNF types organize conditions as OR of AND groups.

This makes code clearer and less error-prone.

Practice

1.

What does a Disjunctive Normal Form (DNF) type represent in PHP?

easy

A. A type that disables type checking

B. A type that combines OR (union) and AND (intersection) conditions

C. A type that restricts variables to integers only

D. A type that only allows a single data type

Solution

1. Step 1: Understand DNF type concept

   DNF types combine multiple conditions using OR (union) and AND (intersection) to specify allowed types.

2. Step 2: Compare options with definition

   Only the type that combines OR (union) and AND (intersection) conditions correctly describes this combination of OR and AND conditions in PHP types.

3. Final Answer:

   A type that combines OR (union) and AND (intersection) conditions -> Option B

4. Quick Check:

   DNF types = OR + AND conditions [OK]

Hint: DNF means combining OR and AND in types [OK]

Common Mistakes:

• Thinking DNF only means union types
• Confusing DNF with simple single types
• Assuming DNF disables type checks

2.

Which of the following is the correct PHP syntax for a DNF type combining union and intersection?

function example( /* type here */ $param) {}

easy

A. int&float&Serializable

B. int&float|Serializable

C. int|float|Serializable

D. int|float&Serializable

Solution

1. Step 1: Recall PHP DNF syntax rules

   PHP uses | for union (OR) and & for intersection (AND). Intersection has higher precedence, so int|float&Serializable means int OR (float AND Serializable).

2. Step 2: Analyze each option

   int|float&Serializable correctly uses union and intersection combined. int&float|Serializable misplaces operators, C uses only union, D uses only intersection.

3. Final Answer:

   int|float&Serializable -> Option D

4. Quick Check:

   Union (|) and intersection (&) combined correctly = int|float&Serializable [OK]

Hint: Use | for OR, & for AND in PHP types [OK]

Common Mistakes:

• Mixing order of | and & operators
• Using only unions or only intersections
• Writing invalid syntax like &| or |&

3.

What is the output of this PHP code snippet?

interface A {} 
interface B {} 
class C implements A, B {} 
function test(A|B&object $param): string { 
  return $param instanceof B ? 'Yes' : 'No'; 
} 
$obj = new C(); 
echo test($obj);

medium

A. Fatal error

B. No

C. Yes

D. Empty output

Solution

1. Step 1: Understand the type declaration

   The parameter type is A OR (B AND object). Class C implements both A and B, so it matches the type.

2. Step 2: Evaluate the instanceof check

   $obj is instance of B, so the ternary returns 'Yes'.

3. Final Answer:

   Yes -> Option C

4. Quick Check:

   Object matches B, so output is 'Yes' [OK]

Hint: Check instanceof for intersection parts in DNF types [OK]

Common Mistakes:

• Assuming type mismatch causes error
• Ignoring intersection precedence
• Thinking output is 'No' without checking instanceof

4.

Identify the error in this PHP function using DNF types:

function checkType(int|float&Countable $value) { 
  return is_countable($value); 
}

medium

A. Invalid use of & with float, which is not an object

B. Missing return type declaration

C. is_countable() cannot be used here

D. int and float cannot be unioned

Solution

1. Step 1: Analyze intersection with primitive types

   float is a primitive type and cannot be combined with & Countable (an interface) because & requires object types.

2. Step 2: Confirm error cause

   Using & between float and Countable causes a type error since float is not an object.

3. Final Answer:

   Invalid use of & with float, which is not an object -> Option A

4. Quick Check:

   Intersection requires objects, float is primitive [OK]

Hint: Intersection (&) only works with object types [OK]

Common Mistakes:

• Thinking primitives can be intersected with interfaces
• Ignoring PHP type system rules
• Assuming is_countable() causes error

5.

Given these interfaces and classes:

interface X {} 
interface Y {} 
class A implements X {} 
class B implements Y {} 
class C implements X, Y {}

Which DNF type correctly accepts objects that implement either X alone, or both X and Y together?

hard

A. X|(X&Y)

B. X&Y|Y

C. X|Y

D. (X|Y)&Y

Solution

1. Step 1: Understand the requirement

   Accept objects that implement X alone OR both X and Y together.

2. Step 2: Translate to DNF

   This means either X alone OR (X AND Y). X|(X&Y) expresses this as X|(X&Y).

3. Step 3: Check other options

   X&Y|Y includes Y alone, which is incorrect. X|Y accepts X or Y alone, too broad. (X|Y)&Y includes Y alone, which is incorrect.

4. Final Answer:

   X|(X&Y) -> Option A

5. Quick Check:

   DNF matches X alone or X and Y together = X|(X&Y) [OK]

Hint: Use union of X and intersection X&Y for this case [OK]

Common Mistakes:

• Choosing simple union X|Y which is too broad
• Misplacing parentheses changing logic
• Confusing intersection and union precedence