Modules

Makes a function, class, or constant available to other modules.

# math.sl

# Private function (not exported)
def validate_number(n: Int) -> Bool
  n >= 0
end

# Exported functions
export def add(a: Int, b: Int) -> Int
  a + b
end

export def subtract(a: Int, b: Int) -> Int
  a - b
end

export def multiply(a: Int, b: Int) -> Int
  a * b
end

export def divide(a: Int, b: Int) -> Float
  if (b == 0)
    panic("Division by zero")
  end
  float(a) / float(b)
end

export def factorial(n: Int) -> Int
  if (n <= 1)
    return 1
  end
  n * factorial(n - 1)
end

Modules can contain classes, enabling organized domain-driven code structures.

# shapes.sl

module Shapes
  class Circle
    radius: Float

    new(radius: Float)
      this.radius = radius
    end

    def area -> Float
      3.14159 * this.radius * this.radius
    end

    def perimeter -> Float
      2 * 3.14159 * this.radius
    end
  end

  class Rectangle
    width: Float
    height: Float

    new(width: Float, height: Float)
      this.width = width
      this.height = height
    end

    def area -> Float
      this.width * this.height
    end

    def perimeter -> Float
      2 * (this.width + this.height)
    end
  end
end

Modules can also contain nested classes using the :: pattern for domain organization.

# commerce.sl

module Commerce
  class Product
    name: String
    price: Float
    quantity: Int

    new(name: String, price: Float, quantity: Int)
      this.name = name
      this.price = price
      this.quantity = quantity
    end

    def in_stock -> Bool
      this.quantity > 0
    end

    def discounted(percent: Float) -> Float
      this.price * (1 - percent / 100)
    end
  end

  class Cart
    items: Product[]

    new
      this.items = []
    end

    def add(product: Product)
      this.items.push(product)
    end

    def total -> Float
      sum = 0.0
      for item in this.items
        sum = sum + item.price
      end
      sum
    end
  end
end

Import classes from modules using named imports or module namespace.

# Import the Commerce module from commerce.sl
import Commerce from "./commerce.sl"

# Use classes from the module
book = new Commerce.Product("Soli Guide", 29.99, 10)
shirt = new Commerce.Product("T-Shirt", 19.99, 3)

println(book.in_stock())          # true
println(book.discounted(20.0))    # 23.992

cart = new Commerce.Cart()
cart.add(book)
cart.add(shirt)
println(cart.total())             # 49.98

Import functions and classes from other modules.

# Import all exports
import "./math.sl"
print(add(2, 3));        # 5
print(factorial(5));     # 120

# Named imports
import { add, multiply } from "./math.sl"
sum = add(1, 2);          # 3
product = multiply(3, 4); # 12

# Aliased imports
import { add as sum, multiply as times } from "./math.sl"
result = sum(10, 20);  # 30
doubled = times(5, 6); # 30

# Import everything with a namespace
import "./utils.sl" as utils
formatted = utils.format_date(DateTime.utc());

Alternative syntax for importing (alias for import).

use "./math.sl"
use { add, multiply } from "./math.sl"
use "./utils.sl" as utils;