0Pricing
Learn Rust Coding · Ders

Yordamsal Makrolar: Türetme, İşlev

Daha karmaşık kod üretimi için özel `#[derive]` makroları ve işlev benzeri makrolar dâhil olmak üzere yordamsal makroları inceleyin.

Yordamsal Makrolar: Türetme, İşlev, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 3 dersten oluşur.

Yordamsal Makrolara Giriş

Yordamsal makrolar dünyasına hoş geldiniz! Bildirimsel makroların (macro_rules!) aksine yordamsal makrolar, doğrudan Rust kodu üzerinde çalışan işlevler gibidir.

Girdi olarak bir TokenStream alır, bunu işler ve başka bir TokenStream döndürürler. Bu, çok daha karmaşık kod üretimine olanak tanır.

Yordamsal Makro Türleri

Rust, üç ana yordamsal makro türü sunar:

  • İşlev benzeri makrolar: Normal işlev çağrıları gibi görünür ve davranırlar; ör. my_macro!(...).
  • Türetme makroları: #[derive(MyTrait)] kullanarak yapı ve numaralandırmalar için özellikleri otomatik olarak uygulamanızı sağlarlar.
  • Öznitelik makroları: Örneğin #[route("/path")] gibi öğelere uygulanabilen özel öznitelikler tanımlamanızı sağlarlar.

`proc-macro` Kasası

Yordamsal makrolar, kendilerine özgü özel bir kasa türünde bulunmalıdır. Cargo.toml dosyanızda bunu şu şekilde bildirirsiniz:

Bu, Cargo'ya kasanın derleme zamanında kodu dönüştüren makrolar içerdiğini bildirir.

[package]
name = "my_macros"
version = "0.1.0"
edition = "2021"

[lib]
proc-macro = true

İşlev Benzeri Makrolar Açıklaması

İşlev benzeri makrolar, bir proc_macro::TokenStream alan ve bir tane döndüren işlev üzerindeki #[proc_macro] özniteliğiyle tanımlanır.

Özel DSL'ler (Alana Özgü Diller) veya macro_rules! ile ele alınamayan karmaşık kod tekrarları için kullanışlıdırlar.

use proc_macro::TokenStream;

#[proc_macro]
pub fn my_function_macro(input: TokenStream) -> TokenStream {
    // Logic to transform input TokenStream
    // ...
    input // For example, return the input unchanged
}

İşlev Benzeri Makro Örneği

Burada kavramsal bir örnek verilmiştir. Bir yazdırma ifadesi oluşturan `greet_name!` makrosu. Gerçek uygulama, adı çıkarmak için girdi TokenStream'ini ayrıştırır.

Makro tanımı karmaşık olsa da kullanımı basit ve güçlüdür:

/* In 'my_macros/src/lib.rs' */
use proc_macro::TokenStream;

#[proc_macro]
pub fn greet_name(input: TokenStream) -> TokenStream {
    // Imagine parsing 'input' to get a name like 'World'
    // and generating: println!("Hello, World!");
    "println!(\"Hello, {}!\", \"CoddyKit\");".parse().unwrap()
}

/* In 'my_app/src/main.rs' */
use my_macros::greet_name;

fn main() {
    greet_name!("CoddyKit");
}

`#[derive]` Makrolarını Anlama

Türetme makroları en yaygın türdür. Bir yapı veya numaralandırma için bir özelliği otomatik olarak uygulamanızı sağlarlar.

#[derive(Debug)] yazdığınızda bir makro derleme zamanında çalışarak türünüzün Debug özelliğini uygulaması için gereken kodu oluşturur.

`#[derive]` Uygulama (Kavramsal)

Özel türetme makroları genellikle Rust kodunu bir AST'ye ayrıştırmak için syn ve bir AST'den Rust kodu oluşturmak için quote gibi kitaplıklar kullanılarak oluşturulur.

#[proc_macro_derive(MyTrait)] ile açıklanmış, yapıyı veya numaralandırmayı temsil eden bir TokenStream alan ve oluşturulan özellik uygulamasını döndüren bir işlev tanımlarsınız.

/* In 'my_macros/src/lib.rs' */
use proc_macro::TokenStream;
use syn::{parse_macro_input, DeriveInput};
use quote::quote;

#[proc_macro_derive(MyDebug)] // MyDebug is the trait name
pub fn my_debug_derive(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;

    let expanded = quote! {
        impl std::fmt::Debug for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                f.debug_struct(stringify!(#name)).finish()
            }
        }
    };
    expanded.into()
}

`#[derive(Debug)]` Kullanım Örneği

Muhtemelen daha önce kullandığınız bir türetme makrosuna ilişkin pratik bir örneğe bakalım: Debug. Point yapımıza #[derive(Debug)] eklediğimizde Rust, Debug özelliğini otomatik olarak uygular ve içeriğini düzgün biçimde yazdırmamızı sağlar.

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    println!("My point is: {:?}", p);
}

Öznitelik Makroları: `#[my_attribute]`

Öznitelik makroları türetme makrolarına benzer, ancak herhangi bir öğeye (işlevlere, yapılara, modüllere vb.) uygulanabilir. Uygulandıkları öğeyi ve parantez içindeki tüm bağımsız değişkenleri girdi olarak alırlar.

Yaygın kullanım alanları arasında web çatısı yönlendirmesi (ör. #[get("/users")]) veya test kurulumu (ör. #[test]) bulunur.

/* In 'my_macros/src/lib.rs' */
use proc_macro::TokenStream;

#[proc_macro_attribute]
pub fn log_calls(attr: TokenStream, item: TokenStream) -> TokenStream {
    // Imagine adding println! statements to 'item'
    item
}

/* In 'my_app/src/main.rs' */
use my_macros::log_calls;

#[log_calls("entry_point")]
fn my_function() {
    println!("Inside my_function");
}

fn main() {
    my_function();
}

Hangi Makro Ne Zaman Kullanılır

  • İşlev benzeri makrolar: Özel mini diller veya rastgele kod bloklarının karmaşık dönüşümleri için.
  • Türetme makroları: Yapılar ve numaralandırmalar üzerinde özellikleri otomatik olarak uygulamak için.
  • Öznitelik makroları: Özel özniteliklere göre belirli öğelerin (işlevler, yapılar) çevresindeki kodu değiştirmek veya oluşturmak için.

Her tür, Rust'ın söz dizimini ve yeteneklerini genişletmede kendine özgü bir amaca hizmet eder.

Kısa Kontrol: Makro Türleri

Yordamsal makrolarla ilgili aşağıdaki ifadelerden hangileri DOĞRUDUR?

Özet: Kod Oluşturma Gücü

Yordamsal makroların gelişmiş dünyasını keşfettiniz!

  • Özel söz dizimi için işlev benzeri makroları öğrendik.
  • #[derive] makrolarının özellik uygulamalarını nasıl otomatikleştirdiğini anladık.
  • Öğe düzeyinde kod oluşturma için öznitelik makrolarına kısaca değindik.

Yordamsal makrolar, tekrar eden kodu azaltmak ve Rust'ın yeteneklerini genişletmek için güçlü bir araçtır; kod yazan kod yazmanızı sağlar!

Sıkça Sorulan Sorular

“Yordamsal Makrolar: Türetme, İşlev” dersi ücretsiz mi?

Evet — “Yordamsal Makrolar: Türetme, İşlev” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 3 dersten oluşur.

“Yordamsal Makrolar: Türetme, İşlev” dersinde ne öğreneceğim?

Daha karmaşık kod üretimi için özel `#[derive]` makroları ve işlev benzeri makrolar dâhil olmak üzere yordamsal makroları inceleyin. Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 3 dersinin 2. dersidir.

“Yordamsal Makrolar: Türetme, İşlev” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Bildirimsel Makrolar (`macro_rules!`)
  2. Yordamsal Makrolar: Türetme, İşlev
  3. Güvensiz Rust ile Etkileşim
← Learn Rust Coding Sayfasına Dön