Pluto Programming Language

🚀 Quick Start

# Install via Cargo
cargo install pluto-lang

# Run the REPL
pluto-lang

# Run a script
pluto-lang script.po

Your first Pluto program:

/* Hello World in Pluto */
print("Hello, World!");

/* Quick example of Pluto's features */
let greet = (name="World") -> {
    ? name == "World" ->
        print("Hello, stranger!")
        : print("Welcome back, " + name + "!");
};

greet();        /* Hello, stranger! */
greet("Alice"); /* Welcome back, Alice! */

📖 Table of Contents

• Features
• Installation
• Language Guide
• Built-in Types
• Standard Library
• Examples
• Contributing
• License

✨ Features

let number = 42;
let text = "Hello";
let flag = true;

let greet = (name) -> {
    print("Hello, " + name);
}

let arr = [1, 2, 3];
let new_arr = arr.push(4);

Core Features

• 🔄 Dynamic typing with type inference
• 🎯 First-class functions with anonymous function support
• 🎨 Named arguments and default parameters
• 🛡️ Immutable by default
• 📚 Rich standard library
• 🎲 Modern random number generation (Xoshiro256**)
• 💻 Interactive REPL environment
• 🔄 Iterative programming model

Key Highlights

/* Variables and functions */
let x = 42;
let greet = (name="World") -> {
    print("Hello, " + name + "!");
};

/* Array operations (immutable) */
let numbers = [1, 2, 3];
let doubled = numbers.map((x) -> x * 2);  /* [2, 4, 6] */

/* Random number generation */
let dice = Random.int(1, 6);
let probability = Random.float();

📥 Installation

Prerequisites

• Rust (edition 2021 or later)
• Cargo package manager

Option 1: Install via Cargo

cargo install pluto-lang

Option 2: Build from Source

git clone https://github.com/mi66mc/pluto
cd pluto
cargo install --path .

📚 Language Guide

Comments

Pluto uses block comments:

/* Single line comment */

/* Multi-line
   block comment */

let x = 42; /* Inline comment */

Variables and Types

/* Basic types */
let number = 42;          /* Integer */
let float = 3.14;        /* Float */
let text = "Hello";      /* String */
let flag = true;         /* Boolean */
let empty = null;        /* Null */

/* Type conversion */
let str_num = "123".to_int();
let str_float = "3.14".to_float();
let num_str = 42.to_string();

Functions

/* Arrow function with default parameters */
let greet = (name="World", greeting="Hello") -> {
    print(greeting + ", " + name + "!");
};

/* Usage */
greet();                          /* "Hello, World!" */
greet("Alice");                   /* "Hello, Alice!" */
greet(greeting="Hi", name="Bob"); /* "Hi, Bob!" */

/* Immediate function invocation */
((x) -> x * x)(5);               /* 25 */
((name) -> print("Hello, " + name))("World");  /* "Hello, World!" */

/* Function return values */
fn square(x) x*x;     /* Returns x*x (expression) */
fn cube(x) {x*x*x;}   /* Returns null (block with no return) */
fn quad(x) {          /* Returns x^4 (explicit return) */
    return x*x*x*x;
}

Data Structures

Arrays (Immutable)

/* Creating arrays */
let numbers = [1, 2, 3, 4, 5];

/* Array operations (all return new arrays) */
let longer = numbers.push(6);      /* [1, 2, 3, 4, 5, 6] */
let shorter = numbers.pop();       /* [1, 2, 3, 4] */
let filtered = numbers.remove(2);  /* [1, 2, 4, 5] */
let doubled = numbers.map((x) -> x * 2);  /* [2, 4, 6, 8, 10] */

/* Array properties */
print(numbers.len());  /* 5 */
print(numbers.sum());  /* 15 */

HashMaps

/* Creating hashmaps */
let user = {
    "name": "John",
    "age": 30
};

/* HashMap operations */
let updated = user.set("city", "New York");
print(user.get("name"));  /* "John" */
print(user.len());        /* 2 */

Control Flow

Conditional Statements

if x > 0 {
    print("Positive");
} else if x < 0 {
    print("Negative");
} else {
    print("Zero");
}

Ternary Operator

/* Ternary syntax: ? condition -> then_expr : else_expr */
let status = ? age >= 18 -> "adult" : "minor";

/* Can also be used with function calls */
? score > 100 -> print("High score!") : print("Keep trying!");

/* Nested ternary expressions */
let message = ? is_logged_in -> 
    ? is_admin -> "Welcome, admin!" : "Welcome, user!" 
    : "Please log in";

Elvis Operator

let inp = input("What's up? ");
let r = inp ?: "Nothing"; /* If inp is null, return "Nothing", otherwise return inp */
print(r); /* If the user doesn't input anything, print "Nothing" */

Match Expressions

Match expressions provide a powerful pattern matching mechanism in Pluto. They allow you to compare a value against a series of patterns and execute code based on which pattern matches.

Basic Syntax

match value {
    pattern1 -> expression1,
    pattern2 -> expression2,
    _ -> default_expression
}

Features

1. Literal Patterns

let num = 2;
match num {
    1 -> "one",
    2 -> "two",
    _ -> "other"
}

2. Block Expressions with Return

match greeting {
    "hi" -> {
        let msg = "Hi there!";
        return msg;
    },
    _ -> "default greeting"
}

3. Multiple Types

match value {
    42 -> "number 42",
    "42" -> "string 42",
    true -> "boolean true",
    null -> "null value",
    _ -> "something else"
}

4. Expression Matching

let x = 10;
let y = 5;
match x + y {
    15 -> "equals 15",
    _ -> "not 15"
}

Notes

• The _ pattern acts as a catch-all default case
• Patterns are checked in order from top to bottom
• Different types can be mixed in the same match expression
• Block expressions can use return statements
• Commas are required between arms, but optional before the closing brace
• Type mismatches (like comparing string with number) evaluate to false

Loops

/* For loop */
for (let i = 0; i < 5; i++) {
    print(i);
}

/* While loop */
let i = 0;
while (i < 5) {
    print(i);
    i++;
}

Range Operations

/* Exclusive range (0 to 4) */
let range1 = 0..5;     /* [0, 1, 2, 3, 4] */

/* Inclusive range (0 to 5) */
let range2 = 0..=5;    /* [0, 1, 2, 3, 4, 5] */

🛠️ Built-in Modules

Random Module

/* Random number generation */
let num = Random.int(1, 100);    /* Integer in range [1, 100] */
let prob = Random.float();       /* Float in range [0, 1) */
let coin = Random.bool(0.5);     /* Boolean with 50% probability */
let shuffled = Random.shuffle(arr);  /* Shuffle array */

Math Module

/* Mathematical operations */
print(Math.pi);              /* π constant */
print(Math.pow(2, 8));      /* Power function (256) */

Time Module

/* Time operations */
print(Time.now());          /* Unix timestamp (seconds) */
print(Time.now_ms());       /* Unix timestamp (milliseconds) */
Time.sleep(1000);          /* Sleep for 1 second */

📝 Examples

Monte Carlo Pi Estimation

/* Estimate Pi using Monte Carlo method */
let points = 1000000;
let inside = 0;

for (let i = 0; i < points; i++) {
    let x = Random.float();
    let y = Random.float();
    if (x * x + y * y <= 1.0) {
        inside++;
    }
}

let pi = 4.0 * inside / points;
print("Estimated Pi:", pi);

Card Deck Shuffling

/* Create a deck of cards */
let suits = ["Hearts", "Diamonds", "Clubs", "Spades"];
let ranks = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"];
let deck = [];

/* Build the deck */
for (let s = 0; s < suits.len(); s++) {
    for (let r = 0; r < ranks.len(); r++) {
        deck = deck.push(ranks[r] + " of " + suits[s]);
    }
}

/* Shuffle and display */
let shuffled_deck = Random.shuffle(deck);
print("First 5 cards:");
for (let i = 0; i < 5; i++) {
    print(shuffled_deck[i]);
}

🤝 Contributing

We welcome contributions! Here's how you can help:

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

For major changes, please open an issue first to discuss what you would like to change.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

📚 Language Reference

Built-in Types and Methods

String Methods

Number Methods

Float Methods

Array Methods

HashMap Methods

Built-in Modules

Math Module

Time Module

Random Module

Global Functions

Operators

Control Flow

/* Variable declaration */
let name = value;

/* If statement */
if (condition) {
    /* code */
} else if (another_condition) {
    /* code */
} else {
    /* code */
}

/* While loop */
while (condition) {
    /* code */
}

/* For loop */
for (let i = 0; i < 10; i++) {
    /* code */
}

/* Break and continue */
break;
continue;

Note: All data structures in Pluto are immutable by default. Operations that appear to modify data structures actually return new copies with the modifications applied.

REPL Environment

Pluto comes with an interactive REPL (Read-Eval-Print Loop) environment:

$ pluto-lang

=== Pluto Programming Language REPL ===
Type :help for available commands
Type :exit to quit

>> let x = 42;
42
>> x + 8;
50
>> fn square(x) x*x;
null
>> square(5);
25
>> ((x) -> x*x)(6);
36
>> (x) -> x*x;
<function: params=[x], body=BinaryExpression(Identifier("x"), "*", Identifier("x")), env_size=1 >
>> :help

Available Commands:
  :help, :h     - Show this help message
  :clear, :c    - Clear the screen
  :exit, :q     - Exit the REPL
  :reset        - Reset the environment