Modules & Imports

Almide organizes code into modules. The standard library provides modules for common operations, and user packages are imported the same way.

Your own files are modules too. The sample below has two of them — switch tabs inside the playground to see greeting.almd, and note that the file name is the module name:

Almide Run

main.almdgreeting.almd

import self.greeting

fn main() -> Unit = {
  println(greeting.polite("Ada"))
  println(greeting.casual("Ada"))
}

Press Run to compile and execute this in your browser

Locally the same code is a project: src/main.almd plus src/greeting.almd.

Import syntax

Import a module to use its functions:

import fs
import json
import regex

effect fn main() -> Result[Unit, String] = {
  let content = fs.read_text("data.json")
  let data = json.parse(content)
  ok(())
}

All stdlib functions are called with a module prefix: fs.read_text(...), json.parse(...), string.trim(...).

Import forms

Form	Syntax	Example
Simple	import module	import fs
Alias	import module as name	import mylib as m
Sub-module	import pkg.sub	import mylib.parser
Selective	import pkg.{Name1, Name2}	import mylib.{Parser, Lexer}
Self-alias	import self as name	import self as app

Wildcard imports (import fs.*) are a compile error.

Auto-imported modules (prelude)

These modules are available without import:

Module	Description
string	String manipulation
list	List operations
map	Map operations
set	Set operations
int	Integer utilities
float	Float utilities
math	Mathematical functions
result	Result combinators
option	Option combinators
value	Dynamic value operations
error	Error construction and chaining
datetime	Date and time operations
bytes	Binary data
matrix	Matrix operations
int8…uint64, float32	Sized numeric types

Auto-imported types and constructors:

• Primitives: Int, Float, Bool, String, Unit, Path
• Collections: List[T], Map[K, V], Set[T]
• Error handling: Option[T], Result[T, E]
• Constructors: some(x), none, ok(x), err(x)
• Booleans: true, false
• Boundary: Value

Import-required modules

These modules require an explicit import:

Module	Description
fs	File system operations (effect)
env	Environment variables, timestamps (effect)
io	Standard I/O (effect)
process	Process execution (effect)
json	JSON parsing and building
random	Random number generation (effect)
regex	Regular expressions
http	HTTP client (effect)
testing	Extended test assertions

Bundled modules (pure Almide)

These are implemented in Almide itself and imported the same way:

Module	Description
args	Command-line argument parsing
path	File path manipulation
base64	Base64 encoding
hex	Hexadecimal encoding

Aliased imports

Use as to create a shorter name for a module:

import mylib as m
m.hello()

Self-alias lets you reference the current package by name. import self loads the package entry point src/mod.almd, so that file must exist; a sibling file is reached with import self.<name> and needs no entry point:

import self as app       // requires src/mod.almd
app.some_function()

Selective imports

Import specific types or items from a module:

import mylib.{Parser, Lexer}

This brings Parser and Lexer directly into scope without a prefix.

Visibility

Declarations default to public. Use mod or local to restrict access:

Modifier	Scope
(none)	Public — accessible from anywhere
mod	Same project only
local	Same file only

fn public_api() -> String = "anyone"
mod fn project_only() -> String = "same project"
local fn file_only() -> String = "same file"

Visibility applies to functions, types, and top-level let bindings:

local type InternalState = { data: String }
mod let INTERNAL_LIMIT = 100

Package configuration

Package identity is declared in almide.toml, not in source files. There is no module or package declaration at the top of .almd files.

Next steps

• Functions — visibility modifiers on functions
• Types & Values — custom types and records
• Generics — parameterized types and bounds