---

Master Airport Robot in Cairo: Complete Learning Path

The Airport Robot module from kodikra.com's exclusive curriculum is a fundamental challenge that teaches Cairo developers how to manage state and control flow using enums and pattern matching. Mastering this concept is essential for building robust, predictable, and secure smart contracts on StarkNet.

Ever felt overwhelmed trying to manage different states or conditions in your code? You might have a variable that can be one of several specific things, and you end up tangled in a messy web of if-else statements. This approach is not only hard to read but is also prone to errors, especially in a high-stakes environment like blockchain where a single bug can be catastrophic. This is a common pain point for developers transitioning to languages with strong type systems and functional paradigms like Cairo.

This comprehensive guide will walk you through the Airport Robot problem, transforming it from a simple exercise into a powerful mental model for smart contract development. We will deconstruct the core concepts of enums and pattern matching, show you how to implement them with clean, efficient Cairo code, and connect this knowledge directly to real-world decentralized applications. By the end, you'll not only solve the challenge but also gain a foundational skill for writing professional-grade StarkNet contracts.

---

What is the Airport Robot Logic Problem?

At its core, the Airport Robot is a logic problem designed to teach one of the most powerful features in modern systems programming languages: pattern matching on enumerated types (enums). The scenario is simple: you are programming a robot at an international airport. This robot needs to provide a welcome greeting in the correct language based on the luggage tag it scans.

The luggage tag can only be from a predefined set of languages (e.g., English, Japanese, Spanish, Russian, etc.). The robot's primary function is to take a language identifier as input and return the corresponding greeting string as output. If it encounters a language it doesn't recognize from its predefined list, it should provide a default, universal greeting.

This problem is a cornerstone of the Cairo learning path at kodikra because it perfectly encapsulates the concept of a state machine in its simplest form. The "state" is the language, and the program's behavior (the greeting) changes based on that state. It forces you to think about handling a finite set of possibilities in a structured, safe, and readable way, moving away from error-prone conditional chains.

The Core Concepts: Enums and Pattern Matching

To solve this, you must master two key Cairo features:

• Enums (Enumerations): An enum is a custom type that allows you to define a set of named variants. For the Airport Robot, you would define a Language enum with variants like English, Japanese, Spanish, and so on. This creates a type-safe way to represent the different possible languages, preventing bugs from typos or invalid inputs that you might get with simple strings or numbers.
• Pattern Matching (The match expression): A match expression is a powerful control flow construct that allows you to compare a value against a series of patterns and execute code based on which pattern matches. Unlike a simple switch statement in other languages, Cairo's match is exhaustive. The compiler will force you to handle every possible variant of an enum, ensuring you never forget a case.

By combining enum and match, you create code that is not only functional but also self-documenting and incredibly robust. The compiler becomes your partner in ensuring correctness.

---

Why is This Pattern Crucial for Cairo and StarkNet?

While the Airport Robot seems like a trivial academic problem, the underlying pattern is fundamental to almost every smart contract you will ever write. Smart contracts are, by their very nature, state machines. They exist in a specific state, and their state transitions are governed by the functions users call.

Understanding how to manage these states cleanly and safely is non-negotiable for a blockchain developer. Errors in state management can lead to locked funds, security vulnerabilities, and catastrophic failures.

Direct Parallels in Smart Contract Development

• DeFi Protocols: A lending protocol contract might have a LoanStatus enum with variants like Requested, Active, Repaid, and Liquidated. Every function that interacts with a loan would use a match statement to ensure it only performs valid actions for the loan's current state (e.g., you can't liquidate a loan that's already been repaid).

• NFT Auctions: An auction contract would use an AuctionState enum with variants like Pending, Open, Closing, and Finished. The bid() function would only work when the state is Open, and the claimNFT() function would only work when the state is Finished.

• DAO Governance: A Decentralized Autonomous Organization's voting contract would have a ProposalStatus enum: Draft, Voting, Succeeded, Defeated, Executed. The logic for tallying votes or executing a proposal is strictly controlled by matching against the current status.

In all these examples, using enums and exhaustive pattern matching prevents developers from forgetting to handle a specific state, a common source of bugs. The Cairo compiler's exhaustiveness check is a powerful safety net that makes your smart contracts more secure by default.

Furthermore, this pattern often leads to more gas-efficient code. A well-structured match statement can be compiled down to a highly optimized jump table, which is often faster than a long chain of if-else checks, saving users money on transaction fees.

---

How to Implement the Airport Robot in Cairo

Let's dive into the practical implementation. We'll build the solution step-by-step, explaining the syntax and logic as we go. This code is based on modern Cairo syntax, which emphasizes safety and clarity.

Step 1: Defining the Language Enum

First, we need to define our custom type for the languages. We use the enum keyword. In Cairo, it's common to use the #[derive(Drop, Serde)] attribute to automatically generate code for memory management and serialization, which is good practice.

use starknet::serde::Serde;

#[derive(Drop, Serde)]
enum Language {
    English,
    Japanese,
    Russian,
    Spanish,
    German,
}

This code defines a new type called Language. A variable of this type can only hold one of the specified values: English, Japanese, Russian, Spanish, or German. The compiler will now prevent you from assigning any other value to a Language variable.

Step 2: Creating the Welcome Function with Pattern Matching

Next, we'll create the main function, welcome, which takes our Language enum as input and returns a greeting. The core of this function is the match expression.

The return type is felt252, which is the standard type for short strings in Cairo. Note that strings in Cairo are not as straightforward as in other languages; a felt252 can hold up to 31 ASCII characters.

fn welcome(language: Language) -> felt252 {
    match language {
        Language::English => 'Welcome',
        Language::Japanese => 'Yokoso',
        Language::Russian => 'Dobro pozhalovat',
        Language::Spanish => 'Bienvenido',
        Language::German => 'Willkommen',
        // In a real-world scenario, you might have a catch-all
        // But for this specific problem, we handle all defined variants.
    }
}

Let's break down the match block:

• match language { ... }: This tells the compiler we want to inspect the value of the language variable.
• Language::English => 'Welcome',: This is a "match arm". It says, "If the value of language is the English variant, then this entire expression evaluates to the short string 'Welcome'".
• Each variant of the Language enum is handled in its own arm.
• Exhaustiveness: If you were to add a new variant, say Language::French, to the enum but forgot to add a corresponding arm in the match statement, the Cairo compiler would produce an error. This is a critical safety feature.

ASCII Diagram: Logic Flow of the Welcome Function

The flow of data and logic in our function can be visualized clearly. The input is strictly typed, flows into the match expression, and a specific output is selected based on the variant.

    ● Start: `welcome` function call
    │
    ▼
  ┌─────────────────────────┐
  │ Input: `language: Language` │
  └────────────┬────────────┘
               │
               ▼
    ◆ Match on `language` variant
   ╱      │      │      ╲
  ├.is_English?  ├.is_Japanese? ...etc.
  │       │      │      │
  ▼       ▼      ▼      ▼
['Welcome'] ['Yokoso'] [...] [Default]
  │       │      │      │
  └───────┴───┬──┴───────┘
              │
              ▼
  ┌────────────────────────┐
  │ Output: `greeting: felt252` │
  └────────────────────────┘
               │
               ▼
             ● End

Step 3: Handling Unknown or "Default" Cases

The kodikra module for Airport Robot often includes a requirement to handle a default case. In a more complex scenario where your enum represents many possibilities, you might want a catch-all. You can achieve this with the underscore _ pattern.

Let's modify our function to be more generic.

fn greet(language: Language) -> felt252 {
    match language {
        Language::English => 'Welcome',
        // A catch-all arm for any other language variant
        _ => 'Welcome',
    }
}

In this version, if the language is English, it returns 'Welcome'. For any other variant of the Language enum (Japanese, Russian, etc.), it will fall through to the _ arm and also return 'Welcome'. The _ is a wildcard that matches anything not already matched by the preceding arms.

Testing Your Implementation

To test your Cairo code, you'll typically use the Scarb package manager. You would write a test function that calls your main logic and asserts the output is correct.

Here's a simplified example of what a test command might look like in your terminal after setting up a Scarb project:

# First, build your Cairo project
scarb build

# Then, run the tests defined in your project
scarb test

This command compiles your code and executes any functions marked with the #[test] attribute, reporting whether they passed or failed. This feedback loop is essential for verifying your logic before deploying it as a smart contract.

---

Where This Pattern Shines: Real-World Applications

The Airport Robot is a microcosm of state management in large-scale systems. The skills you build here are directly transferable to complex, high-value applications on StarkNet and other blockchains.

ASCII Diagram: Smart Contract State Machine

This diagram shows how the same logic pattern applies to a typical smart contract, like an escrow agreement.

    ● Initial State: `AwaitingFunds`
    │
    ▼
  ┌───────────────────┐
  │ `deposit()` called │
  └─────────┬─────────┘
            │
            ▼
    ● State: `FundsDeposited`
    │
    ├─ Event: `release()` called by party A ─┐
    │                                        │
    ▼                                        ▼
  ┌─────────────┐                      ┌───────────────────┐
  │ `release()` logic │                      │ `dispute()` logic │
  └──────┬──────┘                      └─────────┬─────────┘
         │                                        │
         ▼                                        ▼
    ● State: `FundsReleased`               ● State: `InDispute`
    │                                        │
    ▼                                        ▼
  [Complete]                             [Arbitration]

This flow—where a contract's state dictates which functions can be called and what they do—is managed using enums for the state and match expressions within the functions to enforce the rules. Mastering the Airport Robot gives you the foundational tool to build such systems safely.

Common Pitfalls and Best Practices

While powerful, there are nuances to consider when using enums and pattern matching in production code. Here is a summary of the advantages and potential risks.

Pros / Best Practices	Cons / Risks to Avoid
Type Safety: Enums prevent invalid state values at the compile level. You can't accidentally assign an integer or a misspelled string.	Enum Bloat: Avoid creating enums with hundreds of variants if they can be better represented by data structures. Overly large enums can be unwieldy.
Exhaustiveness: The compiler forces you to handle every possible case, eliminating a whole class of bugs related to unhandled states.	Overusing Wildcards: Relying too heavily on the _ wildcard can negate the benefit of exhaustiveness. If you add a new enum variant, the wildcard will catch it silently instead of forcing you to implement its specific logic.
Readability: A match statement is often far more readable and self-documenting than nested if-else blocks, clearly showing how each state is handled.	Gas Costs: While often efficient, a match statement with very complex patterns or a huge number of arms can increase gas consumption. Always profile critical contracts.
Centralized Logic: It encourages centralizing state-transition logic in one place, making the contract's behavior easier to audit and understand.	Rigidity: Once an enum is defined and used in a deployed contract, changing it (adding or removing variants) is a breaking change that requires a contract upgrade. Design your enums thoughtfully.

---

Progressing Through the Kodikra Module

The Airport Robot is a foundational step in your Cairo journey. By completing it, you build the confidence and skills needed for more advanced concepts on the StarkNet platform.

This module contains one core exercise that consolidates all these concepts:

• Beginner to Intermediate: The main challenge is designed to be accessible yet comprehensive. It solidifies your understanding of core Cairo syntax before you move on to more complex topics like storage, traits, and interoperability.
  Learn Airport Robot step by step

After mastering this module, you will be well-prepared to tackle more complex logic, data structures, and contract interactions covered in the full Cairo Learning Roadmap on kodikra.com.

---

Frequently Asked Questions (FAQ)

What is an `enum` in Cairo?

An enum, or enumeration, is a custom data type that consists of a set of named values called variants. It allows you to define a type that can only be one of a finite number of things. This is extremely useful for representing states, categories, or options in a type-safe manner, preventing errors that could arise from using simple integers or strings.

How is Cairo's `match` different from a `switch` statement in C++ or Java?

The most significant difference is exhaustiveness. In Cairo, if you use match on an enum, the compiler requires you to provide a "match arm" for every single variant of that enum. If you forget one, your code will not compile. This feature eliminates a common bug where a new state is added but the logic to handle it is forgotten. Standard switch statements do not enforce this, making them more error-prone.

Why use `felt252` for strings in the Airport Robot example?

In Cairo, a felt252 (a field element) is the primitive data type. It can be used to store short strings (up to 31 ASCII characters) directly on-chain in a gas-efficient way. For the short greetings in this exercise, felt252 is the perfect type. For longer, more complex strings, Cairo provides other mechanisms, but for simple, constant strings, felt252 is standard practice.

Can I put data inside an enum variant?

Yes. This is a more advanced feature of enums. Variants can hold associated data. For example, you could define an enum like enum TransactionStatus { Success(felt252), Failed(felt252) }. Here, both the Success and Failed variants carry a felt252 payload, which could be a transaction hash or an error message. You can then extract this data within a match arm.

Is the Airport Robot pattern only useful for smart contracts?

No, not at all. This pattern of using enums for states and pattern matching for control flow is a cornerstone of modern systems programming and is used extensively in languages like Rust, Swift, and Haskell. It is a powerful tool for writing reliable software in any domain, from web servers to compilers to embedded systems. Cairo adopts it because of the extreme need for correctness and safety in the blockchain space.

What happens if I don't want to handle every enum case individually?

That's what the wildcard pattern (_) is for. If you have many enum variants that should all be handled the same way, you can implement the specific cases you care about and then use a final _ => { ... } arm to catch all remaining possibilities. However, use this with caution, as it can hide bugs if you later add a new variant that needs special handling.

How does this concept relate to AI Overviews or Google's SGE?

Structured data and clear, logical patterns like enums and matching are easily understood by AI models. When AI systems like Google's AI Overview analyze code or technical documentation, content that uses these well-defined, exhaustive patterns is easier to parse, summarize, and present as a direct answer. Explaining concepts with this level of structure makes your content more valuable to both humans and AI crawlers.

---

Conclusion: Your First Step to Safer Smart Contracts

The Airport Robot module is far more than a simple programming puzzle; it's a fundamental lesson in writing code that is predictable, robust, and safe. By mastering enums and pattern matching, you are adopting a paradigm that drastically reduces the likelihood of state-related bugs, a critical skill for any developer working with immutable, high-stakes systems like StarkNet smart contracts.

You have learned not only the "how" of the implementation but, more importantly, the "why." You now understand how this simple pattern scales up to manage the complex states of DeFi protocols, DAOs, and NFT marketplaces. This knowledge is your foundation for building the next generation of decentralized applications on a secure and scalable network.

Technology Disclaimer: The Cairo language and the StarkNet ecosystem are under continuous development. The code snippets and concepts discussed are based on Cairo 1.0 and later versions. Always refer to the official StarkNet and Cairo documentation for the most current syntax and best practices.

Back to Cairo Guide

---

Published by Kodikra — Your trusted Cairo learning resource.