Dil Referansı

Bu sayfa, Tulpar parser’ının kabul ettiği her formun tek yerde toplanmış halidir. Dil Rehberi her konuyu örneklerle anlatır; burası “ne aradığımı zaten biliyorum” durumu için tutulan spec-vari özet.

Dosya yapısı

Bir .tpr dosyası top-level statement’ların sıralı listesidir: import’lar, fonksiyon tanımları, struct (type) tanımları, ve program başlar başlamaz çalışan herhangi bir ifade veya kontrol-akışı statement’ı. main() zorunluluğu yok — top-level statement’lar kaynak sırasına göre çalışır.

import "wings";          // import (yalnızca top-level)

type Point {             // struct tanımı
    int x;
    int y;
}

func origin(): Point {   // fonksiyon tanımı
    Point p = { x: 0, y: 0 };
    return p;
}

print(origin());         // top-level ifade — başlangıçta çalışır

Tipler

Tip	Literal örneği	Notlar
`int`	`42`, `-1`, `0xff`	64-bit signed.
`float`	`3.14`, `2.0`, `-0.5`	64-bit IEEE 754.
`bool`	`true`, `false`
`str`	`"merhaba"`, `t"x={n}"`	UTF-8. `t"..{expr}.."` interpolasyon; `+` çevirir.
`json`	`{"k": 1}`, `[1, 2, 3]`	Runtime’da object/array/scalar tagged-union.
`array<T>`	`[1, 2, 3]`	`T` ∈ `int / float / str / bool / json`.
`void`	—	Sadece dönüş tipi olabilir — `void` değer yok.
`<TipAdı>`	`Point p = { x: 1, y: 2 };`	Kullanıcı `type` ile tanımlar.

var (ve aliası let, tipsiz) ve null da rezerve. var tipi inferer’a bırakır, null ise atanmamış slot/değişkenin “yokluk” değeridir.

String interpolation. t"total: {n} adet" bir t-string’tir: her {expr} değerlendirilip yerleştirilir. Her zaman str üretir (t"{n}" bile); literal süslü parantez \{ / \} ile yazılır. Düz + de çalışır ve çevirir — "n=" + 5, "n=5" olur, toString() gerekmez.

Değişkenler

int x = 10;              // tipli, başlangıç değerli
str name = "Hamza";
bool flag;               // tipli, varsayılan (0 / "" / false / null)
var n = 7;               // tip başlangıç değerinden çıkarılır
let count = 0;           // `var` ile aynı

let ve var birbirinin yerine geçer — let “değişmeyecek” niyetini belirtir ama dil bunu zorunlu kılmaz.

Operatörler

Kategori	Operatörler
Aritmetik	`+`, `-`, `*`, `/`, `%`, tekli `-`
Karşılaş.	`==`, `!=`, `<`, `<=`, `>`, `>=`
Mantıksal	`&&`, `\|\|`, tekli `!`
Atama	`=`, `+=`, `-=`, `*=`, `/=`
Artır/azalt	`x++`, `x--` (sadece statement; ifade değil)
Subscript	`arr[i]`, `obj["key"]`, `obj.key` (`["key"]` sugar’ı)
Çağrı	`f(args)`, `mod.func(args)` (alias’lı import)

Öncelik (yüksekten düşüğe):

Postfix: çağrı (...), subscript [...], üye ., artır ++/--
Tekli: -, !
*, /, %
+, -
<, <=, >, >=
==, !=
&&
||
Atama: =, +=, …

Kontrol akışı

if (kosul) { ... }
if (kosul) { ... } else if (digeri) { ... } else { ... }

while (kosul) { ... }

for (int i = 0; i < n; i = i + 1) { ... }
// `i = i + 1` yerine `i++` ya da `i += 1` da geçerli

// for-each — bir diziyi, string'in karakterlerini veya range(n)'i gez.
// Parantez şart; döngü değişkeni çıkarsanır (tip yok, `var` yok).
for (x in [10, 20, 30]) { print(x); }
for (i in range(n))     { print(i); }

break;       // en içteki döngüden çık
continue;    // bir sonraki iterasyona atla
return;      // void fonksiyondan çık
return ifade; // değerle çık

// match — Rust tarzı; bir *ifadedir* (değer üretir).
str grade = match score {
    90        => "A",       // literal
    1 | 2 | 3 => "low",     // alternatifler
    10 .. 20  => "mid",     // kapsayıcı aralık
    _         => "other"    // joker
};
// Blok kollarıyla statement konumunda da geçerli:
match cmd { "go" => { run(); }, _ => { stop(); } }

// Destructuring — çıplak tanımlayıcı BAĞLAR, literal KISITLAR, `_`
// yok sayar, `..rest` dizi kuyruğunu yakalar. Desenler iç içe geçer.
match arr {
    []             => "empty",
    [0, second]    => "leading zero",      // 0 kısıtlar, second bağlar
    [head, ..tail] => "head + tail",
};
match user {                                // json obje / struct alanları
    {role: "admin", name} => "admin " + name,
    {name}                => "user " + name,
};
match shape {                               // tipli struct varyant desenleri
    Circle{r: 0} => "point",
    Rect{w, h}   => w * h,
};
match req { {user: {id}, path} => handle(id, path), _ => skip() };  // iç içe

match subject’ini bir kez değerlendirir ve ilk eşleşen kolu alır. Desenler: skaler literal (int / string / bool), |-alternatifler, lo .. hi aralıkları ve dizilerin ([a, b], [head, ..tail]), JSON objelerinin / struct alanlarının ({role: "admin", name}) ve tipli struct varyantlarının (Circle{r}) destructuring’i — ki iç içe geçer. _ joker (catch-all)‘dır.

for (x in koleksiyon) for-each’i dizi, string ve range(n) üzerinde çalışır (yukarı bakın). Object üzerinde henüz yok; anahtarlar için keys(obj) dizisini gezin.

Fonksiyonlar

// Pozisyonel parametreler; tip isimden önce.
func add(int a, int b): int {
    return a + b;
}

// Dönüş tipi yoksa = void (veya json döndürürseniz json).
func greet(str name) {
    print("Merhaba, " + name);
}

// Recursive çağrılar destekleniyor (forward reference otomatik çözülür).
func fib(int n): int {
    if (n <= 1) { return n; }
    return fib(n - 1) + fib(n - 2);
}

call("name") ile isimle çağrı yapılır; router / handler tablolarında işe yarar.

Struct (`type`)

type Point {
    int x;
    int y;
}

// Literal başlangıç.
Point p = { x: 3, y: 4 };
print(p.x);              // 3

// Değer ile geçer; kopya üzerinde değiştir.
func translate(Point p, int dx, int dy): Point {
    Point q = { x: p.x + dx, y: p.y + dy };
    return q;
}

Struct alanlarına . ile erişilir (["alan"] sugar’ı). Struct’ta == şu an alan-bazlı (json davranışı).

JSON / array

json o = { "name": "Hamza", "age": 24, "tags": ["admin", "user"] };
print(o["name"]);                // "Hamza"
print(o.tags[0]);                // "admin"
o["age"] = 25;                   // değiştir
o["yeni_alan"] = true;           // ekle
push(o.tags, "verified");        // yardımcı builtin

// Array:
array<int> nums = [1, 2, 3];
push(nums, 4);
int n = length(nums);            // 4

json runtime tagged-union’dur — aynı değer bir object, array, string, sayı veya null olabilir.

Modüller ve import

import "wings";              // tüm top-level fonksiyonları scope'a getirir
import "wings" as w;         // namespace'li — `w.listen(...)` ya da `w__listen(...)`
import "./local/util.tpr";   // path import (kaynağa göre relative)

Çözüm sırası: literal path → path.tpr → tulpar_modules/<name>/<name>.tpr → tulpar_modules/<name>.tpr → embedded stdlib. Lockfile + sürüm spesleri için Paket Yöneticisi sayfasına bakın.

Hata yönetimi

try {
    riskli();
} catch (e) {
    print("hata: " + toString(e));
} finally {
    temizle();
}

throw "hata mesajı";
throw {"code": 500, "msg": "patladı"};

catch (e) fırlatılan değeri e’ye bağlar (json olarak). finally yakalanmamış throw’da bile çalışır.

Async / await

async func fetch(int id) {        // hemen bir promise döndürür
    await sleep_async(20);        // bloklamaz; bu sırada başka görevler koşar
    return id * 2;
}

var p = fetch(21);                // kuyruğa alındı, henüz koşmadı
int r = await p;                  // sür → 42

// gather: birçoğunu eşzamanlı bekle, sonuçlar argüman sırasında
var all = await gather(fetch(1), fetch(2));

async func’lar tek-thread’li bir event loop üzerinde stackful coroutine’lerdir; birini çağırmak bir görev kuyruğa alıp promise döndürür, await onu sürer. Yakalanmayan bir throw promise’i reject eder ve await onu yeniden fırlatır; yani sıradan try / catch async hataları yakalar. En fazla 16 parametre. Tam model ve bloklamayan HTTP istemcisi için Async / Await rehberine bakın.

Yorumlar

// Tek satır — satır sonuna kadar.
/* Blok yorum — iç içe geçmez. */

Rezerve edilmiş anahtar kelimeler

async       await       break       catch       continue    do
else        false       finally     for         func        if
import      in          let         match       null        return
throw       true        try         type        var         void
while

Tip-adı keyword’leri (int, float, str, bool, json, array) de tip olarak kullanıldığında rezervedir; identifier içinde underscore ile geçebilir (int_value, array_size).

CLI özet tablosu

Komut	Etki
`tulpar foo.tpr`	AOT derle + çalıştır, hata olursa VM’e düşer.
`tulpar --vm foo.tpr`	Bytecode VM — hızlı başlangıç, yavaş steady-state.
`tulpar build foo.tpr [out]`	Standalone native binary.
`tulpar --repl`	İnteraktif prompt (VM destekli).
`tulpar fmt foo.tpr [-w]`	Kaynak formatlayıcı.
`tulpar pkg <subcmd>`	Paket yöneticisi — bkz. Paket Yöneticisi.
`tulpar --lsp`	stdio üzerinde LSP server (editör eklentileri kullanır).
`tulpar typecheck foo.tpr`	Standalone tip kontrolcüsü (build pre-pass olarak da çalışır).
`tulpar update [--check]`	Resmi sürümden self-update.

Tam CLI referansı (env değişkenleri dahil) CLI Referansı sayfasında.

Bu sayfa rehberden nasıl ayrılır

Dil Rehberi aynı yüzeyi çalıştırılabilir örneklerle ve motivasyonla anlatır; burası başka bir sekmede açık tuttuğun lookup tablosu. Burada bir şey yanlış görünüyorsa rehber sayfaları ve kaynak (src/parser/parser.cpp + src/lexer/lexer.cpp) kesin cevaptır.