vitte

Vitte — Language Specification

Introduction

La spécification du langage Vitte définit la syntaxe, la sémantique et le comportement attendu du compilateur, du runtime et de la VM.
Elle sert de référence officielle pour les développeurs, les contributeurs et les implémenteurs tiers.


Objectifs


Structure des Programmes

Unité de compilation

Un fichier .vit est une unité de compilation.
Il peut contenir :

Exemple minimal

fn main() {
    print("Hello, world!")
}

Lexique

Identifiants

Exemple : x, myVar, _hidden

Mots-clés réservés

fn let const return if else while for break continue
import from as extern true false null

Littéraux


Types

Types primitifs

Types composites

Typage


Variables et Constantes

let

Déclare une variable mutable.

let x = 10
x = 20

const

Déclare une constante immuable.

const PI = 3.14159

Fonctions

Déclaration

fn add(x: int, y: int) -> int {
    return x + y
}

Appel

let z = add(2, 3)

Récursivité

fn fact(n: int) -> int {
    if n <= 1 { return 1 }
    return n * fact(n - 1)
}

Contrôle de Flux

if / else

if x > 0 {
    println("positif")
} else {
    println("négatif ou nul")
}

while

let i = 0
while i < 5 {
    println(i)
    i = i + 1
}

for (désucré en while)

for let i = 0; i < 5; i = i + 1 {
    println(i)
}

break / continue

while true {
    if condition { break }
    if skip { continue }
}

Modules et Imports

Import simple

import math
let x = math.sqrt(16)

Import sélectif

from math import sqrt, pow

Alias

import system as sys

Erreurs et Exceptions

panic

Interrompt l’exécution immédiatement.

panic("Erreur fatale")

assert

Vérifie une condition.

assert(x > 0)

try / catch (roadmap)

try {
    let x = risky()
} catch e {
    println("Erreur: " + e)
}

Bytecode (VITBC)

Organisation

Exemple IR → Bytecode

LOAD_CONST r1, 2
LOAD_CONST r2, 3
ADD r3, r1, r2
PRINT r3

Interopérabilité

FFI (Foreign Function Interface)

Permet d’appeler du code natif.

extern fn c_sqrt(x: float) -> float

let r = c_sqrt(9.0)

Roadmap Langage


Conclusion

La spécification Vitte définit les fondations solides du langage :
un cœur simple, extensible et pensé pour évoluer vers un écosystème moderne.
Elle constitue la référence officielle de tout développement Vitte.