@rustlang_ru - страница 1150

Anton

ребят

Anton

а по поводу хакатона

Anton

Нет, вот это уже опасный пример

Объясняй)

Ilya

Смотри, замени переменную на вектор

Anton

если чо в питере и тд, куда можно запинить сообщение о хакатоне то

Anton

в ниженм так то есть it52

Anton

а по остальным каналам чо?

Ilya

Если его мутируешь - то он переаллоцирует память и ссылка уже в другое место будет указывать

Anton

Так я ссылаюсь не на его часть

Cat

Вот пример проще: https://play.rust-lang.org/?gist=55aeefba33f73aac02f8361fb22a095c&version=stable

не, не спорю, в моём примере то же самое

Anton

А на вектор целиком

Anton

прост если реально есть желающие поучаствовать, надо бы как то организовать и инфу раскинуть и тд

Ilya

если чо в питере и тд, куда можно запинить сообщение о хакатоне то

Погоди пару дней, определимся точно с датой и тогда найдем каналы

Ilya

У меня есть несколько вариантов

Ilya

+ есть люди которые могут нам помочь

Anton

Там просто время жизни иммутабельных ссылок это вызов функции inspect

Anton

И компилятор вроде видит, что на момент, когда я их беру, их никто не может менять

Cat

а, я не в ту сторону пример развернул, ща

Anton

То есть, грубо говоря мутабельная ссылка может считаться иммутабельной во всех местах, кроме передачи её в мутирующую подфункцию

Anton

Или я неправ?

Ilya

Господи, как мне не хватает матклада

Ilya

Честно, не знаю)

Cat

math treasure?

Anton

Ну чисто по логике если подумать

Ilya

Я только знаю что компилятор этого не любит и приывк такие моменты обходить стороной

Anton

Мне просто очень не хватает таких правил в текущем расте

Anton

И я думаю, можно ли запилить свой раст с куртизанками, где можно будет так делать)

Cat

так, стоп

Cat

Ладно, вопрос: Я правильно понимаю, что вот этот код абсолютно безопасен всегда, просто компилятор не способен отследить такое? https://play.rust-lang.org/?gist=00b1a11ffbcf79e00d2c29614c423bd0&version=stable

это компилилось?

Anton

Без ансейфа нет

Cat

аааа

Cat

ну короче я просто неправильно понял вопрос

Anton

+ есть люди которые могут нам помочь

круто

Cuno

То есть, грубо говоря мутабельная ссылка может считаться иммутабельной во всех местах, кроме передачи её в мутирующую подфункцию

Единственность мутабельной ссылки не просто так требуется. Конверть в &mut ровно перед вызовом этих самых функций.

Cat

я думал у тебя как раз получилось сделать immut + mut borrowing

Anton

тогда я подожду инфу

Anton

если чо будет пиши

Anton

или сюда или в лс, помогу чем смогу, все остальное по организации и плюшкам на проведение могу взять на себя включая интернет и тд)

Cat

То есть, грубо говоря мутабельная ссылка может считаться иммутабельной во всех местах, кроме передачи её в мутирующую подфункцию

по идее должно фиксится в NLL, но там с ним другие проблемы пока

Cuno

по идее должно фиксится в NLL, но там с ним другие проблемы пока

NLL такое не фиксит

Cat

почему?

Anton

Единственность мутабельной ссылки не просто так требуется. Конверть в &mut ровно перед вызовом этих самых функций.

Но это же perfectly safe, нет?

Cuno

nll фиксит же только класс ошибок, которые решаются правильной постановкой областей видимости.

Cat

всё так

Ilya

Чтобы убедится в том что не фиксит, достаточно его включить и с грустью смотреть на ошибку компиляции)

Cuno

Но это же perfectly safe, нет?

В данном конкретном случае - да, но в общем случае - нет.

Anton

Почему?

Cat

nll фиксит же только класс ошибок, которые решаются правильной постановкой областей видимости.

например, let mut a; mutate(a); // borrow 'a' here immutably

Anton

Мы же по дереву вызовов всегда точно видим, где реально могут мутации происходить

Cuno

Почему?

Мутабельность ссылки это пруф того, что нет других указателей на переменную -> нет инвалидации никаких других указателей. Как ты с множеством указателей эту проблему решишь?

Cat

так он же вроде как раз про скопы

Cat

захват в render(), отпускание, захват mutable, отпускание, repeat

Anton

Мутабельность ссылки это пруф того, что нет других указателей на переменную -> нет инвалидации никаких других указателей. Как ты с множеством указателей эту проблему решишь?

Ну у нас всё происходит внутри функции. Мы всегда знаем, что если отдали её как немутабельную, на чтение, её вернут назад перед вызовом другой

Cuno

например, let mut a; mutate(a); // borrow 'a' here immutably

Не понял, к чему это.

Cat

это к изначальному вопросу ( вот этому https://play.rust-lang.org/?gist=00b1a11ffbcf79e00d2c29614c423bd0&version=stable )

Anton

Кстати сказать, кто из Питера, мы тут в это воскресенье собираемся на неформальную сходку

Кстати, не против заглянуть

Cuno

Ну у нас всё происходит внутри функции. Мы всегда знаем, что если отдали её как немутабельную, на чтение, её вернут назад перед вызовом другой

Пример. Допустим ты взял иммутабельную ссылку: let a = &vec[0] а затем передал мутабельную в функцию f(&mut vec). Вектор переаллоцируется и иммутабельная ссылка сломается.

Cat

(вмешиваюсь посередине разговора) конеш, но это про другое

Anton

Ну тут явно надо отпустить сначала a, она же по лайфтайму связана

Ilya

Кстати, не против заглянуть

Не вопрос, будем рады) если что пиши в лс.

Anton

Пример. Допустим ты взял иммутабельную ссылку: let a = &vec[0] а затем передал мутабельную в функцию f(&mut vec). Вектор переаллоцируется и иммутабельная ссылка сломается.

В моём примере иммутабельные отпускаются по выходу из inspect

Cuno

В моём примере иммутабельные отпускаются по выходу из inspect

Проблема в том, что это в общем случае нереально отследить.

Cat

граница в том, что "ссылки" при возврате из функции "отпускаются", и не будут ломаться при дальнейшем переиспользовании

Cat

если ссылки явно объявлены, то понятно, так нельзя

Cat

а если это просто вызов функции с возвратом, то почему бы и нет

Anton

Проблема в том, что это в общем случае нереально отследить.

Ну то есть проблема не в том, что так нельзя, а в том, что отследить нельзя?

Cuno

Ну то есть проблема не в том, что так нельзя, а в том, что отследить нельзя?

Только в частных случаях можно.

Cuno

Но в этом немного смысла

Cat

fn bar() { let mut data = vec!['a', 'b', 'c']; let slice = &mut data[..]; // <-+ 'lifetime capitalize(slice); // | data.push('d'); // ERROR! // | data.push('e'); // ERROR! // | data.push('f'); // ERROR! // | } // <------------------------------+

Anton

Ну я пока не смог придумать примера, в котором это было бы невалидно

Cat

fn bar() { let mut data = vec!['a', 'b', 'c']; let slice = &mut data[..]; // <-+ 'lifetime capitalize(slice); // | data.push('d'); // ERROR! // | data.push('e'); // ERROR! // | data.push('f'); // ERROR! // | } // <------------------------------+

пример из RFC про nll (https://github.com/rust-lang/rfcs/blob/master/text/2094-nll.md)

Anton

fn bar() { let mut data = vec!['a', 'b', 'c']; let slice = &mut data[..]; // <-+ 'lifetime capitalize(slice); // | data.push('d'); // ERROR! // | data.push('e'); // ERROR! // | data.push('f'); // ERROR! // | } // <------------------------------+

Это другое

Cat

Это другое

разве?

Cuno