狠狠撸

Rust’a Giri?
v.1
Rust versiyon: 0.4
MAHMUT BULUT

Telif Haklar?
? Her hakk? sakl?d?r.
Normal ve kanun? iktibaslarda kaynak g?sterilmesi zorunludur.
i

Mahmut BULUT, Eski?ehir Osmangazi ?niversitesi Bilgisayar Mühendisli?i
b?lümünde ??renimini sürdürmektedir. Yapay zeka ve topluluk zekas? konusunda
?al??malar yapmaktad?r, Haskell’in Hackage veritaban?nda Planlama ve MAS
sistem deste?i üzerinde ?al??maktad?r. Mageia Linux da??t?m?n?n QA sorum-lusudur.
2012 y?l? itibariyle Rust programlama dilinin olu?turulmas?nda rol alm??t?r
ve ana geli?tiricilerinden biridir. ?zel bir ?irkette ?al??mas?na devam etmekte ve
Rust programlama dilini de geli?tirmektedir.
ii

?ns?z
Bu kitap Rust programlama diline basit bir giri? olmas? niteli?inde yaz?ld?, dilin kul-lan?m?n?
artt?rmak ve Türk geli?tiricilere/kullan?c?lara dili tan?tmak amac? güt-mektedir.
Rust ?u anda prototip seviyesinde oldu?undan; keskinle?tirilmi? ve
yap?n?n iskeletini olu?turan k?s?mlar? buraya ald?m. Dilin daha üzerinde tart???lan
ve gelecek versiyonlar?nda yer alacak tüm semantik ve sentaks yap?s? bu kitab?n
i?eri?inde de?ildir. Rust’?n derin semantik yap?s?na ve ?ekirdek ilkelerine de?inerek
okuyucu zorlamak istemedi?imden basit ve sade, günlük hayatta kullan?labilecek
cinsten ?rnekler vermeye ?nem verdim. Kitap Rust’a yeni ba?layanlar ve ilgi duy-anlar
i?in birebirdir. Ayr?ca bu kitap Rust programlama dilinin yaz?ld??? zamana
ait Türk?e d?kümantasyonu olma ?zelli?ini de ta??r. Türk?e bili?im terminolojisine
girmeyen ama yeni tan?mlanm?? baz? terimleri de Türk?eye kazand?rmak amac?
da gütmektedir.
iii

??indekiler
1- Rust’a Genel Bak?? 6
1.1- Kitap Konvansiyonlar? 6
1.2- Nedenler ve Ama?lar 6
1.3- ?zellikler 6
2- Rust’?n Temelleri 8
2.1- Kurulum 8
2.1.1- Par?alar ve ?n?aa Sistemi ?nbilgisi 8
2.1.2- ??letim Sistemine Kurulum 8
2.1.3- Edit?r ve Geli?tirme Ortamlar? 10
2.2- ?lk Ad?mlar 10
2.3- De?i?kenler 11
2.3.1- Immutable(De?i?mez) De?i?kenler 11
2.3.2- Mutable(De?i?en) De?i?kenler 12
2.3.3- Tip Tan?mlamalar? 12
2.3.4- ?fade Yap?s?/Sentaks 13
2.4- Veri Tipleri 17
2.4.1- Literaller 19
2.4.2- Sabitler 19
2.4.3- Operat?rler 19
2.4.4- Sentaks Geni?letmeleri 20
3- Program Ak??? 21
3.1- Kontrol Yap?lar? 21
3.1.1- Ko?ullu Yap?lar 21
3.1.2- ?rnek E?leme 22
3.1.3- D?ngüler 23
3.2- Veri Yap?lar? 24
3.2.1- Struct 24
3.2.2- Enumeration 25
3.2.3- Tuple 26
v

B?L?M 1
Rust’a Genel Bak??
Kitap Konvansiyonlar?
Bu kitapta mümkün oldu?unca basit ve anla??l?r bir konvansiyon kullanmak iste-dim.
Bundan dolay? sadece kodlar, uyar?lar ve ?rnekler yer alacak.
Kodlar?n ve komutlar?n yaz?m stili ise ”bu ?ekilde” olacakt?r.
Uyar?lar?n yaz?m stili italik olacak ?ekildedir. ?rnekler ve kod par?ac?klar?(snip-pets)
yine kod konvansiyonu ?eklinde yaz?lacakt?r.
Nedenler ve Ama?lar
?uana kadar geli?tirilen hi?bir programlama dili bize tam manal? paralelizm,
statik tip tan?mlamas?nda kesinlik, haf?za y?netiminde ve performansta gü?lülük
sa?lamad?. Bunu yapan diller ?ok az oldu?u gibi ata olan C bize tip tan?mlama-lar?nda
zorluk ve haf?za y?netiminde gü? kayb? ya?att?. Günümüzde me?hur olan
scripting dillerine ra?men derlenebilir ve her ortamda ?al??abilmesi ?ng?rülen
di?er derlenebilir dillerden farkl?, komplex ak??lar?n uygulanabildi?i dillere ihtiya?
duyuldu. Bu dillere ?rnek olarak Haskell ve OCaml verilebilir fakat bu diller alt-seviye
dillerle aralar?nda soyut bir ayr?m oldu?u i?in dü?ük seviyeye yak?n program
yaz?m?n? zorla?t?r?yordu. Bu zorlu?u ??zebilmek ad?na C ve C++’?n ?zelliklerin-den
de al?nmas? ve harmanlanmas? gerekiyordu. Mozilla Arge’si tüm bunlar?n so-nucunda
bütün iyi ?zellikleri alan bir programlama dili olan Rust’? ortaya ??kard?.
?zellikler
Rust esnektir. En belirgin ?zelliklerinden biri de bu ?zelli?idir. Esnekli?in sebebi
tip tan?mlamalar?n?n zorunlu olmamas?d?r. Tipleri keskinle?tirip yumu?atmak ve
birbirlerine ?evrimini sa?lamak sizin elinizdedir. Belirtilen her tip tan?mlamas? ke-
6

skin tipi olu?turup d?nü?ümünü zor hale getirirken, belirtilmeyen tipler ayn? isimli
ba?ka de?i?kenlerin olu?umuna engel olmaktad?r. Bu iyi bir?eydir ve ayn? ada sahip
iki tane farkl? de?i?ken olu?turabilmenize olanak sa?lar.
Rust ayn? zamanda paralelizme ?nem verir, mesaj aktar?m? yoluyla paralel
?al??may? destekler bu hafif ve i?lemci yormayan bir sistemdir. Di?er bellek pay-la??ml?
?al??an sistemlere nazaran daha iyi bir performans? da beraberinde getirir.
Ba?ta da belirtti?imiz gibi yüksek seviyeli programlama dillerinden ?rnek
al?nan kompleks sistem dizayn?na olanak sa?layan dereceli fonksiyon tan?mlama-lar?na
izin verir. Bu Haskell ve Ocaml’?n da bir ?zelli?idir.
C’deki struct, enum ve typedef kal?plar?n? daha da gü?lendirerek sunar.
Rust bir?ok programlama dilinin uygulama bi?imlerini de kendine dahil et-mi?tir,
?rnek olarak:
? Go programlama dilinden y???n büyüme algoritmas?
? SML’in veri yap?lar?
? C#‘?n makine kodu olu?turma ve birle?tirme sekans?
? C++’?n haf?za referanslama ve destructor ?zelli?i
? Cyclone ve ML Kit’in haf?za belirleme ve s?z?nt? ?nleme sistemleri
? Haskell’in tip s?n?flar? ve d?nü?üm sistemleri
? Python’?n lexer sistemi
? Ruby’nin blok sentaks? (parantezlemesiz sistem)
Rust tamam?yla orijinal bir dil de?ildir bunun nedeni tüm dillerin en gü?lü ?zel-liklerini
alarak ar?nd?r?lm?? sentaks? ile tüm i?leri ba?arabilen bir sisteme evrilme
amac?nda olmas?d?r. Rust gelecek senelerde en gü?lü ve en kolay programlama dili
olma, sistem kontrolü, paralelizm ve hata toleransl? sistemlerin ?ekirde?inde rol ala-cak
bir arac? olma misyonunu yüklenerek en iyi yere gelmeyi planlamaktad?r.
7

B?L?M 2
Rust’?n Temelleri
Kurulum
Par?alar ve ?n?aa Sistemi ?nbilgisi
Kurulum ü? ?al??t?r?labilir ve kütüphanelerden olu?maktad?r. Bunlar:
? rustc (Rust Derleyicisi)
? rustdoc (Rust Dokümantasyon Olu?turucu)
? cargo (Rust Paket Y?neticisi)
? librustllvm, librustrt, libcore, libstd, librustc, libsyntax ve libmorestack
kütüphaneleri (sistem olu?turulurken kullan?lan di?er kütüphaneler ?nceden
yaz?lm?? a??k kaynak kütüphanelerdir)
?n?aa sistemi 3 fazdan olu?maktad?r her bir derleyici faz? kendinden sonraki der-leyici
faz?n? yapacak ?ekilde düzenlenmi?tir. Faz.3 derleyicisi son derleyiciyi
yapt???nda(kendini) Faz.2 ile birebir ayn? bir imaj olu?turur(kendini yapan ile).
Bütün bu i?lemlere ?n-ayak olan ise bir ?nceki rust derleyicisi versiyonun son der-leyicisidir.
Bu derleyici yeni sistemin Faz.0‘?d?r.
??letim Sistemine Kurulum
?Windows
E?er Windows kullan?yorsan?z sisteminize s?ras?yla
? MinGW ve MSYS paketi (versiyon numaras? 20110802 olmak üzere)
? MsysGit (Kurduktan sonra MinGW kurulum dizinindeki .bashrc dosy-as?na
a?a??daki sat?r? ekleyin
8

export PATH=$PATH:/c/Program Files/Git/bin
ve kaydedin.
? libpthread kütüphanesini kurun versiyon numaras? 2.8.0-3
(libpthread-2.8.0-3-mingw32-dll-2.tar.lzma)
tüm bu yaz?l?mlar? sisteminize kurduktan sonra http://www.rust-lang.org/ ad-resindeki
yükleyici’yi indirmelisiniz. Bu paket haz?r derlenmi? ve kullan?ma haz?r
win32 ?al??t?r?labilirlerini ve kütüphanelerini i?ermektedir. Kurulum s?ras?nda
PATH ortam de?i?kenine Rust’? ekle se?ene?inin i?aretli oldu?undan emin olun.
Kurulum tamamland???nda art?k Rust’? kullanabilir durumda olacaks?n?z.
?*NIX türevleri ve Linux
E?er *NIX türevi (buna MacOS’da dahil olmak üzere) veya Linux da??t?mlar?n-dan
birini kullan?yorsan?z
? g++ 4.4 veya clang++ 3.x serisi
? python 2.6 veya sonraki bir sürüm (fakat 3.x serisi olmamak kayd? ile)
? perl 5.0 veya daha sonraki bir sürüm
? gnu make 3.81 veya daha sonraki bir sürüm
? curl
yaz?l?mlar?n?n sisteminizde yüklü oldu?undan emin olun. Tüm bu gereksinimler-den
emin olduktan sonra Rust’? derlemek ?u ?ekildedir:
$ wget http://dl.rust-lang.org/dist/rust-0.4.tar.gz
$ tar -xzf rust-0.4.tar.gz
$ cd rust-0.4
$ ./configure
$ make && make install
Benim yazd???m zamanda Rust derleyicisinin versiyonu 0.4’tü, ?imdi yenilenmi?
olabilir güncel kaynak kodu yine Rust’?n kendi sitesinde bulabilirsiniz.
9

Edit?r ve Geli?tirme Ortamlar?
Rust kodu yazabilmek i?in ?e?itli edit?rler ve destekler mevcuttur. Bunlara ?r-nek
vermek gerekirse Eclipse geli?tirme ortam?, TextMate edit?rü, Vim ve Emacs
edit?rleri verilebilir.
? TextMate i?in destek paketi: Rust.tmbundle
? Eclipse plugin deste?i: Oxide
? Emacs ve Vim i?in destek ise rust’?n kendi kaynak kodunda src/etc dizini
alt?nda bulunmaktad?r.
? Sublime Text 2 i?in Sublime Package Manager yoluyla Rust deste?i yüklene-bilir.
? KDE’nin edit?rü Kate i?in ise yine kaynak kodun src/etc/kate dizini alt?nda
deste?ini bulabilirsiniz.
Rust daha ?ok yeni bir dil oldu?undan dolay? tam anlam?yla ba??ms?z bir IDE
geli?tirilmedi. ?imdilik elimizdeki edit?r ve destek miktar?n?n bu kadar oldu?unu
belirtmekle yetinelim. Geli?tirmeler olduk?a kitab?n yeni revizyonlar?nda bunlar?
belirtece?im.
?lk Ad?mlar
Rust genel olarak veri yap?lar?nda C’den farkl? de?ildir, tiplerin tamam? C’nin
birebir kopyas?d?r fakat baz? tipler üzerinde fazlaca ?al???lm?? ayr?ca ba?ka tiplerde
ekleme yap?lm??t?r, Rust’? anlat?rken ?o?u zaman C ile kar??la?t?raca??z. Rust pro-gramlar?
.rs dosya uzant?s?n? kullan?rlar, .rc uzant?s? ise Crate denilen ba??ms?z
derleme birimlerinin ?zelliklerini belirten dosyalard?r. ?imdilik bunlara de?inme-den
sadece bir dosyadan olu?an ?al??t?r?labilirleri anlataca??z.
?lk program?m?z klasik bir Merhaba Dünya olup helloworld.rs isimli bir
dosya a?arak:
fn main() {
io::println("Merhaba Dünya! Rust’a ho?geldin!");
}
10

metnini kaydediyoruz. Rust derleyicisini sisteminize ba?ar? ile yüklediyseniz
rustc helloworld.rs
komutunu verdi?inizde size e?er *nix sistem üzerinde iseniz helloworld isimli
bir ?al??t?r?labilir olu?turulacakt?r(e?er windows üzerinde iseniz bu ?al??t?r?labilirin
ad? helloworld.exe olur). ?al??t?rd???n?zda ise
Merhaba Dünya! Rust’a ho?geldin!
??kt?s?n? al?rs?n?z. Rust e?er ?al??t?r?labilir olu?turulacaksa C’deki gibi bir main
fonksiyonuna ihtiya? duyar, ayn? zamanda e?er kütüphanelerinde bulunmayan bir
fonksiyonla kar??la??rsa hata mesaj?n? en dar ?ekilde vererek deterministik bir hata
??kt?s? verir. ?imdi kodumuzu biraz de?i?tirerek ?u hale getirelim
fn main() {
io::bu_sat?r?_bas("Merhaba Dünya! Rust’a
ho?geldin!");
}
derleyip ?al??t?rd???m?zda ise kar??m?za ?u mesaj ??kacakt?r
helloworld.rs:2:4: 2:21 error: unresolved name: io::bu_sat?r?_bas
helloworld.rs:2 io::bu_sat?r?_bas("Merhaba Dünya! Rust’a ho?geldin!");
"" ^~~~~~~~~~~~~~~~~
error: aborting due to previous error
Bu hatan?n sebebi ise bu_sat?r?_bas isimli bir fonksiyonun olmamas?d?r.
De?i?kenler
Rust’ta de?i?kenler ba?ta bahsetti?imiz gibi tip tan?mlamas?na ba?l? ?ekilde ad-land?r?l?p
haf?zada yer edinirler. Rust’ta de?i?kenler iki tiptir mutable(de?i?ebilen)
ve immutable(de?i?meyen) de?i?kenler.
Immutable(De?i?mez) De?i?kenler
E?er tipini Rust’?n belirlemesini istedi?iniz ve de?i?mez olmas?n? istedi?iniz bir
de?i?ken varsa tan?mlama ?u ?ekildedir:
11

let merhaba = "merhabalar"
Rust’ta de?i?kenler varsay?lan olarak manipüle edilemez haldedir. Nas?l oluyor da de?i?ken
oluyorlar? sorusunun cevab? ise dilin olu?turulma amac?na bir referans niteli?inde-dir
Güvenli thread olu?umu(Thread-safe) ?zelli?i bu yetenekten ileri gelir.
Mutable(De?i?en) De?i?kenler
Tan?mland?klar?nda C’deki herhangi bir s?radan lokal de?i?kenden pek farklar?
yoktur. ?u ?ekilde tan?mlan?rlar:
let mut toplam = 0;
g?rüldü?ü üzere mut keyword’ü de?i?kenin mutable olaca??n? ve de?i?ebilir
?ekilde yarat?lmas? gerekti?ini belirtmekte kullan?l?r. Mutable de?i?kenlerin kul-lan?m?na
bir ?rnek vermek gerekirse ??yle bir ?rnek verebiliriz:
fn main() {
let mut ?evrim = 0;
"while (?evrim <= 10){
"" io::println("harika");
"" ?evrim+=1;
"}
}
Tip Tan?mlamalar?
Tip tan?mlamalar?nda tip ise C’deki gibi ba?ta prefix (?nek ?eklinde) belirtil-mez.
Bunun yerine ikinoktadan sonra belirtilir. ?rnek olarak;
let karpuz: float = 57.8;
let kavun = karpuz * 10.0;
let karpuz: int = 50;
io::println(fmt!("%d", monster_size));
12

?lk de?i?ken olan karpuz kavun’u olu?turmak i?in kullan?lm??t?r. G?revi bittik-ten
sonra yeniden farkl? bir tip ile yarat?labilir. Ama bu kodu derledi?imizde bize
kavun ve karpuz’u kullanmad???m?z? s?yleyen bir uyar? gelecektir. Bu bize son kar-puzu(
integer olarak deklare etti?imiz) bir i?lemde kullanmad???m?z? ve immutable
olarak olu?turdu?umuz kavun’u da bir i?leme sokmad???m?z? s?ylemektedir. Bu
uyar?dan kurtulmak ad?na kullanmad???n?z de?i?kenlerin ba??na “_” koyman?z ye-terlidir.
Rust’ta tan?mlay?c?lar C’deki gibi alfabetik karakter veya alttan ?izgi ile ba?lar-lar
ve yine C’deki gibi numaralar, alfabetik karakterler ve alttan ?izgi kombinasyon-lar?
ile devam edebilirler. Rust’ta tan?mlay?c? yaz?m konvansiyonu ilk harfin kü?ük ol-mas?
ve gerekli yerlerde(kelimeler aras?nda vb.) alttan ?izgi kullan?lmas? üzerinedir. ?r-nek
olarak:
let yak???kl?_de?i?ken = 100;
verilebilir. Fakat yeni tip tan?mlamalar? bu konvansiyonu kullanmaz, bunun yerine
camelCasing dedi?imiz ilk harfi kü?ük sonraki her kelimenin ilk harfi büyük olma
ko?uluna uyarlar, ?rnek bir yeni tip tan?mlamas? ise ?u ?ekildedir:
type yeniBirTipTan?mlamas? = int;
Rust’ta kod yazarken Türk?e karakter kullanabilirsiniz. Bu size ta??nabilirlikte
de kullan?labilirlikte de sorun ??karmaz.
?fade Yap?s?/Sentaks
Rust kendisi de?er d?ndürebilen ve de?eri yerle?tirebilen bir yap?ya sahiptir. Bu
yap? tan?mlay?c?lar?n tekrar tekrar kullan?lmas?n? ?nlemekle beraber return key-word’ünde
bile blok yazmam?z? da sa?lamaktad?r. ?imdi C’deki bir yap?y? Rust’ta
g?sterelim.
let ?eker;
if item == "re?el" {
?eker = 3.50;
} else if item == "kek" {
13

?eker = 2.25;
} else {
?eker = 2.00;
}
Bu stil C’deki tan?mlaman?n birebir uyarlamas?d?r. Bunun yerine biz Rust’ta bu
yap?y? yazmak istesek daha güzel ve mant?ksal bir yol izleyerek;
let ?eker =
if item == "re?el" {
3.50
} else if item == "kek" {
2.25
} else {
2.00
};
bu ?ekilde tan?mlayacakt?k. Bu bize sadece atamay? de?il ayn? zamanda i?eride so-nucu
olu?turabilecek bir fonksiyonu da kullanabilmemizi sa?l?yor. Dikkat ettiyseniz
2. ?rnekte noktal?virgül s?zkonusu de?ildir son bloktaki noktal? virgül tüm blok zin-cirinin
ba?l?ba??na bir kod olarak ?al??t?r?lmas?n? tetikler, bu bize esneklikte sa?lar
ayn? zamanda ?rnek olarak 3.50 de?eri yerine 3.50 de?erini olu?turan bir fonksiyo-nun
varolabilmesi hatta bu fonksiyonun di?er durumlara da ba?l? olabilen tek para-metreli
bir fonksiyon da olabilmesi gibi. Rust i?te bu ?ekilde bizim yapabilecek-lerimizi
esneterek ve k?saltarak kolayl?k sa?lamaktad?r. Ayn? zamanda Rust i?lemci
üzerindeki bo? i?lemci vaktini paralel threadler ?al??t?rarak minimize etmektedir.
Yukar?daki ?rnekte 3.50, 2.25 ve 2.00 olarak de?er atad???m?z sat?rlar e?er “;”
ile kullan?lsalard?, ifade mekanizmas? ?al??mayacakt?. Bunun nedeni bahsetti?imiz
bloklamad?r. B?yle bir atama yine de ?al???r fakat atanma de?i?kene d?ndürülüy-orsa
nil fonksiyona d?ndürülüyorsa void olur. Bu da istedi?imiz sonucu vermez.
14

De?i?kenler i?in let, fonksiyonlar i?in fn , trait tan?mlamalar?, enumlar
ve constantlar harici dil dahilinde kalan her?ey ifade kapsam?na girmektedir.
Rust’ta ifade olmas? i?in fonksiyon i?eri?i olmak bile yeterlidir. ?rne?in;
fn d?rt_d?ndür(x: int) -> bool {
x==4
}
return ifadesine gerek duyulmadan al?nan de?er return de?eri amac?yla kullan?la-cakt?r.
E?er sat?rlar atama, binary veya unary operasyonlar i?in kullan?lm?yor ve fonksi-yonlar
kullan?l?yorsa;
let x = foo();
if x {
bar();
} else {
baz();
}
Bu ?ekilde fonksiyon sonras? “;” ifadesi kullan?larak yaz?l?rlar. Burada ?nemli olan
?u noktad?r: e?er biz bu fonksiyonlardan bir de?er d?ndürmüyorsak ve fonksiyon-lar?m?z
C’deki void fonksiyonlar gibi ise(ki bu Rust’ta nil-type’a kar??l?k gelir) her
ifade ?evriminin sonuna yukar?da belirtti?imiz gibi bir “;” konulur.
Bu durumlar “;”ün konuldu?u durumlard?r. Konulmad??? durumlar?n genel
?zelli?i ise kesin bir de?er d?ndürüp bu de?er’in nil’den farkl? oldu?u durumlar ol-maktad?r.
??te buna bir ?rnek ise:
fn bar() -> int {
"let a = 9;
"return a;
15

}
fn baz() -> int {
"return 10;
}
fn main() {
"let x = false;
"io::println(fmt!("Cevap %d",
"if x {
"bar()
"} else {
"baz()
"}));
}
G?rüldü?ü üzere bar() ve baz() de?er d?ndürdükleri i?in “;” koymuyoruz hatta
blok sonuna da koymamam?z?n nedeni println()’in onu hesaplama giri?iminde bu-lunaca??d?r.
16

Veri Tipleri
Tipler genel olarak C’deki gibidirler ve ?u ?ekilde g?sterilebilirler:
Tipler A??klama
() Bir tek de?er i?eren, Birim
bool true veya false de?erlerine sahip olan,
Kompozit tipler de genel yap?lar? itibariyle a?a??daki ?ekildedir. Burada her T
bir ba?ka tipi g?stermektedir.
Baz? tipler hi?bir zaman pointer olmadan de?i?tirilemezler. ?rne?in string ola-rak
tan?mlanm?? de?erlere ~, @ ve & i?aret?ilerinden biri kullan?lmadan eri?im
yap?lamaz. Bu kullan?ma sahip olan tipler genellikle dinamik geni?leyebilen(karak-ter,
saf veri vb. ile) tiplerdir.
17
Boolean
int, uint
?zerinde ?al??t??? makinenin
tan?mlamalar?na ba?l? i?aretli ve i?aretsiz
tamsay?lar, signed & unsigned integer
i8, i16, i32, i64 Belirli bit büyüklü?ünde i?aretli tamsay?lar,
signed sized integers
u8, u16, u32, u64 Belirli bit büyüklü?ünde i?aretsiz
tamsay?lar, unsigned sized integers
float
?zerinde ?al??t??? makinenin üzerinde
genel konvansiyonda en iyi ?al??abilecek
en büyük ondal?kl? say?, float
f32, f64 Belirli bit büyüklü?ünde ondal?kl? say?lar,
floating type
char Unicode karakter setini kullanan karakter
(32 bit)
Kompozit Tipler A??klama
[T * N] Vekt?r (Vekt?r di?er dillerdeki diziyi
temsil eder)
[mut T * N] Mutable vekt?r
(T1, T2) Tuple tipleri
&T, ~T, @T Pointer tipleri

Dinamik geni?leyen tiplere ise ?u ?rnekleri verebiliriz:
Dinamik Geni?leyen Tipler A??klama
fn(a: T1, b: T2) -> T3 Fonksiyon tipleri
str String(Katar) tipleri (UTF-8)
[T] Uzunlu?u bilinmeyen vekt?r (di?er ad?yla
Fonksiyon tiplerinde de?er d?ndürme -> i?areti ile belirtilir fonksiyon deklerasy-onunda
ise ?u ?ekildedir:
fn foo() -> bool { }
Rust’?n en güzel ?zelliklerinden biri de anlams?z veya i?inize yaramayan bir de?er
d?ndürmeniz gerekti?inde -> () ?eklinde bir yaz?m yapabilmenizdir. Bunun
yan?nda bu yaz?m yap?lmasa da olur.
Yeni tip tan?mlamalar? takmaad olarak da kullan?labilir ve ?u ?ekilde tan?m-lan?r:
type BüyükVeri = uint;
Bu tan?mlama BüyükVeri tipiyle uint tipini ayn? ba?lamda kullanabiliriz. Burada
?nemli olan k?s?m bu tan?mlamada BüyükVeri ve uint tiplerinin birbirinden ba??ms?z olduk-lar?n?
san?p d?nü?türülemeyece?ini dü?ünmektir, fakat durum b?yle de?ildir veriler birbirl-erine
d?nü?türülebilirler ?ünkü tipler saklan?rken yap?lar?na g?re saklan?r
BüyükVeri’nin ?zünde uint oldu?u bilinmektedir.
Rust’ta tiplerimizin ismen ba?lanmas?n? ve yap?sall?kla ili?ki kurmamas?n? istiy-orsak
struct ve enum anahtar kelimelerini kullanabiliriz.
18
dilim)
[mut T] Uzunlu?u bilinmeyen mutable vekt?r

Literaller
Integerlar(tamsay?) decimal, hexadecimal veya binary formatlarda yaz?labilirler.
Bu yaz?mlar?n tamam?na integral tip denir. Tüm integral tipler son ek’e sahiptir ve
literalin ?e?idini belirler. int i?in i, uint i?in u, int8 i?in i8 tipi gibi.
Literaller konulmazsa Rust fonksiyon argümanlar? ve tip tan?mlamalar?yla lit-eral
olmaks?z?n tan?mlamay? tahmin eder ve ona g?re yorumlar genellikle bu yo-rumlama
sisteme en yak?n varsay?lan üzerinedir. ?rnek olarak;
let a = 1; // a varsay?lan olarak int atan?r
let b = 10i; // b int oldu, i son ekinden dolay?
let c = 100u; // c uint oldu
let d = 1000i32;
verilebilir.
Sabitler
Derleme zaman? sabitleri const anahtar kelimesi ile tan?mlan?r.
const PAROLAM: int = 12345;
const KATAR_PAROLAM: &static/str = "12345";
const EV_PAROLAM: int = PAROLAM + 1;
Operat?rler
Aritmetik operat?rler
*, /, %, +, - (?arp, b?l, mod al, topla, ??kar) ayr?ca - unary operat?r
olup say?lar? negatif yapmakta kullan?l?r. C’deki gibi bit operat?rleri >>, <<, &, |,
ve ^ ‘dir.
! tüm bitleri ters ?evirir ve C’deki ~ operat?rü gibi.Rust’?n kar??la?t?rma oper-at?rleri
C’deki kar??la?t?rma operat?rleriyle ayn?d?r.
== , !=, <, >, <=, >=, &&, || gibi...
19

Tip d?nü?ümü yaparken Rust as operat?rünü kullan?r. ?rnek olarak
let x: float = 4.0;
let y: uint = x as uint;
assert y == 4u;
Sentaks Geni?letmeleri
Dilin saf haline entegre olmam?? ama sonradan kütüphaneler yard?m?yla dahil
edilmi? ?zelliklerdir. ?u anda std::core kütüphanesi bu geni?letmeleri yeterli
miktarda kar??lamaktad?r. C formatlamas?n?n benzer ?zellikleri kütüphaneler
yard?m?yla al?nm??t?r. Katar formatlaman?n geli?tirilmesi gündemdedir.
io::println(fmt!("%s bence %d", "cevap", 43));
io::println(fmt!("Bu nedir %?", gizli_nesne));
Yukar?daki ?rne?imizde %? tüm tipleri i?ine alabilen ve manipüle ederek for-mata
uyduran ibaredir. Dikkat ederseniz fmt!() olmadan formatlama yap?lama-maktad?r.
Bu fonksiyon ?ekirdek kütüphaneyi kullanarak formatlama yapacaksak
mecburidir. Kendi sentaks geni?letmelerinizi de yazabilirsiniz. Rust buna izin verir.
Bu geni?letmelerin genel ad? makrolard?r.
20

B?L?M 3
Program Ak???
Kontrol Yap?lar?
Ko?ullu Yap?lar
If yap?s?n? ?nceki b?lümlerde g?zden ge?irdik k?sa bir ?rnekle ?zetleyelim:
if false {
io::println("yanl?? olan k?s?m");
} else if true {
io::println("do?ru yer");
} else {
io::println("ne do?ru ne yanl??");
}
Fakat e?er her blokta de?er d?ndürülme mekanizmas? ?eklinde ?al???yorsa if
yap?s? tüm blok i?lerindeki de?erler kesinlikle ayn? tipte olmak zorundad?r. ?rnek olarak:
fn signum(x: int) -> int {
if x < 0 { -1 }
else if x > 0 { 1 }
else { return 0 }
}
21

?rnek E?leme
Rust ?rnek e?leme mekanizmas?n? di?er mekanizmalara tercih eder bundan do-lay?
?rnek e?leme mekanizmas? geli?mi?tir. match mekanizmas? C’deki
switch’in bir benzeri olabilece?i gibi return durumlar?nda d?ndürülecek se?e-neklerin
belirlenmesini sa?lamaktad?r.
match numara {
0 => io::println("s?f?r"),
1 | 2 => io::println("bir veya iki"),
3..10 => io::println("3ten 10a kadar"),
_ => io::println("geri kalan tüm durumlar")
}
C’deki gibi bir case yap?ld?ktan sonra kald??? yerden devam etmez. Bu yap?
sabittir ve sadece bir dal? yapar ve i?lemini bitirir. ( _ ) wildcard e?lemesi olarak ad-land?r?lan
ifadedir ve anlam? “en az bir e?le?me”dir. ( * ) ise “enum tan?mla-mas?nda
bir veya daha fazla e?le?me” anlam?na gelmektedir.
Kollar her zaman => i?aretiyle tan?mlanmas?na ba?lan?r.
match numara {
0 => { io::println("s?f?r") }
_ => { io::println("ba?ka bir?ey") }
}
numara de?eri 0’a e?itse “s?f?r” string’ini ekrana bast?r?rken di?er tüm girdi du-rumlar?nda
“ba?ka bir?ey” ??kt?s?n? verecektir.
match tüm kollar? arar ve tüm olas? durumlar? ko?ul üzerinden ge?irir.
match’in en ?nemli i?levlerinden biri de?i?ken isimleri ile verilerin ba?lanabilmesi-dir.
A?a??daki ?rnekte (veri1, veri2) tuple veritipine ?rnektir.
22

fn angle(vector: (float, float)) -> float {
let pi = float::consts::pi;
match vector {
(0f, y) if y < 0f => 1.5 * pi,
(0f, y) => 0.5 * pi,
(x, y) => float::atan(y / x)
}
}
De?i?kenin ismi ?rnekteki veriyle e?lenmi?tir. ?lk kolda g?rülen ve y yaz?lan
yerde bulunan veri kontrol ve manipüle edilebilir. Ayn? zamanda ü?üncü koldaki
(x, y) ?rne?i tamamen ?rnek e?lemeye y?nelik bir tuple’d?r. Her match kolu
if ile takip ediliyorsa bu if ifadesine ?rnek bek?isi denir. ?rnek bek?isi ifadenin
do?rulu?unu kontrol ettikten sonra koldaki ifadeyi yapmaya y?nelir. ?fade ister
de?er d?ndürme olsun ister bir fn d?ndürme tipine bak?larak i?lem yap?l?r, ne
oldu?una bak?lmaz.
D?ngüler
Rust’ta d?ngü yap?m? sadece while ile sa?lanabilir. Array kavram? vekt?r olarak
yer ald??? i?in vekt?r üzerinde iterasyon sadece bek?i i?eren ifadeler ile yap?labilir.
For d?ngüsü Rust i?in gelecekte planlanan bir ?zelliktir. While d?ngüsü yine C’den
?ok farkl? olmamakla birlikte a?a??daki gibidir:
let mut cake_amount = 8;
while cake_amount > 0 {
cake_amount -= 1;
}
Rust’ta while (true) ifadesi i?in geli?tirilmi? ?zel bir sentaks vard?r bu ifade
loop ‘tur. Sonsuz d?ngüyü ifade eder:
23

let mut x = 5;
loop {
x += x - 3;
if x % 5 == 0 { break; }
io::println(int::str(x));
}
Bu kod birka? say? yazd?ktan sonra 5’e b?lünebilen bir say? buldu?unda sonsuz
d?ngüden ??kacak ?ekilde yaz?lm??t?r.
Veri Yap?lar?
Struct
?lk olarak struct yap?s?yla ba?layabiliriz. Struct yap?s? C’dekine benzer bir yap?
sergilemektedir hatta haf?zada tutulma ?ekilleri ayn?d?r. Kullan?m? C’deki kullan?m
?ekliyle ayn?d?r.
struct Stack {
content: ~[int],
mut head: uint
}
Y?k?c? sentaks bir de?eri yerine tan?mlanm?? ba?ka bir de?i?kenle manipüle etmektir. Daha ?nce
de bahsetti?imiz y?k?c? yap? structlar i?in de kullan?labilir. ?rne?in;
match Noktam {
Nokta { x: 0.0, y: yy } => {
io::println(yy.to_str());}
Nokta { x: xx, y: yy } => {
io::println(xx.to_str() + " " + yy.to_str()); }
24

}
Enumeration
Enumlar birden fazla ?ekilde g?sterilebilirler. En basit g?sterimlerinden biri;
enum ?ekil {
Daire(Point, float),
Dikd?rtgen(Point, Point)
}
?eklindedir. Argüman olarak atama yap?labildi?i gibi s?radan C enumlar? gibi
kendi i?lerinde büyükten kü?ü?e indeks s?ralamas? yapan enumlar da vard?r. ?r-nek
olarak:
enum Y?n {
Kuzey,
Güney,
Do?u,
Bat?
}
Kuzey 0, Güney 1, Do?u 2 ve Bat? 3 de?erini almaktad?r. Fakat di?er atamal?
enumlarda bu tan?mlama ge?erli olmay?p her belirtme atamaya g?re yap?l?r.
Dereferans(deref) i?lemi de bir unary operat?r olup enumlar üzerinde i?erisin-deki
de?eri almalar?n? sa?lamaktad?r.
enum Ses { Ses (int) }
let ses_seviyesi: Ses = Ses(10);
let anl?k_ses_seviyesi: int = *ses_seviyesi;
Ba?ka bir i?erikten bilgi al?nmas? bu ?ekilde sa?lanabilir.
25

Enumlar ayn? zamanda ?rnek e?lemede de kullan?labilirler:
fn bu_noktadan_tarif(dir: Y?n) -> Nokta {
match dir {
Kuzey => Point {x: 0f, y: 1f},
Do?u => Point {x: 1f, y: 0f},
Güney => Point {x: 0f, y: -1f},
Bat? => Point {x: -1f, y: 0f}
}
}
Tuple
Rust’ta tuplelar enumlar gibi ?al???r dakat enumlar gibi alanadlar? yoktur.
Argümanla?t?rma i?lemi yap?l?r fakat bu i?lemde 0 veya 1 argüman olarak verilemez. Enumda
bu yap?l?rken tuple da bu yap?lamaz. ?rnek bir tuple ise ?u ?ekildedir:
let mytup: (int, int, float) = (10, 20, 30.0);
match mytup {
(a, b, c) => log(info, a + b + (c as int))
}
Rust’a dair 0.4 versiyonuyla kesinle?mi? ve temele oturmu? ?zellikler ve yap?lar
bunlard?r. Traitler, yeni d?ngüler, REPL(read evaluate print loop), Exception
mekanizmas? gibi ?zellikler yeni yeni geli?tirilmektedir. Ayr?ca fonksiyonlar?n safl???
ve saf olmamalar? ve bu safl?k yap?s?n?n nas?l olmas? gerekti?i hakk?nda hala bir
tak?m belirlenmemi? k?s?mlar vard?r.
26

狠狠撸

Rust'a Giri? v1

Recommended

More Related Content

What's hot (20)

Similar to Rust'a Giri? v1 (20)

Rust'a Giri? v1