Soplang Variables

Naming Conventions

When naming variables in Soplang, follow these guidelines for clarity and consistency:

Valid Variable Names

// Good variable names
door user_name = "John"   // Using underscores
door userName = "John"    // Using camelCase
door age = 25            // Simple and clear
door isActive = true     // Boolean with descriptive name

// Bad variable names
door a = "John"          // Too short, not descriptive
door x1 = 25             // Not meaningful
door thisisaveryverylongvariablenamethatisnoteasytoread = true  // Too long

Naming Style

• Use camelCase for variable names (e.g., userName, firstNumber)
• Use PascalCase for class names (e.g., Person, UserProfile)
• Use snake_case as an alternative for variable names (e.g., user_name, total_amount)

Variable Scope

The scope of a variable defines where the variable can be accessed within your code.

Global Scope

Variables declared outside any function or block have global scope and can be accessed from anywhere in the program.

// Global variable
door app_name = "Soplang Demo"

howl display_app_info() {
    // Global variable accessible inside function
    qor("App: " + app_name)
}

display_app_info()  // Prints "App: Soplang Demo"

Local Scope

Variables declared inside a function or block have local scope and can only be accessed within that function or block.

howl calculate_area() {
    // Local variables
    door width = 10
    door height = 5
    door area = width * height
    
    soo_celi area
}

door result = calculate_area()
qor(result)  // Prints 50

// This would cause an error:
// qor(width)  // Error: width is not defined in this scope

Variable Shadowing

When a local variable has the same name as a global variable, the local variable "shadows" the global one within its scope.

door count = 5  // Global variable

howl display_count() {
    door count = 10  // Local variable that shadows the global one
    qor("Local count: " + count)  // Prints "Local count: 10"
}

display_count()
qor("Global count: " + count)  // Prints "Global count: 5"

Lexical Scope

Soplang uses lexical scoping, which means that inner functions have access to variables declared in their outer function.

howl create_counter() {
    door count = 0  // Variable in outer function
    
    // Inner function has access to count
    howl increment() {
        count = count + 1
        soo_celi count
    }
    
    soo_celi increment  // Return the inner function
}

door counter = create_counter()
qor(counter())  // Prints 1
qor(counter())  // Prints 2
qor(counter())  // Prints 3

Constants

Constants are variables whose values cannot be changed after initialization. In Soplang, you declare constants using the joogto keyword.

// Defining constants
joogto PI = 3.14159
joogto MAX_USERS = 100
joogto APP_VERSION = "1.0.0"

// Constants cannot be changed
// PI = 3.14  // This would cause an error

// Using constants
door radius = 5
door area = PI * radius * radius
qor("Area: " + area)  // Prints "Area: 78.53975"

Best Practices

• Use Static Typing for Better Type Safety

  While dynamic typing offers flexibility, static typing helps catch type-related errors earlier.

  static_typing_best_practice.sop

  Copy

  // Prefer static typing for important variables
  tiro user_count = 42
  qoraal status = "active"

• Initialize Variables When Declaring

  Initialize variables at the time of declaration to avoid undefined value errors.

  initialization_best_practice.sop

  Copy

  // Good practice
  door user_name = "Default"
  
  // Instead of
  // door user_name
  // ... code ...
  // user_name = "Default"

• Use Descriptive Names

  Choose descriptive variable names that clearly indicate their purpose.

  descriptive_names.sop

  Copy

  // Good variable names
  door user_age = 25
  door is_logged_in = true
  door product_price = 29.99
  
  // Instead of
  door a = 25
  door b = true
  door c = 29.99

• Limit Variable Scope

  Keep variables in the smallest scope necessary to avoid naming conflicts and improve code clarity.

  limit_scope.sop

  Copy

  // Prefer local variables when possible
  howl calculate_total(prices) {
      door total = 0  // Local variable only used in this function
      
      ku_celi price ku dhex jira prices {
          total = total + price
      }
      
      soo_celi total
  }

• Use Constants for Fixed Values

  Use constants for values that should not change during program execution.

  use_constants.sop

  Copy

  // Use constants for configuration and fixed values
  joogto API_URL = "https://api.example.com"
  joogto MAX_ATTEMPTS = 3
  joogto TAX_RATE = 0.07
  
  // Use in code
  door remaining_attempts = MAX_ATTEMPTS
  door price_with_tax = price_of_item * (1 + TAX_RATE)