> For the complete documentation index, see [llms.txt](https://glados.guillaume-hein.fr/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://glados.guillaume-hein.fr/introduction/syntax-overview.md).

# Syntax Overview

In "GoMelan," the syntax follows a set of rules to define the structure of programs. This section provides an overview of the language's syntax, covering key elements and their usage.

## Backus-Naur form (BNF)

```bnf
<program> ::= <include-list> <function-declaration> <main-function>

<include-list> ::= <include-statement> | <include-statement> <include-list>

<include-statement> ::= "include" "*" "from" <module> ";" | "include" "(" <import-list> ")" "from" <module> ";"

<module> ::= <identifier>

<import-list> ::= <import-identifier> | <import-identifier> "," <import-list>

<import-identifier> ::= <identifier>

<internal-function> ::= "len()" | "strToInt()" | ...

<function-declaration> ::= "fn" <function-name> "(" <parameter-list> ")" "->" <return-type> <block>

<function-prototype> ::= "fn" <function-name> "(" <parameter-list> ")" "->" <return-type> ";"

<function-name> ::= <identifier>

<parameter-list> ::= <parameter> | <parameter> "," <parameter-list>

<parameter> ::= <identifier> ":" <type>

<return-type> ::= <type>

<type> ::= "Int" | "Char" | "String" | "Bool" | "[" <type> "]" | "Float" | "FnType(" <parameter-list> ")" "->" <return-statement>

<comment> ::= "//" | "/*...*/"

<block> ::= "{" <statement-list> "}"

<statement-list> ::= <statement> | <statement> <statement-list>

<statement> ::= <variable-declaration> | <assignment> | <for-loop> | <print-statement> | <return-statement>

<variable-declaration> ::= <identifier> ":" <type> "=" <expression> ";"

<assignment> ::= <identifier> "=" <expression> ";"

<condition> ::= "if" "(" <expression> ")" <block> | "if" "(" <expression> ")" <block> "else" <block>

<for-loop> ::= <for-loop-iter> | <for-loop-in>

<for-loop-in> ::= "for" "(" <identifier> "in" <expression> ")" <block>

<for-loop-iter> ::= "for" "(" <for-loop-initialization> ";" <for-loop-condition> ";" <for-loop-update> ")" <block>

<for-loop-initialization> ::= <variable-declaration> | <assignment> | <empty>

<for-loop-condition> ::= <expression>

<for-loop-update> ::= <assignment> | <empty>

<return-statement> ::= "return" <expression> ";"

<expression> ::= <term> | <term> <binary-operator> <expression>

<term> ::= <factor> | <factor> <binary-operator> <term>

<factor> ::= <identifier> | <literal> | "(" <expression> ")"

<literal> ::= <number> | <string> | "true" | "false"

<number> ::= <digit>+

<string> ::= '"' <characters> '"'

<characters> ::= <character> | <character> <characters>

<character> ::= (any valid character)

<identifier> ::= (valid identifier)

<binary-operator> ::= "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "&&" | "||" | ...

<syntactic-sugar> ::= "++" | "--" | "+=" | "-=" | "*=" | "/=" | "%=" | ...

<digit> ::= '0' | '1' | '2' | ... | '9'

<empty> ::= epsilon
```

## Details on the BNF

### Program Structure

A "Gomelan" program consists of the following components:

* `<include-list>`: Importing modules and dependencies.
* `<function-declaration>`: Defining functions.
* `<main-function>`: The main entry point of the program.

### Include Statements

You can include external modules using "include" statements:

* `<include-statement>`: Import a module or a list of imports.
* `<module>`: The name of the module.
* `<import-list>`: A list of import identifiers.

### Functions

Functions in "Gomelan" are defined as follows:

* `<function-declaration>`: Declare a function with parameters and a return type.
* `<function-name>`: Name of the function.
* `<parameter-list>`: A list of parameters.
* `<parameter>`: Define function parameters.
* `<return-type>`: Specify the return type of the function.
* `<internal-function>`: Functions to facilitate development

### Data Types

"Gomelan" supports various data types:

* `<type>`: Can be "Int", "Char", "String", "Bool" or "FnType".

### Blocks and Statements

Code blocks are enclosed within curly braces and contain statements:

* `<block>`: Defines a code block.
* `<statement-list>`: A list of statements within a block.
* `<statement>`: Represents individual statements.

### Variables and Assignments

Variable declaration and assignments:

* `<variable-declaration>`: Declare and initialize variables.
* `<assignment>`: Assign values to variables.

### Control Flow

Control structures in "Gomelan":

* `<for-loop>`: For loop for iteration.
  * `<for-loop-iter>`: For loop with an incrementer
* `<condition>`: Conditional statements.
* `<return-statement>`: Returning values from functions.

### Expressions

Expressions in "Gomelan" follow standard mathematical and logical operators:

* `<expression>`: Represents expressions.
* `<term>` and `<factor>`: Building blocks for expressions.
* `<binary-operator>` and `<sintactic-sugar>`: Mathematical and logical operators.
* `<comment>`: Write a comment

### Literals

Literals represent constant values:

* `<number>`: Numeric values.
* `<string>`: Text values.
* "true" and "false": Boolean literals.

### Identifiers

* `<identifier>`: User-defined names for variables, functions, and types.

### Symbols

* `<digit>`: Numeric digits from '0' to '9'.
* `<character>`: Any valid character.
* `<binary-operator>`: Valid binary operators.

### Epsilon

* `<empty>`: Represents an empty or optional element.

This syntax overview provides a solid foundation for understanding the structure and elements of "Gomelan" programs. Use these rules to create, modify, and comprehend "Gomelan" code effectively.