Az bilgiyle çok şey yapabileceğin bir programlama dili

fn main() {
  print("Merhaba dünya!")
}

// Bu satır bir yorum, çalıştırılmaz.

/* Birden çok satırı
   kaplayan yorum da yazılabilir. */

print("yorumlar çıktıyı etkilemez")

print("tek değer")
print("ad:", "Ayşe", "yaş:", 30)
print([1, 2, 3])
print(3.5, true, none)

let ad = "Mustafa"      // değişmez
var sayac = 0           // değişebilir

sayac = sayac + 1
sayac += 5              // aynı şeyin kısa yazımı

print(ad, sayac)

let a = 42              // Int  (kendisi anladı)
let b = 3.14            // Float
let c = "merhaba"       // String
let d = true            // Bool

let e: Float = 10       // istersen açıkça yaz
let f: String = "elma"

print(a, b, c, d, e, f)

print(2 + 3)            // 5
print(10 - 4)           // 6
print(3 * 4)            // 12
print(7 / 2)            // 3    <- tam bölme
print(7 / 2.0)          // 3.5  <- ondalıklı
print(7 % 3)            // 1    <- kalan
print(1 + 2.5)          // 3.5  <- karışık kullanılabilir

print(sqrt(16), abs(-5), min(3, 8), max(3, 8))
print(floor(3.7), ceil(3.2), round(3.5))

let ad = "Ayşe"
let yas = 30

print("Merhaba " + ad)
print("Yaş: " + yas)              // sayı otomatik yazıya döner
print("${ad} ${yas} yaşında")     // gömme — en okunaklısı
print("Toplam: ${yas + 5}")       // içinde işlem de yapılır

let s = "  Merhaba Dünya  "

print(s.trim())                  // baştaki/sondaki boşlukları atar
print(s.trim().len())            // harf sayısı
print(s.trim().lower())
print("istanbul".upperTr())      // Türkçe: İSTANBUL
print("IĞDIR".lowerTr())         // Türkçe: ığdır
print("a-b-c".split("-"))
print("a-b-c".replace("-", "+"))
print("merhaba".contains("hab"))
print("merhaba".slice(0, 3))     // ilk 3 harf
print("ab".repeat(3))

print("A".kodu())          // 65
print("a".kodu())          // 97
print(koddan(65))          // A

// Türkçe harfler de aynı şekilde
print("ı".kodu())
print(koddan(305))

// Sezar şifresi: her harfi üç ileri kaydır
let harf = "d"
print(koddan(harf.kodu() + 3))

print(5 > 3)             // true
print(5 == 5)            // eşit mi
print(5 != 3)            // eşit değil mi
print(5 >= 5, 2 <= 1)

let a = true
let b = false
print(a && b)            // ve   — ikisi de doğruysa
print(a || b)            // veya — biri doğruysa
print(!a)                // değil

let not = 85

if not >= 90 {
  print("A aldın")
} else if not >= 80 {
  print("B aldın")
} else {
  print("Daha çok çalış")
}

let yas = 20

let durum = if yas >= 18 { "yetişkin" } else { "çocuk" }
print(durum)

// zincirlenebilir
let not = 85
let harf = if not >= 90 { "A" } else if not >= 80 { "B" } else { "C" }
print("harf:", harf)

// başka bir ifadenin içinde de kullanılabilir
print("ücret: " + if yas < 12 { 0 } else { 50 })

enum Hava {
  Gunesli
  Yagmurlu
  Karli
}

fn oneri(h: Hava) -> String = match h {
  Gunesli -> "şapka al"
  Yagmurlu -> {
    let arac = "şemsiye"
    let sebep = "yağmur"
    "${arac} al (${sebep})"
  }
  Karli -> {
    let katman = 3
    "${katman} kat giy"
  }
}

fn sinif(not: Int) -> String = if not >= 90 {
  "A"
} else if not >= 80 {
  let fark = 90 - not
  "B (A'ya ${fark} puan)"
} else {
  "C"
}

fn main() {
  print(oneri(Yagmurlu))
  print(oneri(Karli))
  print(sinif(85))
}

for i in 1..4 {
  print("sayı", i)
}

for i in 1..=3 {
  print("dahil", i)
}

for meyve in ["elma", "armut", "kiraz"] {
  print(meyve)
}

for harf in "abc" {
  print(harf)
}

let sehirler = ["İstanbul", "Ankara", "İzmir"]
for (sira, sehir) in sehirler {
  print("${sira + 1}. ${sehir}")
}

for (i, harf) in "açık" {
  print(i, harf)
}

let yaslar = {"Ayşe": 30, "Mehmet": 24}
for (ad, yas) in yaslar {
  print(ad, yas)
}

var sayi = 1

while sayi < 100 {
  sayi = sayi * 2
}

print("100'ü aşan ilk ikinin kuvveti:", sayi)

for i in 1..=10 {
  if i % 2 == 0 {
    continue          // çiftleri atla
  }
  if i > 7 {
    break             // 7'yi geçince dur
  }
  print(i)
}

var sayilar = [5, 3, 8, 1]

print(sayilar)
print("ilk eleman:", sayilar[0])
print("kaç eleman:", sayilar.len())

sayilar.push(10)              // sona ekle
print(sayilar)

print("sıralı:", sayilar.sort())
print("ters:", sayilar.reverse())
print("içinde 8 var mı:", sayilar.contains(8))
print("bir kısmı:", sayilar.slice(1, 3))

let sayilar = [5, 3, 8, 1, 3]

print("toplam:", sayilar.toplam())
print("ortalama:", sayilar.ortalama())
print("çarpım:", sayilar.carpim())
print("en büyük:", sayilar.enBuyuk() ?? 0)
print("en küçük:", sayilar.enKucuk() ?? 0)

print("iki katları:", sayilar.kat(2))
print("10 artırılmış:", sayilar.artir(10))
print("3'ten büyükler:", sayilar.buyukler(3))
print("3'ten küçükler:", sayilar.kucukler(3))
print("çiftler:", sayilar.ciftler())
print("tekler:", sayilar.tekler())

print("benzersiz:", sayilar.benzersiz())
print("kaç tane 3 var:", sayilar.say(3))

let kelimeler = ["nar", "elma", "kiraz"]
print("büyük harf:", kelimeler.buyukHarf())
print("'a' içerenler:", kelimeler.icerenler("a"))

let sayilar = [1, 2, 3, 4, 5]

print(sayilar.map(|x| x * x))          // her birinin karesi
print(sayilar.filter(|x| x % 2 == 0))  // sadece çiftler
print(sayilar.reduce(|a, b| a + b, 0)) // toplamı

// zincirlenebilir
print(sayilar.filter(|x| x > 2).map(|x| x * 10))

let kelimeler = ["nar", "elma", "kiraz"]
print(kelimeler.map(|k| k.upperTr()).join(", "))

var stok = {"elma": 12, "armut": 3}

stok.set("kiraz", 7)

print(stok)
print("kaç çeşit:", stok.len())
print("elma:", stok.get("elma") ?? 0)
print("muz:", stok.get("muz") ?? 0)      // yok -> 0
print("armut var mı:", stok.has("armut"))

for (urun, adet) in stok {
  print("${urun}: ${adet} adet")
}

fn selamla(ad: String) {
  print("Merhaba " + ad)
}

fn topla(a: Int, b: Int) -> Int {
  return a + b
}

fn main() {
  selamla("Nar")
  print(topla(3, 4))
}

fn kare(x: Int) -> Int = x * x

fn selam(ad: String) -> String = "Merhaba " + ad

fn buyuk_mu(n: Int) -> Bool = n > 100

fn main() {
  print(kare(9))
  print(selam("Nar"))
  print(buyuk_mu(150))
}

fn faktoriyel(n: Int) -> Int {
  if n <= 1 {
    return 1              // durma noktası
  }
  return n * faktoriyel(n - 1)
}

fn fib(n: Int) -> Int = if n < 2 { n } else { fib(n - 1) + fib(n - 2) }

fn main() {
  print("6! =", faktoriyel(6))
  print("fib(20) =", fib(20))
}

let iki_kat = |x: Int| x * 2
print(iki_kat(21))

// birden çok satır gerekiyorsa
let mesafe = |a: Int, b: Int| {
  let fark = a - b
  return abs(fark)
}
print(mesafe(3, 10))

// bir listeye uygularken tip yazmaya gerek yok
print([1, 2, 3].map(|x| x + 100))

struct Kisi {
  ad: String
  var yas: Int
}

fn main() {
  let k = Kisi { ad: "Ayşe", yas: 30 }

  print(k)
  print(k.ad, "->", k.yas)

  k.yas = 31        // 'var' olduğu için değiştirilebilir
  print("doğum günü sonrası:", k.yas)
}

struct Dikdortgen {
  en: Float
  boy: Float

  fn alan() -> Float = self.en * self.boy

  fn cevre() -> Float = 2.0 * (self.en + self.boy)

  fn kare_mi() -> Bool = self.en == self.boy

  fn buyut(kat: Float) -> Dikdortgen {
    return Dikdortgen { en: self.en * kat, boy: self.boy * kat }
  }
}

fn main() {
  let d = Dikdortgen { en: 3.0, boy: 4.0 }
  print("alan:", d.alan())
  print("çevre:", d.cevre())
  print("kare mi:", d.kare_mi())
  print("iki katı:", d.buyut(2.0))
}

enum Hava {
  Gunesli
  Yagmurlu
  Karli
}

fn main() {
  let bugun = Hava.Yagmurlu
  print(bugun)
}

enum Hava {
  Gunesli
  Yagmurlu
  Karli
}

fn oneri(h: Hava) -> String = match h {
  Gunesli -> "şapka al"
  Yagmurlu -> "şemsiye al"
  Karli -> "atkı al"
}

fn main() {
  print(oneri(Yagmurlu))
  print(oneri(Hava.Karli))   // uzun yazım da geçerli
}

fn temizle(s: String) -> String = s.trim()
fn buyut(s: String) -> String = s.upperTr()
fn sar(s: String, k: String) -> String = k + s + k

fn main() {
  let sayilar = [1, 2, 3, 4, 5]
  print(sayilar[1..3])        // [2, 3]
  print(sayilar[1..=3])       // [2, 3, 4]
  print("merhaba"[0..3])      // mer

  let bas = [0]
  print([...bas, ...sayilar[0..2], 9])

  print("  merhaba  " |> temizle |> buyut |> sar("*"))
}

fn bolVeKalan(a: Int, b: Int) -> (Int, Int) = (a / b, a % b)

fn enUzunKelime(cumle: String) -> (String, Int) {
  var enUzun = ""
  for k in cumle.split(" ") {
    if k.len() > enUzun.len() {
      enUzun = k
    }
  }
  return (enUzun, enUzun.len())
}

fn main() {
  let (bolum, kalan) = bolVeKalan(17, 5)
  print(str(bolum) + " kalan " + str(kalan))

  let (kelime, uzunluk) = enUzunKelime("bugün hava çok güzel")
  print(kelime + " — " + str(uzunluk) + " harf")

  // Tek tek de okunur:
  let ikili = bolVeKalan(9, 2)
  print(str(ikili.0) + "/" + str(ikili.1))
}

fn siniflandir(n: Int) -> String = match n {
  x if x < 0 -> "eksi"
  0 -> "sıfır"
  1..=9 -> "tek haneli"
  10..=99 -> "iki haneli"
  _ -> "daha büyük"
}

fn main() {
  for n in [-3, 0, 7, 42, 1000] {
    print(str(n) + " -> " + siniflandir(n))
  }
}

struct Kutu {
  var yazi: String
  var genislik: Int = 20
  var cerceve: Bool = true
}

fn bicim(metin: String, once: String = "[", sonra: String = "]") -> String =
  once + metin + sonra

fn main() {
  print(bicim("selam"))
  print(bicim("selam", sonra: ">"))
  print(bicim(sonra: ">", once: "<", metin: "selam"))

  let k = Kutu { yazi: "not" }
  print(k.yazi + " " + str(k.genislik) + " " + str(k.cerceve))
}

enum Hava {
  Gunesli
  Yagmurlu
  Karli
}

fn tavsiye(h: Hava) -> String = match h {
  Hava.Gunesli -> "Şapka al."
  Hava.Yagmurlu -> "Şemsiye al."
  Hava.Karli -> "Mont al."
}

fn main() {
  for h in [Hava.Gunesli, Hava.Yagmurlu, Hava.Karli] {
    print(tavsiye(h))
  }

  // sayı ya da metin üzerinde de çalışır
  let n = 3
  print(match n {
    1 -> "bir"
    2 -> "iki"
    _ -> "çok"           // _ = geri kalan her şey
  })
}

enum Sonuc {
  Tamam(Int)
  Hata(String)
}

fn bol(a: Int, b: Int) -> Sonuc {
  if b == 0 {
    return Sonuc.Hata("sıfıra bölünemez")
  }
  return Sonuc.Tamam(a / b)
}

fn main() {
  for bolen in [4, 0, 5] {
    match bol(100, bolen) {
      Sonuc.Tamam(deger) -> print("100 / ${bolen} = ${deger}")
      Sonuc.Hata(mesaj) -> print("olmadı: ${mesaj}")
    }
  }
}

struct Kutu<T> {
  deger: T
  fn al() -> T = self.deger
}

fn main() {
  let sayiKutusu = Kutu { deger: 5 }
  let metinKutusu = Kutu { deger: "merhaba" }

  print(sayiKutusu.al())
  print(metinKutusu.al())

  // Tipi açıkça da yazabilirsin
  let acik = Kutu<Float> { deger: 2.5 }
  print(acik.deger)
}

fn ilk<T>(liste: [T]) -> T? {
  if liste.len() == 0 {
    return none
  }
  return liste[0]
}

fn ikiKat<T>(x: T) -> [T] = [x, x]

fn main() {
  print(ilk([3, 4, 5]) ?? 0)
  print(ilk(["a", "b"]) ?? "yok")

  let bos: [Int] = []
  print(ilk(bos) ?? -1)

  print(ikiKat(7))
  print(ikiKat("x"))
}

enum Sonuc<T, H> {
  Tamam(T)
  Hata(H)
}

fn bol(a: Int, b: Int) -> Sonuc<Int, String> {
  if b == 0 {
    return Sonuc.Hata("sıfıra bölünemez")
  }
  return Sonuc.Tamam(a / b)
}

fn main() {
  for bolen in [4, 0] {
    match bol(100, bolen) {
      Sonuc.Tamam(deger) -> print("100 / ${bolen} = ${deger}")
      Sonuc.Hata(mesaj) -> print("olmadı: ${mesaj}")
    }
  }
}

enum Agac<T> {
  Yaprak(T)
  Dal([Agac<T>])
}

fn topla(a: Agac<Int>) -> Int = match a {
  Agac.Yaprak(n) -> n
  Agac.Dal(dallar) -> dallar.map(|d| topla(d)).toplam()
}

fn main() {
  let agac = Agac.Dal([
    Agac.Yaprak(1),
    Agac.Dal([Agac.Yaprak(2), Agac.Yaprak(3)])
  ])
  print("yaprakların toplamı:", topla(agac))
}

interface Yazdirilabilir {
  fn yaz() -> String
}

struct Nokta: Yazdirilabilir {
  x: Float
  y: Float
  fn yaz() -> String = "(${self.x}, ${self.y})"
}

struct Kisi: Yazdirilabilir {
  ad: String
  fn yaz() -> String = "kişi: " + self.ad
}

fn goster(sey: Yazdirilabilir) {
  print(sey.yaz())
}

fn main() {
  goster(Nokta { x: 1.0, y: 2.0 })
  goster(Kisi { ad: "Ayşe" })
}

interface Yazdirilabilir {
  fn yaz() -> String
}

struct Kisi: Yazdirilabilir {
  ad: String
  fn yaz() -> String = "kişi: " + self.ad
}

enum Durum: Yazdirilabilir {
  Acik
  Kapali
  fn yaz() -> String = match self {
    Durum.Acik -> "açık"
    Durum.Kapali -> "kapalı"
  }
}

fn main() {
  let hepsi: [Yazdirilabilir] = [
    Kisi { ad: "Ayşe" },
    Durum.Acik,
    Durum.Kapali
  ]
  for e in hepsi {
    print("- " + e.yaz())
  }
}

interface Olculebilir {
  fn olcu() -> Float
}

struct Nokta: Olculebilir {
  x: Float
  y: Float
  fn olcu() -> Float = sqrt(self.x * self.x + self.y * self.y)
}

fn enBuyuk<T: Olculebilir>(liste: [T]) -> Float {
  var en = 0.0
  for e in liste {
    if e.olcu() > en {
      en = e.olcu()
    }
  }
  return en
}

fn main() {
  print(enBuyuk([
    Nokta { x: 3.0, y: 4.0 },
    Nokta { x: 6.0, y: 8.0 }
  ]))
}

let takma: String? = none
let gercek: String? = "Nar"

print(takma)
print(gercek)

// ?? ile yedek değer ver
print(takma ?? "takma adı yok")
print(gercek ?? "takma adı yok")

let sayilar = [10, 20, 30]

let ilk = sayilar.first()        // İlk eleman olmayabilir (liste boşsa)
print("ilk:", ilk ?? 0)

if ilk != none {
  print("var, iki katı:", ilk * 2)   // burada artık kesin var
}

var bos: [Int] = []
print("boş listenin ilki:", bos.first() ?? -1)

fn yas(ad: String) -> Int? {
  let defter = {"Ayşe": 30, "Mehmet": 24}
  return defter.get(ad)
}

fn main() {
  if let y = yas("Ayşe") {
    print("Ayşe ${y} yaşında")
  } else {
    print("Ayşe defterde yok")
  }

  if let y = yas("Zeynep") {
    print("Zeynep ${y} yaşında")
  } else if let y = yas("Mehmet") {
    print("Zeynep yok ama Mehmet ${y} yaşında")
  } else {
    print("ikisi de yok")
  }
}

// Satırların ilkindeki sayıyı okur.
// Herhangi bir adım tutmazsa sonuç none olur.
fn ilkSayi(satirlar: [String]) -> Int? {
  let satir = satirlar.first()?
  return int(satir.trim())?
}

fn main() {
  print(ilkSayi(["  42  ", "başka satır"]) ?? -1)
  print(ilkSayi(["sayı değil"]) ?? -1)
  print(ilkSayi([]) ?? -1)
}

struct Adres {
  sehir: String
}

struct Kisi {
  ad: String
  adres: Adres?
}

fn main() {
  let a = Kisi { ad: "Ayşe", adres: Adres { sehir: "Ankara" } }
  let b = Kisi { ad: "Veli", adres: none }

  print(a.adres?.sehir ?? "adres yok")
  print(b.adres?.sehir ?? "adres yok")
}

fn main() {
  let baslik = bul("#baslik")

  if baslik != none {
    baslik.metinYaz("Merhaba Nar")
    baslik.stil("color", "#a32a2f")
    baslik.sinifEkle("vurgulu")
  }
}

var sayi = 0

fn main() {
  let alan = bul("#uygulama")
  if alan == none {
    print("bu program tarayıcıda çalışmalı")
    return
  }

  let ekran = olustur("div")
  ekran.ozellikYaz("id", "ekran")
  ekran.metinYaz("0")
  alan!.ekle(ekran)

  let dugme = olustur("button")
  dugme.metinYaz("Artır")
  dugme.dinle("click", || {
    sayi += 1
    bul("#ekran")?.metinYaz(str(sayi))
  })
  alan!.ekle(dugme)
}

fn ornekler(e: Element) {
  e.metinYaz("yazı")            // içindeki yazıyı değiştir
  print(e.metin())              // içindeki yazıyı oku
  e.htmlYaz("<b>kalın</b>")     // HTML olarak yaz
  e.degerYaz("giriş")           // input/textarea değeri
  print(e.deger())

  e.sinifEkle("acik")
  e.sinifSil("kapali")
  print(e.sinifVarMi("acik"))

  e.ozellikYaz("id", "kutu")
  print(e.ozellik("id") ?? "yok")
  e.stil("color", "red")

  e.dinle("click", || { print("tıklandı") })

  e.ekle(olustur("span"))       // çocuk ekle
  e.temizle()                   // içini boşalt
  e.odaklan()

  print(e.bul(".ic") != none)   // içinde ara
}

import "araclar/arayuz.nar"

// Ekran bir Gorunum ağacıdır: Sutun, Satir, Kutu içinde
// Metin, Baslik, Dugme, Giris, Bosluk, Cizgi.
fn ciz(sayi: Int) -> Gorunum = Kutu([
  Baslik("Sayaç"),
  Metin("değer: ${sayi}"),
  Satir([
    Dugme("azalt", || { azalt() }),
    Dugme("artır", || { artir() })
  ])
])

import "araclar/arayuz.nar"

var uygulama: Uygulama<Int>? = none

fn artir() {
  if uygulama != none {
    uygulama!.degistir(uygulama!.durum + 1)
  }
}

fn ciz(sayi: Int) -> Gorunum = Sutun([
  Baslik("Sayaç"),
  Metin("değer: ${sayi}"),
  Dugme("artır", || { artir() })
])

fn main() {
  // Sayfadaki <div id="uygulama"></div> içine çizer.
  uygulama = uygulamaBaslat("#uygulama", 0, ciz)
}

fn gorevSatiri(sira: Int, g: Gorev) -> Gorunum {
  var kutu = "[ ]"
  if g.bitti {
    kutu = "[x]"
  }
  return Satir([
    Dugme(kutu, || { gorevDegistir(sira) }),
    Metin(g.baslik)
  ])
}

fn gorevListesi(gorevler: [Gorev]) -> Gorunum {
  if gorevler.len() == 0 {
    return Metin("Henüz görev yok.")
  }
  var satirlar: [Gorunum] = []
  var sira = 0
  for g in gorevler {
    satirlar.push(gorevSatiri(sira, g))
    sira += 1
  }
  return Sutun(satirlar)
}

import "../araclar/arayuz.nar"

fn ciz(n: Int) -> Gorunum = Kart("Deri denemesi", [
  Metin("Sayaç: ${n}"),
  Satir([
    Dugme("Artır", || { }),
    IkincilDugme("Sıfırla", || { })
  ])
])

fn main() {
  deriSec("yumusak")        // "" verirsen varsayılana döner
  uygulamaBaslat("#uygulama", 0, ciz)
}

import "../araclar/arayuz.nar"

fn ciz(yukleniyor: Bool) -> Gorunum {
  if yukleniyor {
    return Kart("Kayıtlar", [
      Iskelet(3),
      Bosluk(8),
      Donuyor("Veri geliyor…")
    ])
  }

  return Kart("Kayıtlar", [
    Sirali([
      Metin("Ayşe"),
      Metin("Mehmet"),
      Metin("Zeynep")
    ]),
    Cizgi,
    Hareketli(NABIZ, Rozet("kaydedildi", TON_BASARI))
  ])
}

fn main() {
  kademeSec(KADEME_SAKIN)
  uygulamaBaslat("#uygulama", true, ciz)
}

import "../araclar/arayuz.nar"

fn ciz(n: Int) -> Gorunum = Kart("Sipariş", [
  // Geniş ekranda yan yana, telefonda alt alta.
  Satir([
    Kutu([Metin("Ürün: Nar")]),
    Kutu([Metin("Adet: 3")]),
    Kutu([Metin("Tutar: 120₺")])
  ]).mobildeSutun(),

  // Geniş ekranda tablo, telefonda liste.
  Tablo(["Ad", "Adet"], [["Nar", "3"]]).mobil(Liste(["Nar × 3"])),

  Rozet("klavye kısayolu: Ctrl+K", TON_BILGI).mobildeGizle(),
  Dugme("Öde", || { }).masaustundeGizle()
])

fn main() {
  uygulamaBaslat("#uygulama", 0, ciz)
}

import "araclar/arayuz.nar"

var uygulama: Uygulama<Int>? = none

fn git(i: Int) {
  if uygulama != none {
    uygulama!.degistir(i)
  }
}

fn ciz(sayfa: Int) -> Gorunum = Yigin([
  Gezinti("Kavurma", ["Menü", "Hakkında", "İletişim"], sayfa,
          |i| { git(i) },
          Dugme("Sipariş ver", || { })),

  Kahraman("Günlük kavurma", "Sabah taze kavrulur",
           "Siparişin aynı gün yola çıkar.",
           [Dugme("Menüye bak", || { git(0) }),
            IkincilDugme("Nasıl çalışır?", || { git(1) })]),

  Bolum("Neden biz?", "Üç sebep.",
    Izgara(3, [
      Kart("Taze", [Metin("Kavurma günü kargolanır.")]),
      Kart("Şeffaf", [Metin("Çekirdeğin geldiği yeri yazıyoruz.")]),
      Kart("Esnek", [Metin("Öğütümü sen seçersin.")])
    ])),

  AltBilgi(["Kavurma", "Kurum"], [
    [Bag("Menü", "#"), Bag("Abonelik", "#")],
    [Bag("Hakkında", "#"), Bag("İletişim", "#")]
  ], "© 2026 Kavurma · Mardin")
])

fn main() {
  uygulama = uygulamaBaslat("#uygulama", 0, ciz)
}

// Aynı program dört hedefte de çalışır.
fn main() {
  let kutu = bul("#uygulama")
  if kutu == none {
    print("terminaldeyiz")
    return
  }
  kutu!.metinYaz("tarayıcıdayız")
}

nar build ornekler/yapilacaklar_uygulamasi.nar --target masaustu

# üretilen klasör:
#   index.html    programın kendisi
#   baslat.py     pencereyi açan başlatıcı
#   baslat.cmd    Windows kısayolu
#   BENIOKU.md

nar build ornekler/yapilacaklar_uygulamasi.nar --target mobil

cd cikti/yapilacaklar_uygulamasi-mobil
npm install
npx cap add android
npx cap open android     # Android Studio açılır, ▶ ile çalıştır

# Nar ile yazılmış derleyiciyle bir dosyayı denetle
nar ozdenetim ornekler/yapilacaklar_uygulamasi.nar

# Derleyici kendi kaynağını da okuyabiliyor
nar ozdenetim derleyici/parser.nar --kutuphane

$ nar ozdenetim derleyici/denetleyici.nar --kutuphane
tamam — hata yok

$ nar ozdenetim bozuk.nar
hata: 2:1 — 'A' tipi zaten tanımlı
hata: 1:15 — bilinmeyen tip: 'Yok'

// Kaynak
fn kare(x: Int) -> Int = x * x

// İki çözümleyicinin de ürettiği S-ifadesi
(modul [(fn "kare" [] [] [(parametre "x" (tad "Int"))] (tad "Int")
  (blok [(donus (ikili "*" (ad "x") (ad "x")))]))])

// araclar.nar dosyası:
fn selamla(ad: String) -> String = "Merhaba " + ad


// program.nar dosyası:
import "araclar.nar"

fn main() {
  print(selamla("Nar"))
}

fn main() {
  // Dosya yazma ve okuma
  dosyaYaz("not.txt", "birinci satır\n")
  dosyaEkle("not.txt", "ikinci satır\n")

  let icerik = dosyaOku("not.txt")
  if icerik != none {
    print("satır sayısı:", icerik!.trim().split("\n").len())
  }

  print("var mı:", dosyaVarMi("not.txt"))
  dosyaSil("not.txt")

  // Klasördeki dosyalar
  let dosyalar = klasorListele("ornekler")
  print("kaç dosya:", dosyalar.len())

  // Komut satırı argümanları
  print("argümanlar:", argumanlar())

  // Zaman
  print("şu an:", zamanMetni())
  let basla = simdi()
  var toplam = 0
  for i in 1..=1000 { toplam += i }
  print("geçen süre (ms):", simdi() - basla)

  // Kullanıcıdan girdi (terminalden):
  //   let satir = satirOku()
  //   if satir != none { print("girdin: " + satir!) }
}

let sayi = 5
sayi = 6

enum Durum {
  Acik
  Kapali
  Bekliyor
}

fn main() {
  match Durum.Acik {
    Durum.Acik -> print("açık")
    Durum.Kapali -> print("kapalı")
  }
}