Ders 04: Fonksiyonlar

📖 Büyü KitabıSpell Book

Fonksiyonlar, büyüler gibidir! Bir kere yaz, istediğin kadar kullan. 🧙‍♂️

📝 Örnek 1: Saldırı BüyüleriExample 1: Attack Spells

🔮 buyuler.berk

// 🔥 Ateş topu büyüsü
fonksiyon ates_topu() {
    yazdir("🔥 ATEŞ TOPU!");
    yazdir("💥 50 hasar verdin!");
}

// ❄️ Buz oku büyüsü
fonksiyon buz_oku() {
    yazdir("❄️ BUZ OKU!");
    yazdir("💥 30 hasar + yavaşlatma!");
}

// ⚡ Şimşek büyüsü - parametre ile
fonksiyon simsek(guc: tamsayı) {
    yazdir("⚡ ŞİMŞEK! Güç: {}", guc);
    değişken hasar = guc * 10;
    yazdir("💥 {} hasar verdin!", hasar);
}

fonksiyon ana() {
    yazdir("🧙‍♂️ Büyücü savaşa hazır!\n");
    
    ates_topu();
    yazdir("");
    
    buz_oku();
    yazdir("");
    
    simsek(5);  // 50 hasar
    simsek(10); // 100 hasar!
}

📝 Örnek 2: Karakter YetenekleriExample 2: Character Abilities

🦸 yetenekler.berk

// İyileştirme büyüsü - değer döndürüyor!
fonksiyon iyilestir(mevcut_can: tamsayı) -> tamsayı {
    değişken iyilesme = 25;
    yazdir("💚 +{} can iyileştirildi!", iyilesme);
    don mevcut_can + iyilesme;
}

// Hasar hesapla
fonksiyon hasar_hesapla(guc: tamsayı, zirh: tamsayı) -> tamsayı {
    değişken net_hasar = guc - zirh;
    eğer net_hasar < 0 yap
        don 0;
    son
    don net_hasar;
}

fonksiyon ana() {
    değişken mut can = 50;
    yazdir("❤️ Başlangıç canı: {}", can);
    
    can = iyilestir(can);
    yazdir("❤️ Şimdiki can: {}", can);
    
    can = iyilestir(can);
    yazdir("❤️ Şimdiki can: {}", can);
    
    yazdir("\n⚔️ Savaş!");
    değişken hasar = hasar_hesapla(30, 10);
    yazdir("Alınan hasar: {}", hasar);
}

🎯 Senin Görevin!Your Mission!

"Kalkan" büyüsü yaz - zırhı 2 katına çıkarsın!
"Kritik Vuruş" fonksiyonu yaz - %20 şansla hasar 3 katına çıksın!

📖 Fonksiyon YapısıFunction Structure

BERK

// Temel fonksiyon yapısı
fonksiyon isim(parametre: tip) -> donus_tipi {
    // kod
    don deger;
}

// Örnekler:
fonksiyon selamla() {                    // Parametresiz, dönüşsüz
    yazdir("Merhaba!");
}

fonksiyon kare(x: tamsayı) -> tamsayı {  // Parametreli, dönüşlü
    don x * x;
}

📝 Örnek 1: Matematik YardımcılarıExample 1: Math Helpers

📐 matematik.berk

// Daire alanı
fonksiyon daire_alani(yaricap: ondalık) -> ondalık {
    sabit PI = 3.14159;
    don PI * yaricap * yaricap;
}

// Dikdörtgen çevresi
fonksiyon dikdortgen_cevresi(en: ondalık, boy: ondalık) -> ondalık {
    don 2.0 * (en + boy);
}

// Üçgen alanı
fonksiyon ucgen_alani(taban: ondalık, yukseklik: ondalık) -> ondalık {
    don (taban * yukseklik) / 2.0;
}

// Fahrenheit'tan Celsius'a
fonksiyon fahrenheit_to_celsius(f: ondalık) -> ondalık {
    don (f - 32.0) * 5.0 / 9.0;
}

fonksiyon ana() {
    yazdir("📐 Matematik Hesaplayıcı\n");
    
    yazdir("Daire alanı (r=5): {:.2}", daire_alani(5.0));
    yazdir("Dikdörtgen çevresi (3x4): {:.2}", dikdortgen_cevresi(3.0, 4.0));
    yazdir("Üçgen alanı (t=6, h=4): {:.2}", ucgen_alani(6.0, 4.0));
    yazdir("98.6°F = {:.1}°C", fahrenheit_to_celsius(98.6));
}

📝 Örnek 2: Not HesaplayıcıExample 2: Grade Calculator

📊 grades.berk

function calculate_average(vize: float, final_grade: float) -> float {
    return vize * 0.4 + final_grade * 0.6;
}

function get_letter_grade(average: float) -> string {
    if average >= 90.0 do return "AA"; end
    if average >= 85.0 do return "BA"; end
    if average >= 80.0 do return "BB"; end
    if average >= 75.0 do return "CB"; end
    if average >= 70.0 do return "CC"; end
    if average >= 65.0 do return "DC"; end
    if average >= 60.0 do return "DD"; end
    if average >= 50.0 do return "FD"; end
    return "FF";
}

function is_passing(letter: &string) -> bool {
    return letter != "FF" && letter != "FD";
}

function main() {
    let vize = 75.0;
    let final_grade = 85.0;
    
    let avg = calculate_average(vize, final_grade);
    let letter = get_letter_grade(avg);
    let passed = is_passing(&letter);
    
    print("📊 Sonuçlar:");
    print("  Vize: {} | Final: {}", vize, final_grade);
    print("  Ortalama: {:.1}", avg);
    print("  Harf: {}", letter);
    print("  Durum: {}", if passed do "✅ Geçti" else do "❌ Kaldı" end);
}

✏️ AlıştırmalarExercises

BMI (Vücut Kitle İndeksi) hesaplayan fonksiyon yazın.Write a function to calculate BMI.
Asal sayı kontrolü yapan fonksiyon yazın.

🎯 İleri Fonksiyon KavramlarıAdvanced Function Concepts

Higher-order functions (fonksiyon alan/döndüren)
Closures ve captured variablesClosures and captured variables
Generic functionsGeneric functions
Function pointers vs closuresFunction pointers vs closures

📝 Örnek 1: Higher-Order FunctionsExample 1: Higher-Order Functions

BERK (Advanced)

// Function that takes a function as parameter
function apply_twice(f: F, x: T) -> T 
where 
    F: Fn(T) -> T,
    T: Copy 
{
    f(f(x))
}

// Function that returns a function (closure)
function make_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor
}

// Function composition
function compose(f: F, g: G) -> impl Fn(A) -> C
where
    F: Fn(A) -> B,
    G: Fn(B) -> C,
{
    move |x| g(f(x))
}

function main() {
    // Higher-order function usage
    let double = |x: i32| x * 2;
    let result = apply_twice(double, 5);  // 5 -> 10 -> 20
    print("apply_twice(double, 5) = {}", result);
    
    // Closure factory
    let triple = make_multiplier(3);
    let quadruple = make_multiplier(4);
    print("triple(10) = {}", triple(10));      // 30
    print("quadruple(10) = {}", quadruple(10)); // 40
    
    // Function composition
    let add_one = |x: i32| x + 1;
    let square = |x: i32| x * x;
    let add_then_square = compose(add_one, square);
    print("(5 + 1)² = {}", add_then_square(5));  // 36
}

📝 Örnek 2: Generic PipelineExample 2: Generic Pipeline

BERK (Generics)

// Generic max function
function max(a: T, b: T) -> T {
    if a > b { a } else { b }
}

// Generic find function
function find(slice: &[T], target: &T) -> Option {
    for (i, item) in slice.iter().enumerate() {
        if item == target {
            return Some(i);
        }
    }
    None
}

// Pipeline builder pattern
struct Pipeline {
    value: T,
}

impl Pipeline {
    function new(value: T) -> Self {
        Pipeline { value }
    }
    
    function map U>(self, f: F) -> Pipeline {
        Pipeline { value: f(self.value) }
    }
    
    function tap(self, f: F) -> Self {
        f(&self.value);
        self
    }
    
    function unwrap(self) -> T {
        self.value
    }
}

function main() {
    // Generic functions
    print("max(10, 20) = {}", max(10, 20));
    print("max('a', 'z') = {}", max('a', 'z'));
    
    let numbers = [1, 2, 3, 4, 5];
    print("find 3: {:?}", find(&numbers, &3));  // Some(2)
    print("find 9: {:?}", find(&numbers, &9));  // None
    
    // Pipeline pattern
    let result = Pipeline::new(5)
        .tap(|x| print("Initial: {}", x))
        .map(|x| x * 2)
        .tap(|x| print("After *2: {}", x))
        .map(|x| x + 10)
        .tap(|x| print("After +10: {}", x))
        .unwrap();
    
    print("Final result: {}", result);  // 20
}

🎓 İleri Seviye AlıştırmalarAdvanced Exercises

Memoization decorator fonksiyonu implemente edin.
Generic fold fonksiyonu yazın (reduce pattern).

📌 ÖzetSummary

fonksiyon/function ile fonksiyon tanımlanırfonksiyon/function defines a function
Parametreler isim: tip formatında yazılırParameters use name: type format
-> tip ile dönüş tipi belirtilir-> type specifies return type
don/return ile değer döndürülürdon/return returns a value