Document not found (404)
-This URL is invalid, sorry. Please use the navigation bar or search to continue.
- -This URL is invalid, sorry. Please use the navigation bar or search to continue.
- -PooLang uses if, elif, and else to control the flow of execution based on boolean conditions.
The simplest form is a single if block:
if x > 10 {
- pout("x is large");
-}
-You can provide an alternative path using else:
if x > 10 {
- pout("x is large");
-} else {
- pout("x is small");
-}
-For multiple conditions, use elif:
if x > 100 {
- pout("Huge");
-} elif x > 10 {
- pout("Large");
-} else {
- pout("Small");
-}
-Variables declared inside a conditional block are scoped to that block and are not accessible outside.
-if true {
- poo temp << 1;
-}
-# temp is no longer accessible here
-PooLang provides two primary ways to repeat logic: while loops and for loops.
The while loop continues to execute as long as its condition remains true.
poo mut count << 0;
-
-while count < 5 {
- pout("Count: ", count);
- count << count + 1;
-}
-PooLang supports for loops that iterate over a range or a collection.
You can iterate over a range of numbers using the .. syntax:
for i in 0..5 {
- pout(i); # Prints 0, 1, 2, 3, 4
-}
-You can also iterate over elements in a vector:
-poo items << [10, 20, 30];
-
-for item in items {
- pout(item);
-}
-The loop variable (like i or item) is only accessible within the body of the loop.
Functions in PooLang allow you to encapsulate logic into reusable blocks. They are defined using the poof keyword.
A basic function looks like this:
-poof sayHello() {
- pout("Hello!");
-}
-PooLang uses the >> operator to specify the return type of a function.
poof getNumber() >> int {
- return 42;
-}
-Common return types include int, float, string, bool, and void (if no value is returned).
You can pass data into functions via parameters:
-poof add(a, b) >> int {
- return a + b;
-}
-
-poo sum << add(5, 5); # sum is 10
-Functions create their own scope. Variables declared inside a function are not accessible outside. Functions can, however, access variables in the global scope if they are defined before the function is called.
- -The fastest way to install PooLang is via our universal installers:
-Linux / macOS
-curl --proto '=https' --tlsv1.2 -LsSf https://github.com/shayyz-code/poolang/releases/latest/download/poo-installer.sh | sh
-Windows
-powershell -c "irm https://github.com/shayyz-code/poolang/releases/latest/download/poo-installer.ps1 | iex"
-If you have Rust and Cargo installed, you can build from source:
-git clone https://github.com/shayyz-code/poolang.git
-cd poolang
-cargo build --release
-The binary will be available at ./target/release/poo.
Create a file named hello.poo:
use std::pout;
-
-pout("Hello, Guinea Pig!");
-Run it using the PooLang CLI:
-poo hello.poo
-Check out the Variables & Types section to learn more about PooLang syntax.
- -PooLang is a tiny, interpreted language written in Rust. It was designed to be a lightweight, pedagogical language featuring a full pipeline: lexical analysis, parsing into an Abstract Syntax Tree (AST), and tree-walking interpretation.
-The name Poo is inspired by the Burmese word for Guinea Pig, reflecting the language's friendly and compact nature.
-mut for mutability.poo keyword.<< operator.if/elif/else, while, and for loops.poof.The Interpreter is the final stage of the PooLang pipeline. It takes the Abstract Syntax Tree (AST) produced by the Parser and executes the logic it represents.
-PooLang uses a Tree-Walking Interpreter. It traverses the AST recursively, "visiting" each node and performing the corresponding action in the real world (e.g., adding two numbers, updating a variable in memory).
-The interpreter maintains an Environment (or Scope) which maps variable names to their current values. When you declare a variable with poo, it is added to the current environment.
The interpreter is located in src/interpreter.rs. Key features include:
The Lexer (also known as a Tokenizer) is the first stage of the PooLang pipeline. Its job is to take raw source code (a string of characters) and turn it into a sequence of meaningful Tokens.
-The Lexer scans the input character by character and groups them into tokens like:
-poo, mut, if, while<<, +, -, *, /10), Strings ("hi"), Booleans (true)The implementation is located in src/lexer.rs. It uses a simple state-machine approach to recognize different patterns of text.
Input:
-poo x << 5;
-Tokens produced:
-Keyword(Poo)Identifier("x")Operator(Assign)Literal(Integer(5))SemicolonThe Parser takes the stream of tokens produced by the Lexer and organizes them into a hierarchical structure called an Abstract Syntax Tree (AST).
-PooLang uses a Recursive Descent parser. It looks at the current token and decides which rule of the language grammar to apply next.
-For example, if the parser see the poo token, it knows it is starting a variable declaration and expects an identifier followed by an assignment operator.
The AST is a tree-like representation of your code. For example, the expression 1 + 2 * 3 would be parsed into a tree where + is the root, 1 is the left child, and another tree representing 2 * 3 is the right child.
The AST node definitions can be found in src/ast.rs.
The parser logic resides in src/parser.rs. It handles:
PooLang is a tiny, interpreted language written in Rust. It was designed to be a lightweight, pedagogical language featuring a full pipeline: lexical analysis, parsing into an Abstract Syntax Tree (AST), and tree-walking interpretation.
-The name Poo is inspired by the Burmese word for Guinea Pig, reflecting the language's friendly and compact nature.
-mut for mutability.poo keyword.<< operator.if/elif/else, while, and for loops.poof.PooLang is a tiny, interpreted language written in Rust. It was designed to be a lightweight, pedagogical language featuring a full pipeline: lexical analysis, parsing into an Abstract Syntax Tree (AST), and tree-walking interpretation.
-The name Poo is inspired by the Burmese word for Guinea Pig, reflecting the language's friendly and compact nature.
-mut for mutability.poo keyword.<< operator.if/elif/else, while, and for loops.poof.The fastest way to install PooLang is via our universal installers:
-Linux / macOS
-curl --proto '=https' --tlsv1.2 -LsSf https://github.com/shayyz-code/poolang/releases/latest/download/poo-installer.sh | sh
-Windows
-powershell -c "irm https://github.com/shayyz-code/poolang/releases/latest/download/poo-installer.ps1 | iex"
-If you have Rust and Cargo installed, you can build from source:
-git clone https://github.com/shayyz-code/poolang.git
-cd poolang
-cargo build --release
-The binary will be available at ./target/release/poo.
Create a file named hello.poo:
use std::pout;
-
-pout("Hello, Guinea Pig!");
-Run it using the PooLang CLI:
-poo hello.poo
-Check out the Variables & Types section to learn more about PooLang syntax.
-PooLang uses the poo keyword to declare variables. By default, variables are immutable, meaning their value cannot be changed after assignment.
poo age << 5;
-If you need to reassign a value, you must use the mut keyword:
poo mut score << 0;
-score << 10; # This is allowed
-Note that PooLang uses the << operator for assignment instead of the traditional =. This helps distinguish PooLang code at a glance.
42, -10).3.14, 2.0)."Hello").true or false).[1, 2, 3]).PooLang automatically infers the type of a variable based on the value assigned to it. You do not need to explicitly declare types for variables.
-PooLang supports standard arithmetic operations with proper mathematical precedence (PEMDAS).
-| Operator | Description | Example |
|---|---|---|
+ | Addition | 5 + 2 |
- | Subtraction | 10 - 4 |
* | Multiplication | 3 * 3 |
/ | Division | 20 / 5 |
poo result << 10 + 5 * 2; # result is 20 (5*2=10, 10+10=20)
-These operators return a Boolean (true or false).
| Operator | Description |
|---|---|
== | Equal to |
!= | Not equal to |
> | Greater than |
< | Less than |
>= | Greater than or equal to |
<= | Less than or equal to |
| Operator | Description |
|---|---|
&& | Logical AND |
| ` | |
! | Logical NOT |
PooLang uses if, elif, and else to control the flow of execution based on boolean conditions.
The simplest form is a single if block:
if x > 10 {
- pout("x is large");
-}
-You can provide an alternative path using else:
if x > 10 {
- pout("x is large");
-} else {
- pout("x is small");
-}
-For multiple conditions, use elif:
if x > 100 {
- pout("Huge");
-} elif x > 10 {
- pout("Large");
-} else {
- pout("Small");
-}
-Variables declared inside a conditional block are scoped to that block and are not accessible outside.
-if true {
- poo temp << 1;
-}
-# temp is no longer accessible here
-PooLang provides two primary ways to repeat logic: while loops and for loops.
The while loop continues to execute as long as its condition remains true.
poo mut count << 0;
-
-while count < 5 {
- pout("Count: ", count);
- count << count + 1;
-}
-PooLang supports for loops that iterate over a range or a collection.
You can iterate over a range of numbers using the .. syntax:
for i in 0..5 {
- pout(i); # Prints 0, 1, 2, 3, 4
-}
-You can also iterate over elements in a vector:
-poo items << [10, 20, 30];
-
-for item in items {
- pout(item);
-}
-The loop variable (like i or item) is only accessible within the body of the loop.
Functions in PooLang allow you to encapsulate logic into reusable blocks. They are defined using the poof keyword.
A basic function looks like this:
-poof sayHello() {
- pout("Hello!");
-}
-PooLang uses the >> operator to specify the return type of a function.
poof getNumber() >> int {
- return 42;
-}
-Common return types include int, float, string, bool, and void (if no value is returned).
You can pass data into functions via parameters:
-poof add(a, b) >> int {
- return a + b;
-}
-
-poo sum << add(5, 5); # sum is 10
-Functions create their own scope. Variables declared inside a function are not accessible outside. Functions can, however, access variables in the global scope if they are defined before the function is called.
-PooLang includes a small built-in standard library to handle common tasks like output.
-The pout function is used to print values to the standard output.
use std::pout;
-
-pout("Hello, World");
-pout("The result is: ", 42);
-Note the use std::pout; line. While pout is often available by default in many contexts, using the explicit use statement ensures it is imported into your current namespace.
The standard library is currently minimal. Planned additions include:
-std::math: Advanced math functions (sin, cos, etc.)std::fs: File system operationsstd::str: String manipulation utilitiesThe Lexer (also known as a Tokenizer) is the first stage of the PooLang pipeline. Its job is to take raw source code (a string of characters) and turn it into a sequence of meaningful Tokens.
-The Lexer scans the input character by character and groups them into tokens like:
-poo, mut, if, while<<, +, -, *, /10), Strings ("hi"), Booleans (true)The implementation is located in src/lexer.rs. It uses a simple state-machine approach to recognize different patterns of text.
Input:
-poo x << 5;
-Tokens produced:
-Keyword(Poo)Identifier("x")Operator(Assign)Literal(Integer(5))SemicolonThe Parser takes the stream of tokens produced by the Lexer and organizes them into a hierarchical structure called an Abstract Syntax Tree (AST).
-PooLang uses a Recursive Descent parser. It looks at the current token and decides which rule of the language grammar to apply next.
-For example, if the parser see the poo token, it knows it is starting a variable declaration and expects an identifier followed by an assignment operator.
The AST is a tree-like representation of your code. For example, the expression 1 + 2 * 3 would be parsed into a tree where + is the root, 1 is the left child, and another tree representing 2 * 3 is the right child.
The AST node definitions can be found in src/ast.rs.
The parser logic resides in src/parser.rs. It handles:
The Interpreter is the final stage of the PooLang pipeline. It takes the Abstract Syntax Tree (AST) produced by the Parser and executes the logic it represents.
-PooLang uses a Tree-Walking Interpreter. It traverses the AST recursively, "visiting" each node and performing the corresponding action in the real world (e.g., adding two numbers, updating a variable in memory).
-The interpreter maintains an Environment (or Scope) which maps variable names to their current values. When you declare a variable with poo, it is added to the current environment.
The interpreter is located in src/interpreter.rs. Key features include:
PooLang includes a small built-in standard library to handle common tasks like output.
-The pout function is used to print values to the standard output.
use std::pout;
-
-pout("Hello, World");
-pout("The result is: ", 42);
-Note the use std::pout; line. While pout is often available by default in many contexts, using the explicit use statement ensures it is imported into your current namespace.
The standard library is currently minimal. Planned additions include:
-std::math: Advanced math functions (sin, cos, etc.)std::fs: File system operationsstd::str: String manipulation utilitiesPooLang supports standard arithmetic operations with proper mathematical precedence (PEMDAS).
-| Operator | Description | Example |
|---|---|---|
+ | Addition | 5 + 2 |
- | Subtraction | 10 - 4 |
* | Multiplication | 3 * 3 |
/ | Division | 20 / 5 |
poo result << 10 + 5 * 2; # result is 20 (5*2=10, 10+10=20)
-These operators return a Boolean (true or false).
| Operator | Description |
|---|---|
== | Equal to |
!= | Not equal to |
> | Greater than |
< | Less than |
>= | Greater than or equal to |
<= | Less than or equal to |
| Operator | Description |
|---|---|
&& | Logical AND |
| ` | |
! | Logical NOT |
PooLang uses the poo keyword to declare variables. By default, variables are immutable, meaning their value cannot be changed after assignment.
poo age << 5;
-If you need to reassign a value, you must use the mut keyword:
poo mut score << 0;
-score << 10; # This is allowed
-Note that PooLang uses the << operator for assignment instead of the traditional =. This helps distinguish PooLang code at a glance.
42, -10).3.14, 2.0)."Hello").true or false).[1, 2, 3]).PooLang automatically infers the type of a variable based on the value assigned to it. You do not need to explicitly declare types for variables.
- -