Rust

Въведение Rust? TDD Памет ООП Заключение
Rust
за практичния програмист
Петко Борджуков
PlovdivConf
6 юли 2013 г.

За лектора
Петко

За лектора
Петко
занимава се с Ruby и Rails

За лектора
Петко
@ignisf

За лектора
Петко
@ignisf
http://gplus.to/ignisf

За лектора
Петко
@ignisf
http://gplus.to/ignisf
https://github.com/ignisf

Кратката история на Rust

Започнат през 2006 г. като личен проект на Грейдън
Хауър, служител на Mozilla

Mozilla се включва през 2009 г.

Първа алфа на компилатора през януари 2012 г.

Версия 0.7 – преди няколко дни

Версия 0.7 – преди няколко дни
Стабилна версия – до края на годината

Парадигми

Парадигми
Компилируем

Парадигми
Функционален (горе-долу)

Парадигми
Конкурентен (по модела на актьорите)

Парадигми
Императивно-процедурен

Парадигми
Императивно-процедурен
Обектно ориентиран

Фокус върху

Type safety

Type safety
Memory safety

Type safety
Memory safety
Concurrency

Type safety
Memory safety
Concurrency
Performance

Практична функционалност от по-високо ниво

Type inferrence

Type inferrence
Safe task-based concurrency

Type inferrence
Функции от по-висок ред

Type inferrence
Функции от по-висок ред
Полиморфизъм

Защо да се интересуваме от Rust?
Какво е кофти в Ruby?

Конкурентността

Конкурентността!!1

Гаранциите за сигурност

Много променливи състояния

Бавен е

Бавен е
Сложен е (семантиката на Smalltalk се събира на листче)

Какво е яко в Ruby?

Блоковете

Блоковете
Тове, че е функционален

Блоковете
Синтаксисът е горе-долу лесен

Блоковете
Прави разработчиците щастливи.

Блоковете
Програмира се бързо с него

Блоковете
Програмира се бързо с него
Динамично типизиран е

Популярният пример

Hello World
fn main () {
println("hello?");
}

Hello World
fn main () {
println("hello?");
}
Прилича ли ви на нещо познато?

Още познати неща

Parallel Hello World
fn main ( ) {
for 1 0 . t i m e s {
do spawn {
l e t greeting_message = " Hello ? " ;
p r i n t l n ( greeting_message ) ;
}
}
}

Parallel Hello World
fn main ( ) {
for 1 0 . t i m e s {
do spawn {
l e t greeting_message = " Hello ? " ;
p r i n t l n ( greeting_message ) ;
}
}
}
Познато?
1 0 . t i m e s do
Thread . new do
greeting_message = " Hello ? "
puts greeting_message
end
end

Приличия между Ruby и Rust
Променливите са в snake_case

Имаме блокове, които използват {}

Въпреки че промеливите са статични типизирани, имаме
type inferrence, така че няма нужда да декларираме типове

Въпреки че промеливите са статични типизирани, имаме
type inferrence, така че няма нужда да декларираме типове
Ще видим още прилики по-нататък

Различия между Ruby и Rust
; (почти) навсякъде

Нямаме блокове, които използват do и end

Малко по-различен синтаксис за дефиниране на функция:
fn вместо def

fn вместо def
Понеже нямаме do и end, използваме {} навсякъде

fn вместо def
Компилаторът ни се кара повече, ако сгрешим

fn вместо def
При писане на Rust трябва да се следва PEP8 Style Guide

fn вместо def
ВСИЧКО е immutable по подразбиране.

fn вместо def
ВСИЧКО е immutable по подразбиране. Да, дори
променливите

Фреймуърк за тестване
В Rust има вграден прост фреймуърк за писане на unit тестове.

Не е RSpec, но хайде да не бъдем претенциозни...

Не е RSpec, но хайде да не бъдем претенциозни...
testing.rs
#[test]
fn this_tests_code () {
println("")
}

След това компилираме тестовете и ги пускаме с командата
$ rustc --test testing.rs
$ ./ testing

След това компилираме тестовете и ги пускаме с командата
$ rustc --test testing.rs
$ ./ testing
На екрана ще се изведе нещо такова:
$ ./ testing
running 1 test
test this_tests_code ... ok
result: ok. 1 passed; 0 failed; 0 ignored
$

Управление на паметта
Спорно най-голямото преимущество на Rust

Както и най-сложното за овладяване

Rust e garbage collected

Rust e garbage collected
Aко искаме да е

Инструменти за управление на паметта
Три вида указатели

Управлявани кутии (Managed boxes): let x = @10;

Собствени кутии (Owned boxes): let x = ∼ 10;

Указатели на заем (Borrowed pointers): Означават се с &

Указатели на заем (Borrowed pointers): Означават се с &
Небезопасни блокове и функции

Структури

Структури
Структурите се използват за
”
пакетиране“ на стойности:

Структури
Структурите се използват за
”
пакетиране“ на стойности:
Структура
struct Monster {
health: int ,
attack: int
}
fn main () {
let m = Monster { health: 10, attack: 20 };
println(int:: to_str(m.health ));
println(int:: to_str(m.attack ));
}

Когато компилираме и изпълним предния код, на екранът ще
се изведе:
$ rust run dwemthysarray.rs
10
20
$

се изведе:
10
20
$
Ако пък подадем структурата на fmt!, използвайки формата
%?:

се изведе:
10
20
$
%?:
{health: 10, attack: 20}
$

се изведе:
10
20
$
%?:
{health: 10, attack: 20}
$
Яко!

Методи
Методите, са функции, които приемат първи аргумент с име
self.

Методи
self. Python anyone?

Методи
self. Python anyone?
Имплементация на метод
struct Monster {
h e a l t h : int ,
a t t a c k : int
}
impl Monster {
fn a t t a c k (& s e l f ) {
p r i n t l n ( fmt ! ( " The ␣ m o n s t e r ␣ a t t a c k s ␣ for ␣ % d ␣ damage . " , s e l f . a t t a c k ) ) ;
}
}
fn main ( ) {
l e t m = Monster { h e a l t h : 10 , a t t a c k : 20 } ;
m. a t t a c k ( ) ;
}

Методи
Това ще ни върне
The monster attacks for 20 damage.
$

Асоциирани функции

Аналог на класовите методи в Ruby и статичните методи в
Ява.

Ява.
Дефинираме ги като метод, само че без self за първи
аргумент.

Ява.
Дефинираме ги като метод, само че без self за първи
аргумент.
Асоциирана функция
impl Monster {
fn count () {
println("There␣are␣lots␣of␣monsters.");
}
}

Асоциираните функции намират приложение при
имплементирането на конструктор в Rust.

Асоциираните функции намират приложение при
имплементирането на конструктор в Rust.
Конструктор
struct Monster {
h e a l t h : int ,
a t t a c k : int
}
impl Monster {
fn a t t a c k (& s e l f ) {
p r i n t l n ( fmt ! ( " The ␣ m o n s t e r ␣ a t t a c k s ␣ for ␣ % d ␣ damage . " , s e l f . a t t a c k ) ) ;
}
fn new ( h e a l t h : int , a t t a c k : int ) −> Monster {
Monster { h e a l t h : h e a l t h , a t t a c k : a t t a c k }
}
}
fn main ( ) {
Monster : : new (20 , 4 0 ) . a t t a c k ( ) ;
}

Типажи и обобщения (Traits & Generics)
Нещо средно между миксин и интерфейс.

Нещо средно между миксин и интерфейс. Абстрактен
клас?

Нещо средно между миксин и интерфейс. Абстрактен
клас?
Чрез тях се постига полиморфизъм в Rust

Лирическо отклонение
Аналогът на списъците в Ruby в Rust са векторите.
Не са хетерогенни като в Ruby

Immutable по подразбиране като всичко останало

Дефинирани са им алгебрични оператори като в Ruby

Дефинирани са им алгебрични оператори като в Ruby
Вектори
fn main () {
l e t your_numbers = @[ 1 , 2 , 3 ] ;
l e t my_numbers = @[ 4 , 5 , 6 ] ;
l e t our_numbers = your_numbers + my_numbers ;
p r i n t l n ( fmt ! ( "The␣third␣number␣is␣%d." ,
our_numbers [ 2 ] ) )
}

Trait
fn print_vec <T: ToStr >(v: &[T]) {
for v.each |&i| {
println(i.to_str ())
}
}
fn main () {
let vec = [1,2,3];
print_vec(vec);
let str_vec = [~"hey", ~"there", ~"yo"];
print_vec(str_vec );
}

Operator Overloading
Едно време ми се наложи да рисувам ето тази красота:

Operator Overloading
Едно време ми се наложи да рисувам ето тази красота:
Нарича се
”
Аполониева гарнитура“ и е фрактал.

Сега няма да се плашите.

Центровете и радиусите на окръжностите се изчисляват с
теоремата на Декарт.

Нека центъра на окръжност zj е комплексно число (т.е.
zj = xj + i yj ).

zj = xj + i yj ).
Нека кривата kj е реципрочното число на дължината на
радиуса на окръжността.

zj = xj + i yj ).
Нека кривата kj е реципрочното число на дължината на
радиуса на окръжността.
Тогава центъра на допираща се до четири други окръжности
окръжност намираме така:
Следствие от комплексната декартова теорема
z4 =
2(zmkm + z2k2 + z3k3) − z1k1
k4

Фракталите с окръжности са ГАДНИ.

Фракталите с окръжности са ГАДНИ.
Сериозно.

Бях млад и глупав и реших да имплементирам предната
формула на Java.

Сега вече не съм толкова млад.

Ето какво се получи:

Java
public static Complex getDaughterCenter ( S o d d y C i r c l e m, S o d d y C i r c l e a1 ,
S o d d y C i r c l e a2 , S o d d y C i r c l e a3 , double k ){
Complex z = m. z ( ) . m u l t i p l y (m. k )
. add ( a2 . z ( ) . m u l t i p l y ( a2 . k ) )
. m u l t i p l y ( 2 )
. s u b t r a c t ( a1 . z ( ) . m u l t i p l y ( a1 . k ) )
. d i v i d e ( new Complex ( k , 0 ) ) ;
return z ;
}

Java
. m u l t i p l y ( 2 )
return z ;
}
Приоритетът на операциите е пълна боза.

Java
. m u l t i p l y ( 2 )
return z ;
}
Приоритетът на операциите е пълна боза.
Освен това... .add(), .multipy(), .divide()...

Ето как може да стане на Rust:

Rust
fn get_daughter_center (m: C i r c l e , a1 : C i r c l e , a2 : C i r c l e ,
a3 : C i r c l e , k : float ) −> Cmplx<float> {
l e t ( p , q ) = (~Cmplx : : new ( 2 . 0 , 0 . 0 ) , ~Cmplx : : new ( k , 0 . 0 ) ) ;
( (m. z ∗ m. k + a2 . z ∗ a2 . k + a3 . z ∗ a3 . k ) ∗ ∗p − a1 . z ∗ a1 . k ) / ∗q
}

Rust
fn get_daughter_center (m: C i r c l e , a1 : C i r c l e , a2 : C i r c l e ,
a3 : C i r c l e , k : float ) −> Cmplx<float> {
l e t ( p , q ) = (~Cmplx : : new ( 2 . 0 , 0 . 0 ) , ~Cmplx : : new ( k , 0 . 0 ) ) ;
( (m. z ∗ m. k + a2 . z ∗ a2 . k + a3 . z ∗ a3 . k ) ∗ ∗p − a1 . z ∗ a1 . k ) / ∗q
}
Пак е рунтаво, но е далеч по-четимо и по-лесно за дебъг от
предишното.

Заключение

БЛАГОДАРЯ!

Rust

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

Rust