Chapter 2: Basics of Cairo programming

Cairo is a high-stage programming language particularly designed for writing applications that can be effectively proven via zero-information (ZK) proofs. It’s a key aspect of the StarkNet ecosystem, a layer-2 scaling solution for Ethereum. This segment will delve into the essential elements of Cairo programming, masking syntax, information types, variables, constants, mutability, feedback, code shape, and arithmetic operations.

Cairo Language Syntax

Cairo’s syntax is designed to be noticeably person-pleasant and attracts concept from Python, making it simpler to learn for developers familiar with excessive-level languages. Here are some key aspects of Cairo’s syntax:

1. Indentation:

• Cairo uses indentation to define code blocks, similar to Python.
• Proper code execution requires consistent indentation.
• The indentation degree determines which traces of code belong to a particular block (e.G., within a characteristic, loop, or conditional announcement).

Example:

Code snippet

func my_function(x: felt) -> felt {
    let y = x + 1;  # This line is within the function block
    return y; 
}

2. Semicolons:

• Unlike many other programming languages, semicolons are optional in Cairo.
• You can use them if you prefer, but they are not required to end statements.

3. Keywords:

• Cairo has a set of reserved keywords with specific meanings.
• Keywords cannot be utilized as variable or function identifiers.
• Some important keywords include:
  • let: Used to declare variables.
  • const: is a keyword used to define constants, which are immutable values.
  • func: Used to define functions.
  • return: keyword is used to output a value from a function.
  • if, else, elif: Used to define and handle conditional logic in programming.
  • for, while: Used for loops.

4. Comments:

• Single-line comments: Start with # Code snippet# This is a single-line comment
• Multi-line comments: Enclosed within %{ and %} Code snippet%{ This is a multi-line comment that can span multiple lines. %}

5. Function Definitions:

• Functions are defined using the func keyword.
• Parameters and a return type can be part of them.

Example:

Code snippet

func add_numbers(a: felt, b: felt) -> felt { 
    return a + b; 
}

Key Considerations:

• Readability: Proper indentation and clear variable naming are essential for writing readable and maintainable Cairo code.
• Consistency: Adhering to consistent coding style conventions improves code readability and maintainability within a project.

Primitive Types and Variables in Cairo

Cairo, like other programming languages, utilizes data types to define the kind of values a variable can hold. Here’s a breakdown of primitive types and how variables are declared in Cairo:

1. Primitive Data Types

• felt:
  • The fundamental data type in Cairo.
  • Represents a field element, essentially an integer within a specific range.
  • It’s the most commonly used data type in Cairo.
• bool:
  • Represents the two possible boolean states: True or False.
• Unit:
  • Represents a state of emptiness or nullity.
  • Often used as the return type of functions that don’t return any specific value.

2. Variables

• Declaration: Variables are declared using the let keyword.
  • Example: let x = 6;
    • This declares a variable named x and assigns the value 6 to it.
• Type Inference: Cairo often infers the facts type of a variable based totally at the assigned fee.
  • For example, let x = 6; infers that x is of type felt.
• Explicit Type Annotation (Optional): You can explicitly specify the data type of a variable:
  • Example: let y: felt = 10;

Key Points:

• Write-Once Memory Model: Cairo has a unique write-once memory model. Once a memory location is written to, it cannot be modified later. This restriction is crucial for the security and verifiability of Cairo programs.
• Mutability: While technically mutable, the write-once nature of memory limits how variables can be changed.

Example:

Code snippet

let x = 5; 
let y: bool = True; 

func my_function() -> Unit {
    # ... some logic ...
    return (); 
}

In Summary:

Understanding primitive data types and how to declare variables in Cairo is fundamental to writing effective Cairo programs. The felt type is central to most Cairo operations, and the write-once memory model significantly influences how you approach variable usage and data manipulation within the Cairo environment.

Constants and Mutability in Cairo

Cairo, while inspired by Python, has a unique approach to variable handling that significantly impacts how you structure your code. Let’s delve deeper into constants and mutability in Cairo:

1. Constants

• Declaration: Declared using the const keyword.
• Immutability: Their values cannot be changed after they are assigned.
• Example: Code snippetconst MY_CONSTANT = 10;
• Purpose:
  • Readability: Improve code readability by giving meaningful names to fixed values.
  • Maintainability: Make it easier to change a value consistently across the codebase by modifying it only in the constant declaration.
  • Security: Help prevent accidental or unintended modifications to critical values within your program.

2. Mutability and the Write-Once Memory Model

• Cairo’s Unique Approach: Cairo employs a write-once memory model. This means that once a memory location is written to, it cannot be modified later.
• Implications:
  • Variables declared with let are essentially immutable by default, even though they are not explicitly declared as const.
  • This restriction is a core principle of Cairo and is crucial for:
    • Security: Preventing unintended data modifications that could compromise the integrity of the program.
    • Verifiability: Simplifying the process of generating and verifying ZK-proofs.

3. Working with “Mutability” (Within Constraints)

• Apparent Mutability: While direct modification is restricted, you can achieve “apparent mutability” through techniques like:
  • Re-assignment: Create a new variable with the updated value.
  • Function Parameters: Pass values into functions and have those functions return modified values.

Example:

Code snippet

let x = 5; 
let y = x + 3; 
# x still retains its original value (5) 

Key Considerations

• Embrace Immutability: The write-once memory model might seem restrictive at first, but it encourages a more functional programming style, which can lead to more robust and secure code.
• Utilize Constants: Leverage constants effectively to improve code readability and maintainability.

In Summary

The concept of constants and the write-once memory model are fundamental to Cairo’s design. By understanding these principles, you can write more secure, efficient, and verifiable Cairo programs.

Comments and Code Structure in Cairo

Effective commenting and proper code structure are crucial for writing maintainable and understandable Cairo code, especially as projects grow in complexity.

1. Comments

• Purpose:
  • Explain reasoning: Use comments to explain why certain code exists, the thought process behind design decisions, and any logic that isn’t immediately clear.
  • Document assumptions: Clarify any assumptions made in the code.
  • Improve readability: Make the code easier to understand for both the original author and other developers.
• Types of Comments:
  • Single-line comments:
    • Begin with #Example: # This line adds two numbers
    Multi-line comments:
    • Enclosed within %{ and %}Useful for longer explanations or documenting complex logic.
  Code snipp

%{ 
This is a multi-line comment that can span multiple lines. 
%}

2. Code Structure

• Functions:
  • Use functions to divide complex logic into simpler, more digestible components.
  • Each function need to have a clean and concise call that reflects its motive.
  • Ensure that parameter and variable names are descriptive and significant.
  • Add comments to explain the function’s purpose, its parameters, and its return value.
• Control Flow:
  • Use if, else, elif for conditional statements.
  • Use iteration with for and while loops.
  • Indent code blocks consistently within control flow structures.
• Modules:
  • Organize code into modules to enhance code reusability and maintainability.
  • A module is a collection of functions and statistics which are related to every different.
  • Use modules to encapsulate functionality and avoid namespace collisions.

Example (Illustrating Code Structure and Comments):

Code snippet

%{
This module contains functions for basic arithmetic operations.
%}
module Arithmetic {
    func add(a: felt, b: felt) -> felt {
        # This function adds two felt values.
        return a + b;
    }

    func subtract(a: felt, b: felt) -> felt {
        # This function subtracts the value of b from a.
        return a - b;
    }
}

Best Practices

• Write meaningful comments: Avoid trivial comments that simply restate the obvious.
• Keep comments brief and clear.
• Update comments whenever you modify the code.
• Use the same commenting format consistently throughout the project.

Arithmetic Operations in Cairo

Cairo supports a set of fundamental arithmetic operations that are essential for performing calculations within your programs. Here’s a breakdown:

1. Basic Arithmetic Operations:

• Addition:+
  • Example: let result = 5 + 3;
• Subtraction:-
  • Example: let result = 10 - 4;
• Multiplication:*
  • Example: let result = 2 * 6;
• Division:/
  • Important: Cairo’s division operation returns a felt result, which represents an integer.
  • If the division outcomes in a non-integer value, the end result will be rounded down.
  • Example: let result = 11 / 3; (In this case, result will be 3.)
• Modulo:%
  • Provides the remainder after dividing two numbers.
  • Example: let result = 11 % 3; (In this case, result will be 2.)

2. Example:

Code snippet

func calculate(x: felt, y: felt) -> felt {
    let sum = x + y;
    let difference = x - y;
    let product = x * y;
    # Assume y is not zero
    let quotient = x / y; 
    let remainder = x % y; 

    return sum; 
}

3. Key Considerations:

• Felt Type: Remember that all arithmetic operations in Cairo primarily operate on the felt data type.
• Overflow and underflow: Pay attention to possible overflow. (exceeds the maximum value of the felt) or underflow (below the minimum value) in mathematical operations…
• Divide by zero: Avoid division by zero. Because this will result in an error.

4. Advanced Arithmetic Operations:

• Although Cairo has basic mathematical operations, But you can often perform more complex math functions using these building blocks.
• For example, you can create a function to calculate powers, square roots, or trigonometric functions.

In Summary:

Arithmetic operations are fundamental to most Cairo programs. By understanding how to perform basic arithmetic and the specific considerations within the Cairo environment, you can effectively implement the logic required for your applications.

FAQ

Q: What is the difference between let and const in Cairo? A: let is used to declare variables whose values can be modified (within the constraints of Cairo’s write-once memory model), while const is used to declare constants whose values cannot be changed after they are assigned.

Q: Why is Cairo’s memory model write-once? A: Cairo’s write-once memory model is essential for ensuring the security and verifiability of Cairo programs. It prevents unintended modifications to data, making it easier to generate and verify ZK-proofs.

Q: How does Cairo handle division? A: Caro’s division operation yields perceptible results. which is an integer within the specified range. If the division results in a non-integer value Results are rounded down.

Q: What are some common use cases for Cairo? A: Cairo is primarily used for developing smart contracts on the StarkNet blockchain. Some common use cases include creating decentralized exchanges (DEXs), building non-fungible token (NFT) marketplaces, and developing decentralized applications (dApps) for various purposes.

This comprehensive guide provides a solid foundation for understanding the basics of Cairo programming. By mastering these fundamental concepts, you can begin to explore more advanced Cairo features and build sophisticated applications on the StarkNet ecosystem.