[01:24:03] <valexey_> fn main() {
let x: bool = true;
let x = 34; // type isize
let x = 34u; // type usize
let x: u8 = 34u8;
let x = 34i64;
let x = 34f32;
}
[01:24:07] <valexey_> раст такой раст...
[01:24:16] <valexey_> это легальный код, если что
[01:24:33] <valexey_> "As a side note, Rust lets you redefine variables so the above code is legal - each let statement creates a new variable x and hides the previous one."
[01:26:48] <END> Ну это ж раст. На что ты надеялся?
[01:27:39] <valexey_> Это ж ocaml :-)
[01:27:45] <valexey_> там та же фигня
[01:28:04] <valexey_> ну и вообще, это характерно для языка заточенного изначально под REPL, как ocaml вот
[01:28:15] <valexey_> а Rust это сместь окамла с плюсами
[01:29:09] <valexey_> ну, посмотрим насколько это опасная штука
[01:29:48] <END> Разве МЛ такие штоки разрешал?
[01:29:59] <END> Штуки
[01:30:12] <valexey_> да, конечно
[01:30:16] <valexey_> len x = 10
[01:30:21] <valexey_> let x = "hello world"
[01:30:23] <valexey_> легко
[01:30:31] <valexey_> ой
[01:30:37] <valexey_> let конечно в обоих случаях
[01:31:00] <valexey_> замечу, что тут нет никакой динамической типизации, если что. ни в расте ни в камле
[01:32:53] <END> Мне казалось, что в ML переменная - это константа. Если ты понимаешь о чем я.
[01:33:41] <valexey_> дык и в расте тоже константа
[01:33:51] <valexey_> immutable
[01:34:28] <valexey_> let x = something; // не меняет значение, но создает новую x, которая скрывает предыдущую
[01:34:34] <valexey_> "As a side note, Rust lets you redefine variables so the above code is legal - each let statement creates a new variable x and hides the previous one."
[01:34:40] <valexey_> это так и в ocaml и в rust
[01:35:41] <END> На стеке новое значение?
[01:35:59] <END> ... появляется
[01:40:33] <valexey_> ну, в данном случае - да
[01:40:48] <valexey_> но компилятор может соптимизировать, если увидит, что предыдущее значение никому уже нинужно
[01:41:08] <valexey_> (оно может быть нужно, если кто-то захватил его в свой контекст)
[01:46:53] <valexey_> let x = 42;
x = 13
error[E0384]: re-assignment of immutable variable `x`
--> src/main.rs:8:5
|
7 | let x = 42;
| - first assignment to `x`
8 | x = 13
| ^^^^^^ re-assignment of immutable variable
[01:46:59] <NEW> ты просто балуешься или у тебя проект на расте?
[01:47:12] <valexey_> пока просто балуюсь/щупаю язык
[01:47:31] <valexey_> цель - понять насколько оно вообще имеет смысл
[01:47:48] <valexey_> в плане производительность и надежности
[01:48:00] <valexey_> ну и очень хочется сравнить это дело с С++ (естественно) и с Адой
[01:48:49] <valexey_> Больше языков, заточенных одновременно и на надежность и напроизводительность, кажется и нет.
[01:49:25] <valexey_> по работе у меня сейчас с++11
[01:52:38] <valexey_> хм. забавно. вот первые серьезные отличия в семантике от плюсов и любых других ЯП:
[01:52:40] <valexey_> let y = Box::new(42);
let mut x = Box::new(75);
x = y;
*x = 43;
println!("{}", *y);
[01:53:01] <valexey_> error[E0382]: use of moved value: `*y`
--> src/main.rs:11:20
|
9 | x = y;
| - value moved here
10 | *x = 43;
11 | println!("{}", *y);
| ^^ value used here after move
|
= note: move occurs because `y` has type `std::boxed::Box<i32>`, which does not implement the `Copy` trait
[01:54:53] <NEW> Почему ошибка?
[01:55:29] <NEW> x = y перезаписала указатель?
[01:55:35] <valexey_> потому, что y это Unique pointer
[01:55:42] <valexey_> а мы его мувнули в x
[01:55:55] <valexey_> и все, y больше не валиден. и тут это проверяется на этапе компиляции
[01:56:07] <NEW> Тогда почему ошибка при выводе, а не при присваивании?
[01:56:21] <valexey_> дык присвоить то как раз можно. это валидно
[01:56:29] <valexey_> более того, его и вернуть можно
[01:56:39] <valexey_> в общем, это очень круто, как по мне.
[01:57:26] <NEW> Предвкушаю спокойные тихие ночи и неспешную отладку кода хотя бы в два раза больше этого.
[01:58:29] <valexey_> хм. а чего его отлаживать, если ошибка на этапе компиляции.
[01:58:38] <valexey_> а не на этапе исполнения
[01:58:39] <NEW> Зачем восклицательный знак, кстати?
[01:58:56] <valexey_> восклицательный знак означает, что println! это макрос
[01:59:03] <NEW> ну не отлаживать, а искать, почему не компилится.
[01:59:14] <valexey_> (нет, этот макрос ничего общего с сишными макросами не имеет)
[01:59:29] <valexey_> да не, это линейные типы, тут еще все просто :-)
[01:59:40] <valexey_> в плюсах вот тоже unique_ptr есть
[01:59:49] <valexey_> только там бы был UB в этом месте :-)
[02:00:00] <NEW> я подумал про макросы, тело которых подменяет его название на этапе компиляции. Оно в расте не так работает?
[02:00:37] <NEW> непонятно сказал
[02:00:54] <valexey_> не, оно на этапе компиляции (макрос этот) проверяет типы поданых аргументов и выдает ошибку если что не так, ну и вызывает генерит нужный код для вывода в консоль
[02:01:20] <NEW> имя макроса, встретившееся в коде, на этапе компиляции подменяется телом.
[02:01:20] <valexey_> то есть тут макрос - это ближе к плагину для компилятора нежели к тупо текстовой подстановке хз чего в хз что
[02:01:58] <valexey_> но до макросов я еще не дошел, как видишь :-)
[02:02:02] <valexey_> у меня пока линейные типы
[02:05:11] <valexey_> и да, лучше такие ошибки компиляции, чем UB или даже сработавший ASSERT в рантайме
[02:11:13] <valexey_> вообще, растовые статьи и книги, где сравнивают раст с С++ читать приятно так как видно, что автор ЗНАЕТ С++
[02:11:19] <valexey_> причем глубоко знает
[02:11:48] <valexey_> А не так как в книжках по Аде например, где в первом же примере кода на С++ сразу ошибка.
[02:12:18] <valexey_> хотя книжка эта - Ada for C++ or java programmers
[02:12:35] <NEW> ошибки компиляции лучше, чем непонятно что при работе. Но ещё лучше, когда ошибки компиляции указывают на место ошибки.
[02:12:51] <valexey_> дык оно и указывает на место ошибки
[02:13:03] <valexey_> ты попытался обратиться к переменной которой больше нет. это и есть ошибка
[02:13:20] <NEW> нет. Я говорю, что лучше бы оно указывало на место, где сделана ошибка.
[02:13:24] <valexey_> точнее - к невалидному указателю обратиться
[02:13:32] <valexey_> дык там до того нет ошибки ни одной
[02:13:45] <valexey_> ошибка - println!("{}", *y);
[02:13:47] <valexey_> вот это
[02:13:53] <valexey_> до того ошибок в коде НЕТ
[02:13:57] <NEW> в этом куске кода ошибка в x = y
[02:14:04] <valexey_> это не ошибка
[02:14:16] <NEW> тогда почему не печатается : )
[02:14:38] <valexey_> потому, что писать надо println!("{}", *x);
[02:14:40] <valexey_> :-)
[02:15:10] <NEW> чё за галимые отмазы : )
[02:15:57] <NEW> а если бы не было строки x = y, то всё равно при print была бы ошибка компиляции?
[02:16:46] <valexey_> нет, не было бы
[02:16:58] <NEW> кстати, а почему y удалена?
[02:17:20] <valexey_> ну вот смотри:
потому, что x = y; при том, что x и y это unique pointers
[02:17:51] <NEW> а, понял. Такой указатель может храниться только в одной переменной.
[02:17:55] <valexey_> да
[02:18:03] <valexey_> только один владелец
[02:18:31] <valexey_> /me явственно слышит ехидные замечания info21 на тему языков без GC
[02:18:55] <NEW> а что такое mut?
[02:20:06] <valexey_> mutable
[02:20:23] <NEW> а, значение y нельзя изменять, а значение x можно.
[02:20:28] <valexey_> да
[02:20:42] <valexey_> по умолчанию все в расте immutable, как и в ocaml
[02:21:01] <NEW> то есть, не значения, а переменные.
[02:21:33] <NEW> значения, как я вижу всегда можно менять, если они хранятся в соответствующей переменной
[02:21:50] <valexey_> эмм.. в смысле?
[02:22:07] <NEW> x = y
[02:22:31] <valexey_> ну если у тебя указатель mut, то и объект/переменную на которую указатель указывает менять можно
[02:22:34] <valexey_> иначе - нельзя
[02:23:25] <valexey_> вот такое - будет ошибкой компиляции:
let y = Box::new(42);
*y = 13;
[02:23:26] <NEW> но y не mut. Однако, после передачи его значения в x, его стало можно менять.
[02:23:52] <valexey_> а такое, не будет:
let mut y = Box::new(42);
*y = 13;
[02:25:14] <valexey_> то есть мутабельность указываемого тут привязана к мутабельности указателя
[02:25:25] <valexey_> упростили по сравнению с С++
[02:25:46] <valexey_> где мог быть константный указатель на не константу и неконстантный указатель на константу :-)
[02:26:57] <valexey_> Ооо! borrowed pointers - сейчас буду погружаться в пучину жести
[02:28:36] <valexey_> ибо самое странное, сложное, из того, что постоянно используется в Rust - это борьба с Borrowing checkerом
[02:29:15] <valexey_> ибо пока ему не докажешь, что у тебя ошибок в плане указателей в проге нет, прогу он тебе собрать не даст
[02:29:21] <NEW> название вызывает у меня ассоциации с подсчётом ссылок и правилами освобождения указателей в objective-c
[02:30:57] <valexey_> в obj-c оно в рантайме все. тут же - нет рантайма
[02:31:31] <valexey_> эффективность та же, что и в с++ или в чистом си
[18:23:03] <valexey> дас, если нет задачи делать работающий продукт, то Rust намного лучше и интересней чем golang
[18:50:19] <valexey> http://www.electronicdesign.com/industrial/rust-and-spark-software-reliability-everyone
[22:20:51] <_valexey_> http://www.opennet.ru/opennews/art.shtml?num=47800