Language Keywords#

ai fn summarize(text: str) -> str {
    prompt "Summarize the following text in 3 sentences: {text}";
}

let summary = summarize("AIScript is a programming language designed for AI interactions...");
print(summary);

// Basic usage
let response = prompt "What is the capital of France?";

// With model specification
let detailed_answer = prompt {
    input: "Explain quantum computing",
    model: "gpt-4",
    max_tokens: 500,
    temperature: 0.7,
    system_prompt: "You are a quantum physics expert"
};

agent SearchAssistant {
    instructions: "You are a search assistant. Help users find information.",
    model: "claude-3-5-sonnet",
    
    fn search(query: str) -> str {
        // Implementation of search functionality
        prompt f"Search for: {query}";
    }
    
    fn summarize(text: str) -> str {
        prompt f"Summarize: {text}";
    }
}

// Using the agent
let result = SearchAssistant.run(input: "Find information about climate change");

let x = 10;
if x > 5 {
    print("x is greater than 5");
} else if x < 5 {
    print("x is less than 5");
} else {
    print("x equals 5");
}

for i in 1..5 {
    print(i);  // Prints 1, 2, 3, 4
}

let names = ["Alice", "Bob", "Charlie"];
for name in names {
    print(name);
}

let i = 0;
while i < 5 {
    print(i);
    i = i + 1;
}

for i in 1..10 {
    if i == 5 {
        break;
    }
    print(i);  // Prints 1, 2, 3, 4
}

for i in 1..10 {
    if i % 2 == 0 {
        continue;
    }
    print(i);  // Prints 1, 3, 5, 7, 9
}

let value = 2;
match value {
    1 => print("One"),
    2 => print("Two"),
    3 => print("Three"),
    _ => print("Other number")
}

// Match with enum variants
enum Status {
    Pending,
    Started,
    Finished,
}

let result = Result::Pending;
match result {
    Result::Pending => print("status: pending"),
    Result::Started => print("status: started"),
    Result::Finished => print("status: finished"),
}

fn add(a: int, b: int) -> int {
    return a + b;
}

fn is_even(num: int) -> bool {
    if num % 2 == 0 {
        return true;
    }
    return false;
}

enum ArithError! {
    DivideByZero
}

fn divide(a: int, b: int) -> float, ArithError! {
    if b == 0 {
        raise ArithError!::DivideByZero;
    }
    return a / b;
}

// Using the function with error handling
let result = divide(10, 0) |err| {
    print("Division by zero");
    return 0;
};

let name = "AIScript";
name = "AI Script Language";  // Valid - can be reassigned

const PI = 3.14159;
const MAX_USERS = 100;
// PI = 3.14;  // Invalid - constants cannot be reassigned

pub fn add(a: int, b: int) -> int {
    return a + b;
}

pub const VERSION = "1.0.0";

enum Color {
    Red,
    Green,
    Blue
}

// Enum with values
enum HttpStatus {
    OK = 200,
    NotFound = 404,
    ServerError = 500
}

// Enum for errors
enum NetworkError! {
    ConnectionFailed,
    Timeout,
    InvalidResponse,
}

class Person {
    name: str,
    age: int,
    
    fn new(name: str, age: int) {
        self.name = name;
        self.age = age;
    }
}

let person = Person("John", 30);

if x > 0 and x < 10 {
    print("x is between 0 and 10");
}

if x < 0 or x > 10 {
    print("x is not between 0 and 10");
}

if not (x == 5) {
    print("x is not 5");
}

// Membership test
let numbers = [1, 2, 3, 4, 5];
print(3 in numbers);  // true

// Used in for loops
for element in numbers {
    print(element);
}

class Counter {
    count: int = 0,
    
    fn increment(self) {
        self.count = self.count + 1;
    }
    
    fn get_count(self) -> int {
        return self.count;
    }
}

class Animal {
    fn make_sound() {
        print("Generic animal sound");
    }
}

class Dog(Animal) {
    fn make_sound() {
        super.make_sound();
        print("Woof!");
    }
}

let optional = nil;
if optional == nil {
    print("No value");
}

// Import a module
use std.math;
print(math.sin(0.5));

// Import multiple modules
use std.io;
use std.time;

match value {
    1 => print("One"),
    2 => print("Two"),
    _ => print("Other number")
}