SigmaF

Learn SigmaF

Before starting, it is necessary to know this:

printLn("Hello, World!")

Comments

If you want to comment your code, you can use:

-- This is a single line comment
/*
And this a multiline comment
*/

Data Types

Let Statements

This language does not use variables. Instead of variables, you can only declare static values.
For declaring a value, you must use let and give it a value. For example:

let a = 1 -- Interger
let b = 1.0 -- Float
let c = "string" -- String
let d = true -- Boolean
let e = [1,2,3] -- List
let f = (1, 2) -- Tuple
...

SigmaF allows data type as Integer, Float, Boolean, and String.

Data Structs

Lists

The Lists allow to use all the data types before mentioned, as well as lists and functions.
Also, they allow to get an item through the next notation:

let value_list = [1,2,3,4,5,6,7,8,9]
value_list[0] -- Output: 1
value_list[0, [4] -- Output: [1,2,3,4]
value_list[0, 8, 2] -- Output: [1, 3, 5, 7]

The struct of List CAll is example_list[<Start>, <End>, <Jump>]

Tuples

The tuples are data structs of length greater than 1. Unlike lists, they allow the following operations:

(1,2) + (3,4) -- Output: (4,6)
(4,6,8) - (3,4,5) -- Output: (1,2,3)
(0,1) == (0,1) -- Output: true
(0,1) != (1,3) -- Output: true

To obtain the values of a tuple, you must use the same notation of the list. But this data structure does not allow ranges like the lists (only you can get one position of a tuple).

E.g.

let t = (1,2,3,4,5,6)
t[1] -- Output: 2
t[5] -- Output: 6

And so on.

Conditionals

Regarding the conditionals, the syntax structure is:

if <Condition> then {
<Consequence>
}
else{
<Other Consequence>
 }

For example:

if x <= 1 || x % i == 0 then {
false;
}
if x == i then {
true;
}
else {
false;
}

Functions

For declaring a function, you have to use the next syntax:

let example_function = fn <Name Argument>::<Argument Type> -> <Output Type> {
=> <Return Value>
}

(For return, you have to use the => symbol)

For example:

let is_prime_number = fn x::int, i::int -> bool {
if x <= 1 then {=>false;}
if x == i then {=> true;}
if (x % i) == 0 then {=> false;}
=> is_prime_number(x, i+1);
}

printLn(is_prime_number(11, 2)) -- Output: true

Operators

Warning: SigmaF have Static Typing, so it does not allow the operation between different data types.

These are operators:

Operator Symbol
Plus +
Minus -
Multiplication *
Division /
Modulus %
Exponential **
Equal ==
Not Equal !=
Less than <
Greater than >
Less or equal than <=
Greater or equal than >=
And &&
Or ||

The operator of negation for Boolean was not included. You can use the not() function in order to do this.

Some Examples

Quick Sort

-- Quick Sort
let qsort = fn l::list -> list {

if (l == []) then {=> [];}
else {
let p = l[0];
let xs = tail(l);

let c_lesser = fn q::int -> bool {=> (q < p)}


let c_greater = fn q::int -> bool {=> (q >= p)}

=> qsort(filter(c_lesser, xs)) + [p] + qsort(filter(c_greater, xs));
}
}

Filter

-- Filter
let filter = fn c::function, l::list -> list {
if (l == []) then {=> [];}

=> if (c(l[0])) then {[l[0]]} else {[]} + filter(c, tail(l));
}

Map

-- Map
let map = fn f::function, l::list -> list {
if (l==[]) then {=> [];}

=> [f(l[0])] + map(f, tail(l));
}