Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/frewtypebbles/fulcrum
A fast and straight forward scripting language with a tiny binary.
https://github.com/frewtypebbles/fulcrum
Last synced: 3 days ago
JSON representation
A fast and straight forward scripting language with a tiny binary.
- Host: GitHub
- URL: https://github.com/frewtypebbles/fulcrum
- Owner: FrewtyPebbles
- License: mit
- Created: 2022-12-09T08:37:37.000Z (about 2 years ago)
- Default Branch: main
- Last Pushed: 2024-06-12T22:08:11.000Z (7 months ago)
- Last Synced: 2024-06-13T03:53:25.387Z (7 months ago)
- Language: Rust
- Size: 85.9 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Fulcrum 0.8.9
A straight forward scripting language with a tiny binary and a functional programming paradigm.
***Note:***
> This was the first complete working programming language I made. I learned alot from the trials and tribulations involved in its development.
## Documentation
## Features:
- Higher order functions.
- An extremely minimal and basic syntax.
- An compact interpreter that can be packaged with your project.
## Language Rules:
- Assignments, function calls, and return statements must be ended with a `;`
- Operators are not yet a part of the language but operations can be done via functions.
- Functions defined inside of other functions only are callable inside of the parent function and inherit all of the parent function's variables and function definitions.
- Higher order functions must include a function name, this requirement will be taken out once a new syntax for function literals is added.
- When exiting any scope, all variables defined within that scope are deleted.
- Nothing is passed by reference, all variables are modified via the `=` asignment operator.
## Language Keywords and syntax:
- `fun` : Prefixes a function definition.
- `return` : Returns a value from a user defined function.
- `break` : Breaks out of a scope.
- `if` : Prefixes the condition for an if block.
- `elif` : Prefixes the condition for an elif block.
- `else` : Prefixes an else block.
- `loop` : Prefixes a loop block. Loop blocks will loop indefinitely until they hit a break or return.
- `while` : Prefixes a while block. while blocks will loop as long as their statement is true.
- `[]` : Wraps a list literal or is used to hold the offset for an index/offset operator.
- `=` : Used to declare or assign to existing variables.
- `'` : Wraps a string literal.
- `in` : Operator that checks if the left side is in the right side when not used inside a for loop.
- `;` : Denotes the end of a line.
- `()` : Suffixes a function name when calling or declaring that function. Wraps function arguments when calling a function and wraps function argument names when declaring a function.
- `true`|`yes`|`t` : Aliases for the boolean literal `true`.
- `false`|`no`|`f` : Aliases for the boolean literal `false`.
## Non-traditional Functionalities
- Loops
```
loop {
print('Loop!\n');
}
```
Loops will loop until the path of execution hits a `break` or a `return`.
- For loops
```
// String Example
for i in 'abc' {
print(add(i, '\n'));
}
// output:
// a
// b
// c
// Integer Example
for i in 3 {
print(add(i, '\n'));
}
// output:
// 0
// 1
// 2
// List Example
for i in ['1', 2.0, 3] {
print(add(i, '\n'));
}
// output:
// 1
// 2.0
// 3
// Variable Example
variable = [0, 1, 2];
for i in variable {
print(add(i, '\n'));
}
// output:
// 0
// 1
// 2
```
## Standard Library Functions:
Functions in fulcrum return the result of their operation.
- `print(val)` : Prints a value to the standard output.
- `input()` : Gets user input.
- `read(filepath)` : Returns the contents of the file provided.
- `write(filepath, new_content, writemode)` : Writes the `new_content` to the file provided based on the writemode which can be `'a'` for append or `'t'` for truncate.
- `add(val1, val2)` : Adds 2 values. also concatenates strings.
- `sub(val1, val2)` : Subtracts 2 values. also removes substrings from strings.
- `mul(val1, val2)` : Multiplies 2 values.
- `div(val1, val2)` : divides 2 values.
- `E(val1, val2)` : Tests if two values are equal and returns boolean.
- `NE(val1, val2)` : Tests if two values are not equal and returns boolean.
- `G(val1, val2)` : Tests if `val1` is greater than `val2`.
- `L(val1, val2)` : Tests if `val1` is less than `val2`.
- `GE(val1, val2)` : Tests if `val1` is greater than or equal to `val2`.
- `LE(val1, val2)` : Tests if `val1` is less than or equal to `val2`.
- `and(condition1, condition2)` : Tests if both conditions are true and returns boolean.
- `or(condition1, condition2)` : Tests if one of the conditions are true and returns boolean.
- `INT(val)` : Casts the type to an Int.
- `FLOAT(val)` : Casts the type to a Float.
- `BOOL(val)` : Casts the type to a Boolean.
- `STRING(val)` : Casts the type to a String.
- `cat(val1, val2, val3, ...)` : Concatenates multiple values into a string.
- `split(string, substring)` : Splits a string by a substring.
- `trim(string)` : Removes the leading and trailing whitespace from a string.
- `replace(string, substring1, substring2)` : Replaces the substring1 in the string with substring2.
- `pop(list)` : pops a value from a list.
- `push(list, value)` : pops a value from a list.
- `len(string`|`list)` : Returns the len of the first argument.
- `range(num1, num2)` : Returns a list of integers from num1 to num2.
- `rev(list`|`string)` : Reverses a list or string.
- `CLI(integer)` : Returns command line arguments.
- `import(module_path)` : imports all definitions/functions from the `.ful` file at the path specified into the current scope.
## Example Program:
Tic Tac Toe:
```
# tictactoe.ful
fun tictactoe() {
# Board will act as a global that will hold the state of the tic tac toe board.
board = [
# 1 2 3
[' ',' ',' '], #a
[' ',' ',' '], #b
[' ',' ',' '] #c
];
fun check_winner() {
#horizontal
if E(board[0], ['O', 'O', 'O']) {
return 'O';
}
elif E(board[0], ['X', 'X', 'X']) {
return 'X';
}
elif E(board[1], ['O', 'O', 'O']) {
return 'O';
}
elif E(board[1], ['X', 'X', 'X']) {
return 'X';
}
elif E(board[2], ['O', 'O', 'O']) {
return 'O';
}
elif E(board[2], ['X', 'X', 'X']) {
return 'X';
}
#vertical
elif and(and(E(board[0][0], 'O'), E(board[1][0], 'O')), E(board[2][0], 'O')) {
return 'O';
}
elif and(and(E(board[0][0], 'X'), E(board[1][0], 'X')), E(board[2][0], 'X')) {
return 'X';
}
elif and(and(E(board[0][1], 'O'), E(board[1][1], 'O')), E(board[2][1], 'O')) {
return 'O';
}
elif and(and(E(board[0][1], 'X'), E(board[1][1], 'X')), E(board[2][1], 'X')) {
return 'X';
}
elif and(and(E(board[0][2], 'O'), E(board[1][2], 'O')), E(board[2][2], 'O')) {
return 'O';
}
elif and(and(E(board[0][2], 'X'), E(board[1][2], 'X')), E(board[2][2], 'X')) {
return 'X';
}
#diagonal
elif and(and(E(board[0][0], 'O'), E(board[1][1], 'O')), E(board[2][2], 'O')) {
return 'O';
}
elif and(and(E(board[0][0], 'X'), E(board[1][1], 'X')), E(board[2][2], 'X')) {
return 'X';
}
elif and(and(E(board[2][0], 'O'), E(board[1][1], 'O')), E(board[0][2], 'O')) {
return 'O';
}
elif and(and(E(board[2][0], 'X'), E(board[1][1], 'X')), E(board[0][2], 'X')) {
return 'X';
}
return '';
}
fun update_board(current_player) {
# This function starts a turn for a player.
fun print_board() {
# this function renders the current board.
# board is inherited from top most function and acts as a global.
print(add(add(add(add(board[0][0], '|'),board[0][1]),'|'),board[0][2]));
print('\n-----\n');
print(add(add(add(add(board[1][0], '|'),board[1][1]),'|'),board[1][2]));
print('\n-----\n');
print(add(add(add(add(board[2][0], '|'),board[2][1]),'|'),board[2][2]));
print('\n');
}
# render the board at the start of the turn
print_board();
# check for a winner
is_winner = check_winner();
if is_winner {
write('tictactoe_wins.txt', add(is_winner, ', '), 'a');
print(add(add('The winner is: ', is_winner), '\n'));
print('Previous wins:\n');
print(read('tictactoe_wins.txt'));
return is_winner;
}
# Get horizontal input.
print('horizontal:');
x = sub(INT(input()),1);
# Get vertical input.
print('vertical:');
y = sub(INT(input()), 1);
# Set the current player at that position.
board[x][y] = current_player;
# Check who the current player is to recursively call update board as the other player.
if E(current_player, 'X') {
return update_board('O');
}
else {
return update_board('X');
}
}
return update_board('X');
}
# Run the game
tictactoe();
```