pluto-lang-0.2.4 is not a library.

Pluto

Pluto is an interpreted programming language implemented in Rust, designed for learning, experimentation, and rapid prototyping. Pluto features a simple, expressive syntax, dynamic typing, and a growing set of built-in functions and methods. Its extensible architecture allows you to add your own built-ins in Rust.

Features

Feature	Description
Variables	`let` keyword for variable declaration
Arithmetic Expressions	Supports `+`, `-`, `*`, `/`, `%`
Floating Point Support	Both integers and floats supported
String Support	String literals and concatenation
Boolean Support	`true` and `false` literals, type detection
Function Calls	Built-in functions like `print`, `type`, `input`
Method Calls	Call methods on strings, numbers, arrays, etc.
Member Access	Access module members (e.g. `Math.pi`)
If Statements	Conditional execution with `if` and `else`
Arrays	Array literals, indexing, and array methods
Extensible	Add your own built-in functions in Rust
Simple Syntax	Easy to read and write

Example

Given the following Pluto code in test.po:

let x = 5.5;
print(x + 5);
print(x);
let a = "Result: ";
print(a);
let a = a + x;
print(a);
let abc = true;
let def = false;
print(abc, def, type(abc));

if !(5 < 2) {
    print("a");
} else {
    print("b");
}

print("abcde".char_at(1));

let first = input("first num: ");
let second = input("second num: ");
let sum = first.to_int() + second.to_float();
print(sum);
print(type(sum));
if sum > 10 {
    print("Grather than 10!");
} else {
    print("Less than 10!");
}

Sample Output:

10.5
5.5
Result: 
Result: 5.5
true false Bool
a
b
b
c
[first num prompt...]
[second num prompt...]
[sum result...]
[sum type...]
Grather than 10! or Less than 10!

Value Types

Pluto supports the following value types:

Type	Description	Example
Number	64-bit signed integer	`let x = 42;`
Float	64-bit floating point number	`let y = 3.14;`
String	UTF-8 string	`let s = "hi";`
Bool	Boolean (`true` or `false`)	`let b = true;`
Array	Ordered collection of values	`let arr = [1,2,3];`
Module	Built-in module (e.g. `Math`)	`Math.pi`
Function	Built-in function	`print(x);`

You can check the type of any value using the type built-in function:

let x = 5.5;
print(type(x)); // Output: Float
let b = true;
print(type(b)); // Output: Bool
let s = "hello";
print(type(s)); // Output: String

Getting Started

Prerequisites

Rust (edition 2021 or later)

Build

cargo build --release

Run

cargo run test.po

Or, after building:

./target/release/pluto test.po

Language Syntax

Syntax	Example	Description
Variable Declaration	`let x = 10;`	Declare variable `x`
Arithmetic	`let y = x * 2 + 3;`	Expressions with `+ - * / %`
String Literal	`let s = "hello";`	String assignment
String Concatenation	`let t = s + " world";`	Concatenate strings
Boolean Literal	`let b = true;`	Boolean assignment
Function Call	`print(y);`	Call built-in function
Float Support	`let z = 3.14;`	Floating point numbers
If Statement	`if x > 0 { print(x); }`	Conditional execution
Member Access	`Math.pi`	Access module member
Method Call	`"abc".len()`	Call method on value
Input	`let s = input("prompt: ");`	Read user input
Array Literal	`let arr = [1, 2, 3];`	Array assignment
Array Indexing	`arr[0]`	Access array element
Array Assignment	`arr[0] = 42;`	Modify array element

Built-in Functions

Function	Description	Example
print	Prints arguments to stdout	`print(x);`
type	Returns the type of the argument	`print(type(x));`
input	Reads a line from stdin	`let s = input();`
format	Format string with arguments	`format("Hello, {}", name)`
exit	Exit the interpreter	`exit(0);`

Built-in Modules

Math

Member	Description	Example
Math.pi	Returns the value of π	`print(Math.pi);`
Math.pow(a, b)	Raises `a` to the power of `b`	`print(Math.pow(2, 3));`

Built-in Methods by Type

String Methods

Method	Description	Example
len()	Returns string length	`"abc".len()`
to_upper()	Uppercase string	`"abc".to_upper()"`
to_lower()	Lowercase string	`"ABC".to_lower()"`
char_at(i)	Char at index `i` (as string)	`"abc".char_at(1)`
to_int()	Convert string to integer	`"42".to_int()"`
to_float()	Convert string to float	`"3.14".to_float()"`

Number Methods

Method	Description	Example
to_string()	Convert number to string	`x.to_string()`

Float Methods

Method	Description	Example
to_string()	Convert float to string	`x.to_string()`

Array Methods

Method	Description	Example
len()	Returns array length	`arr.len()`
push(val)	Returns new array with `val` added	`arr.push(5)`
pop()	Returns new array with last removed	`arr.pop()`
remove(i)	Returns new array with element at index removed	`arr.remove(2)`
sum()	Returns sum of numeric elements	`arr.sum()`

Module Methods

Modules can contain members (constants, functions) accessible via dot notation, e.g. Math.pi, Math.pow(a, b).

Contributing

Pull requests and suggestions are welcome! Please open an issue or submit a PR if you have ideas for new features, bug fixes, or improvements.

License

This project is licensed under the MIT License. See LICENSE for details.

pluto-lang 0.2.4