08.05.2015
Serdar Doğruyol
Lead Backend Developer at Protel, Rubyist, Rustacean
Twitter: @sdogruyol
Github: www.github.com/sdogruyol
Blog: www.serdardogruyol.com
15 Mayıs
1.0.0
fn main() {
println!("Hello, world!");
}
rustc hello.rs
./main # or main.exe for windows
Çalıştıralım
fn main() {
let x = 5; // Type inference
let y: i32 = 10; // Type specified
let (a, b) = (1, 2); // Pattern Matching
}
Değişkenler default olarak immutable
fn main() {
let x = 5;
x = 10;
}
error: re-assignment of immutable variable `x`
x = 10;
^~~~~~~
Derlemeye çalıştığınızda compile time hatası alırsınız
Mutable yapmak için
fn main() {
let mut x = 5;
x = 10;
}
fn main() {
}
main fonksiyonu her Rust programında var
fn print_sum(x: i32, y: i32) {
println!("sum is: {}", x + y);
}
fn add_one(x: i32) -> i32 {
x + 1
}
Fonksiyon parametlerinde tip olmak zorunda
Dönüş tipi -> şeklinde belirtilir
let x = 5;
if x == 5 {
println!("x is five!");
} else {
println!("x is not five :(");
}
let x = 5;
let y = if x == 5 {
10
} else {
15
};
Tipik bir programlama dilinde olduğu gibi
Hatta şu şekilde yazılabilir.
let x = 5;
let y = if x == 5 { 10 } else { 15 }; // y: i32
Aslında If bir expression ( Ruby gibi)
for x in 0..10 {
println!("{}", x); // x: i32
}
for var in expression {
code
}
Dinamik bir programlama diline benziyor.
Şart bir expression olabilir
let mut x = 5; // mut x: u32
let mut done = false; // mut done: bool
while !done {
x += x - 3;
println!("{}", x);
if x % 5 == 0 {
done = true;
}
}
let mut x = 5;
loop {
x += x - 3;
println!("{}", x);
if x % 5 == 0 { break; }
}
struct Point {
x: i32,
y: i32,
}
fn main() {
let origin = Point { x: 0, y: 0 }; // origin: Point
println!("The origin is at ({}, {})", origin.x, origin.y);
}
C'deki ile benzer.
Kompleks veri yapılarını Struct sayesinde modelliyoruz.
{
int *x = malloc(sizeof(int));
// we can now do stuff with our handle x
*x = 5;
free(x);
}
{
let x = Box::new(5);
}
Rust
C
Rust bizim için memory alloc ve dealloc işini hallediyor. Dolayısı ile unutma ihtimalimiz sıfır.
fn main() {
let x = Box::new(5);
add_one(x);
println!("{}", x);
}
fn add_one(mut num: Box<i32>) {
*num += 1;
}
error: use of moved value: `x`
println!("{}", x);
^
Peki nasıl çözeceğiz?
Compiler derlememize izin vermiyor.
fn main() {
let x = Box::new(5);
let y = add_one(x);
println!("{}", y);
}
fn add_one(mut num: Box<i32>) -> Box<i32> {
*num += 1;
num
}
Ownership geri veriliyor
fn main() {
let mut x = 5;
add_one(&mut x);
println!("{}", x);
}
fn add_one(num: &mut i32) {
*num += 1;
}
Box oluşturulmadan değer fonksiyona ödünç veriliyor ve çalışma bittikten sonra geri veriliyor.
SEGFAULT
fn add_one(num: &mut i32) {
*num += 1;
}
fn add_one<'a>(num: &'a mut i32) {
*num += 1;
}
Lifetime elision
struct Foo<'a> {
x: &'a i32,
}
fn main() {
let y = &5;
let f = Foo { x: y };
println!("{}", f.x);
}
Struct with Lifetime
struct Foo<'a> {
x: &'a i32,
}
fn main() {
let x; // -+ x goes into scope
// |
{ // |
let y = &5; // ---+ y goes into scope
let f = Foo { x: y }; // ---+ f goes into scope
x = &f.x; // | | error here
} // ---+ f and y go out of scope
// |
println!("{}", x); // |
}
Compile time error
Each elided lifetime in a function's arguments becomes a distinct lifetime parameter.
If there is exactly one input lifetime, elided or not, that lifetime is assigned to all elided lifetimes in the return values of that function.
If there are multiple input lifetimes, but one of them is &self or &mut self, the lifetime of self is assigned to all elided output lifetimes.
struct Car {
name: String,
}
struct Wheel {
size: i32,
owner: Car,
}
fn main() {
let car = Car { name: "DeLorean".to_string() };
for _ in 0..4 {
Wheel { size: 360, owner: car };
}
}
error: use of moved value: `car`
Wheel { size: 360, owner: car };
^~~
note: `car` moved here because it has type `Car`, which is non-copyable
Wheel { size: 360, owner: car };
use std::rc::Rc;
struct Car {
name: String,
}
struct Wheel {
size: i32,
owner: Rc<Car>,
}
fn main() {
let car = Car { name: "DeLorean".to_string() };
let car_owner = Rc::new(car);
for _ in 0..4 {
Wheel { size: 360, owner: car_owner.clone() };
}
}
Lifetime
Generics
Traits
Macros
Unsafe
Inline Assembly