Standard Library

The XXML Standard Library provides fundamental types, collections, and utilities for building applications.

Module Structure

text
Language/
├── Core/           # Primitive types (Integer, String, Bool, Float, Double)
├── Collections/    # Generic data structures (List, HashMap, Set, Stack, Queue)
├── System/         # Console I/O
├── IO/             # File operations
├── Math/           # Mathematical functions
├── Text/           # String utilities, Regex
├── Time/           # Date/time handling
├── Format/         # JSON parsing
├── Network/        # HTTP client
├── Reflection/     # Runtime type introspection
├── Concurrent/     # Threading and synchronization
├── Test/           # Unit testing framework
└── Annotations/    # Built-in annotations (@Unsafe, etc.)

Importing Modules

xxml
#import Language::Core;           // Integer, String, Bool, Float, Double
#import Language::Collections;    // List, HashMap, Set, Array, Stack, Queue
#import Language::System;         // Console
#import Language::IO;             // File
#import Language::Math;           // Math utilities
#import Language::Text;           // StringUtils, Pattern
#import Language::Time;           // DateTime, Timer
#import Language::Format;         // JSONObject, JSONArray
#import Language::Network;        // HTTPClient
#import Language::Reflection;     // Type introspection
#import Language::Concurrent;     // Threading
#import Language::Test;           // TestRunner, Assert

Module Reference

Core Types

Integer, String, Bool, Float, Double - primitive wrapper types

Collections

List, HashMap, Set, Array, Stack, Queue - generic data structures

Iterators

ListIterator, SetIterator, HashMapIterator - collection traversal

Console

Console I/O, environment variables, system utilities

File I/O

File reading, writing, and management operations

Text

StringUtils, Pattern - string manipulation and regex

Math

Mathematical functions, random numbers, number theory

Time

DateTime, TimeSpan, Timer - date/time handling

JSON

JSONObject, JSONArray - JSON parsing and generation

HTTP

HTTPClient, HTTPResponse - web requests

Testing

TestRunner, Assert - unit testing framework

Concurrent

Thread, Mutex, Atomic - threading and synchronization

API Reference

Core

Fundamental types including Integer, String, Bool, Float, and Double.

IntegerStringBoolFloatDouble

Collections

Generic collection types including List, HashMap, Set, Array, Stack, and Queue.

List<T>HashMap<K, V>Set<T>Array<T>Stack<T>Queue<T>

System

System-level operations including console I/O, file operations, and environment access.

ConsoleFileEnvironment

Iterators

Iterator types for traversing collections with forward, bidirectional, and random access capabilities.

ListIterator<T>SetIterator<T>HashMapIterator<K, V>KeyValuePair<K, V>

Console

Console input/output operations for terminal interaction.

Console

File I/O

File operations for reading and writing files.

File

Text

Text utilities including StringUtils and Pattern for regex operations.

StringUtilsPattern

Math

Mathematical functions for trigonometry, exponentiation, and numeric operations.

Math

Time

Date/time handling with DateTime, TimeSpan, and Timer classes.

DateTimeTimeSpanTimer

JSON

JSON parsing and generation for data interchange.

JSONObjectJSONArray

HTTP

HTTP client and server functionality for web requests.

HTTPClientHTTPResponseHTTPServer

Testing

Unit testing framework with reflection-based test discovery.

AssertTestRunnerTestResultTestSummary

Constraints

The standard library defines these constraints for generic types:

ConstraintRequired Methods
Hashable<T>hash(): NativeType<"int64">^
Equatable<T>equals(other: T&): Bool^
Sendable<T>(marker) - Type can be moved across threads
Sharable<T>(marker) - Type can be shared across threads

Quick Reference

Creating Values

xxml
// Integers
Instantiate Integer^ As <n> = Integer::Constructor(42);

// Strings
Instantiate String^ As <s> = String::Constructor("Hello");

// Booleans
Instantiate Bool^ As <flag> = Bool::Constructor(true);

// Floating point
Instantiate Double^ As <d> = Double::Constructor(3.14159265359D);

// Lists
Instantiate Collections::List<Integer>^ As <numbers> =
    Collections::List@Integer::Constructor();

// Maps
Instantiate Collections::HashMap<String, Integer>^ As <ages> =
    Collections::HashMap@String, Integer::Constructor();

Common Operations

xxml
// Console output
Run Console::printLine(message);

// String operations
Instantiate String^ As <combined> = str1.append(str2);
Instantiate Integer^ As <len> = str.length();

// Integer arithmetic
Instantiate Integer^ As <sum> = a.add(b);
Instantiate Integer^ As <product> = a.multiply(b);
Instantiate String^ As <text> = n.toString();

// List operations
Run list.add(value);
Instantiate T^ As <item> = list.get(index);
Instantiate Integer^ As <size> = list.size();