pluto-lang-0.2.7 is not a library.

Pluto

Features

Feature	Description
Variables	`let` keyword for variable declaration
Block Scoping	Variables are scoped to their block
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, assignment, 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`
Block Scope	`{ let y = 5; print(y); }`	Variables are scoped to blocks
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).

Notes on Scoping

Pluto uses block scoping for variables. This means that variables declared with let inside a block ({ ... }) are only accessible within that block and its inner blocks. Variables declared in an outer scope are accessible in inner scopes, but not vice versa.

Example:

let x = 1;
if true {
    let y = 2;
    print(x); // 1
    print(y); // 2
}
print(x); // 1
print(y); // Error: y is not defined

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.7