LINUX.ORG.RU

Изучая Rust...

 , ,


1

4

Здравствуйте. Пытаюсь реализовать список на Rust. Вот что у меня получилось:

use std::fmt;

struct Node {
    value: i32,
    link: Option<Box<Node>>,
}

impl Node {
    fn new(value: i32) -> Node {
        Node { value: value, link: None, }
    }

    fn append(&mut self, value: i32) {
        match self.link {
            Some(ref mut node) => node.append(value),
            None => self.link = Some(Box::new(Node::new(value))),
        }
    }

    fn length(&self) -> i32 {
        match self.link {
            Some(ref node) => node.length() + 1,
            None => 1,
        }
    }

    fn insert_after(&mut self, value: i32, after: i32) -> bool {
        if self.value == after {
            self.link = Some(Box::new(Node { value: value, link: self.link.take() }));
            true
        }
        else {
            match self.link {
                Some(ref mut node) => node.insert_after(value, after),
                None => false,
            }
        }
    }
}

impl fmt::Display for Node {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.value)
        while
    }
}

fn main() {
    let mut stack = Node::new(1024);

     stack.append(67);

     println!("{}", stack);
}

Подскажите, как можно напечатать все элементы списка? В текущей реализации выводится только первый элемент.


Ответ на: комментарий от DarkEld3r

Список не мой, если что.

Я так понял, что раз вы вписались в их защиту, то поддерживаете озвученные red75prim претензии.

Хотя тоже считаю, что пользы от точки с запятой после if.

Эта фича появилась в языке задолго до того, как я вообще начал программировать. Так что для меня это просто объективная реальность, глупо рассуждать есть от этого польза или нет.

Но тащить такую «возможность» в новые языки нет смысла, как и жалеть об их утере.

Никто не жалеет об этой конкретной фиче. Речь о том, что говорить, что Rust лучше C++ потому, что в C++ можно ставить точку с запятой после if-а, а в Rust — нет, это сильно мелко.

Вон дропбокс недавно хвастался кодом на раст в продакшене - так они прямо говорили, что им нужен С++, но не было готовой инфраструктуры, потому и могли взять раст.

Там не так все однозначно (см. https://news.ycombinator.com/item?id=11283688 и https://news.ycombinator.com/item?id=11283758). У них была инфраструктура на Go, но в паре мест Go не удовлетворял по расходу памяти. Для этих мест можно было брать Rust или C++, взяли Rust. При том, что разработчики Rust находятся в тесном контакте с разработчиками из Dropbox и даже регулярно наведываются в офис Dropbox-а, то можно предположить, как именно был сделан выбор в пользу Rust-а ;)

Обращение к переменной без инициализации - ошибка компиляции.

Если мне не изменяет склероз, разговоры о том, что при разработке C++ допустили серьезный просчет и разрешили использование неинициализированных переменных, идут уже лет 20. И разговоры сводятся в итоге к одному и тому же: в 90% случаев обязательная инициализация переменных и полей классов не оказывает серьезного влияния на производительность. Но в оставшихся 10% случаев — оказывает, причем серьезное. И что делать в этих самых 10%? Заставлять людей менять C++ на что-то другое? Тогда как же репутация языка для высокопроизводительных приложений?

Ну а как можно спорить с return f(a), f(b), f(c);? Вот серьёзно - если тут не запятую, а точку с запятой применить, то что изменится?

Так ведь не зная, что именно возвращают f(a), f(b) и f(c) нельзя сказать, какой тип в итоге имеет выражение f(a), f(b), f(c). Может это то же самое, что и:

ostream & operator<<(ostream & to, const data & v) {
  return to << v.a << v.b << v.c;
}

eao197 ★★★★★ ()
Ответ на: комментарий от DarkEld3r

Ага, вот только есть ещё одна проблема: всё вокруг - «дерьмо». И или мы будем «держать его на плаву» или останемся ни с чем. Ты ведь не рвёшься переписать всё «по уму».

Ну дак всем насрать всё дерьмо или нет, в конечном итоге это ничего не меняет - проблема в дерьме, а не в языке и твои рассуждения это никак не меняют.

Ну не скажи - ни С ни плюсы сильно кратко писать не позволят.

Куллстори такая куллстори. Почему все примеры, которые взялись в этом теме - в них раст ну как бэ это сказать покультурней.

Хотя мне лень рассказывать про кратко балбателям, ибо это слишком бесполезно - у них в головах всё смешалось - дёрганье апи/написание кода. Впрочем, для любого языка найдётся задача которую без «тонн лапши» не решить.

Впрочем, для любого языка найдётся задача которую без «тонн лапши» не решить.

Для раста - это все. Да и нет таких задач.

Всё-таки не соглашусь. Проекты - они разные по объёму и сложности бывают. Всё-всё в одну голову не (всегда) реально поместить.

Причём тут «понять»? Причём тут «поместить»? Это никак и ни на что не влияет. Я говорю об ошибках типа «нетак заюзал», «что-то перепутал», «что-то недотсавил», «криво спастил» и прочее. Это именно те ошибки, который не логические, который ты можешь сделать.

Если раньше адпт рвал жопу грепая и ища объявления/определения/примеры использования, да и то он этого не делал, ибо зачем? Сейчас с этим проблем нет.

А уж надуманные ошибки типа точки с запятой после if - просто смешны. Нажал кнопочку «реформат» и всё, да и ворнинг словил.

Если ты пытаешься толкать про «вникать в логику» проекта, то раст к этом отношения не имеет.

Тут тоже можно поспорить. Многое в последних стандартах (и вполне успешно) делается как раз для упрощения «без потери скорости».

О боже, ты понимаешь вообще что я тебе говорю? Я тебе повторяю пропаганду влитую в голову раст-адептов, а не то как на самом деле есть.

На самом деле раст нихрена не safe, чем кресты, но это никого не волнует. И «без потери скорости» - так же смешно.

Да и когда речь о «безопасности» заходит, то тут же начинаются разговоры - мол никаких проблем давно нет, «если нормально писать».

Никаких проблем нет, ибо все примеры раст-пропагандистов настолько убоги и высосаны из пальца, что просто смешно.

Точка с запятой после скобочек. Выпил скобочек. Балабольство про «сишный синтаксис говно», а после того как благополучно обделались со своим «куллсинтасисом» уже не говно.

Ни одного примера реального safe - нет. Всё какая-то неведомая херня. Везде сравнения жопа с пальцем.

А на самом деле, есть. Другой вопрос насколько тут «чудо-инструменты» помогут.

Примеры где. Есть - покажи. Не сравнивая сишные касты из крестов с растом, а сравнивая крестовые методы с растом. С таким же успехом я могу помножить это на ноль использую твоё «unsafe» - видишь сишный каст - значит unsafe и всё наглядно.

Ну паттерн матчинг с местными enum, опять же?

Нет. Именно пример. Конкретный пример, т.е. применение обусловленное реальной задачей.

У нас в проекте активно используется boost::variant с самописным «подобием» матча - получается менее красиво/удобно.

Ну это проблема твой реализации. Выкатывай.

Или то, что указатель/optional нельзя разыменовать без проверки.

Это какие-то мутные куллстори. Без объяснений «зачем/почему» - это не имеет смысла. Какие проблемы могут быть с разименованием указателя? У тебя null имеет какое-то значение? Ну это проблема твоего подхода.

Как ты собрался гарантировать проверку указателя в рантайме? Заставить на каждый указатель вначале блока его определения проверять, иначе отваливаться?

Да, это решается «всего-лишь внимательностью», но я предпочту чтобы компилятор тут подстраховывал.

Нет, это решается вменяемыми подходами.

registrant27492 ()
Ответ на: комментарий от DarkEld3r

Все применения просмотрел? (Мне лень, честно.)

Мне не надо смотреть. Я тебе гарантирую, что любой шарящий пацан не будет никогда писать на русте. По определению. А рандомный раст-адепт ни во что что, кроме как спастить убогое repmovsb не может.

Синтаксис макроса такой.

Меня не волнует это. Меня волнует «зачем»? Чем «{rax}» отличается от оригинального «rax»;

Ну и ассемблер на строках из 70-х в новом языке - это так мило. Просто смешно. А ха да забыл - чтобы удобней было пастить из сишки(гцц) - единственное объяснение. Ну и «intel» - это так мило - паста с маздайского osdev.

Ради тебя посмотрел всё - ничего хоть что-то стоящего нет.

Ну а как можно спорить с return f(a), f(b), f(c);? Вот серьёзно - если тут не запятую, а точку с запятой применить, то что изменится?

А ну ок, надо так:

f(a, b, c)
{
    f(a);
    f(b);
    return f(c);
}
Гораздо лучше.

Давай без этого с лужами, ок?

Ну дак а как иначе? Ты заигнорил этот факт ниже и начал опять толка «разницы нет», но ведь ты сам её нашел.

Короче - не всегда лучше.

Всегда. Тут не просто короче - тут полностью идентично по всем остальным критериям, кроме собственно «короче».

Ну и дофига проектов используют вариант с скобкой на отдельной строке.

Дофига алкашей валяется под забором - не вижу в этом ничего плохого.

Мне не важно что там и где используется - у нас есть конкретные профиты с первого и ноль профитов со второго. Один из профитов нашел ты, ибо я о нём даже не подозревал.

И сторонники такого подхода тоже приведут «аргументы» - мол так визуально лучше видно и т.д. Вес аргументов примерно одинаковый.

АХаха. Ой не могу - эти веруны такие смешные.

У нас есть два объективных критерия - наш шанса запороть и короче, против которые ничего нет.

Ты же выклал убогохую херню вида «визуально видно» - что вообще не имеет смысла. Любая субъективная херня взаимонивелируется мой субъективной хернёй и не является аргументом от слова вообще.

Ты это понимаешь? Ты только что подтвердил, что нормальный скобочки лучше - подставив защитников не нормальных.

Это сарказм или как?

Уж явно убогая портянка не может быть лучше одной строки.

Ну и у цикла вполне может быть пустое тело, если так уж хочется. Хотя while((*out++ = *in++)) действительно не прокатит.

И да, тут даже есть safe вида вторых скобочек для =, для наглядности и конпелятора.

registrant27492 ()
Ответ на: комментарий от DarkEld3r

Это типа фича.

Ограничение вызванное убогостью реализации уже является фичёй - отличный дивный мир.

Да и как ты статически отслеживать будешь?

Легко.

Вот есть в программе, скажем, преобразование i32 в u8

И - чем это тебе помешает? Если тебе так хочется - сделай усечение явным, но это никак не влияет на 99% остальных случаев, где оно не нужно.

И что тут компилятор может увидеть?

Он итак там ничего не видит. Даже если ты поставишь каст руками. Это логическая ошибка, которая к конпелятору не имеет никакого отношения.

Да, в каких-то случаях, рядом будет проверка и по ней можно что-то выводить, но покажи мне кто так умеет.

У тебя же safe, не?

Ты вообще понимаешь что ты толкаешь? Ты понимаешь, что руст хайпиться как «принципиально новый и мощный конпелятор», который естественно должен уметь то, что не умеет никто, иначе это очередная нонейм поделка.

А ещё чаще только человек знает (и хорошо если знает, а не думает, что знает) можно ли безопасно кастовать.

В этом проблема всех проверялок - они не работают для случаев чуть сложнее банального анскилла. Поэтому всё просто - мы называем анскилл «проблемой» всеобщей и самой проблемной, а потом благополучно её решаем, вернее даже её не решаем, но делаем вид.

В конечном итоге это ничего не меняет, но гранты получены и тебе поклоняются, а большего не надо - никому не надо ничего решать.

Зачем решать, если можно не решать? Зачем писать нормально, если можно не писать? С чего вдруг в одном месте стал противополный обыденному подходу в любой другой оласти подход? Так не бывает.

Конкретно в примере со строками это, пожалуй, спорный момент. Тут обычно аргументируют тем, что будет выделение памяти и хорошо, что оно явно делается. Ну и если надо, то имеются трейты From и Into.

Выделение память в таком подходе - это обыденность. Зачем её выделять, если она везде?

Нет, это брехня, которая ничего не объяснят и не из чего не следует. Не сделано это по причине того, что сваять дерьмо просто, а вот сваять реально что-то отслеживающую систему - ой как не просто.

registrant27492 ()
Ответ на: комментарий от DarkEld3r

Так, погоди. Мы ведь о лайфтаймах говорили.

Нет.

Они нужны только для того, чтобы компилятор мог (статически) проследить за тем, чтобы ссылки не пережили владельца.

А где мистический треадсейв? Чем это отличается от обычной передачи ссылки в крестах?

То есть, «тупо» нельзя вернуть из функции ссылку (владеющий указатель - можно) на что-то созданное в ней же. Если, конечно, это что-то не static. Никаких аллокаций и прочего «под капотом» не происходит.

А т.е. реальный некстген - посмеялся.

Причём тут аллокации. Ладно, слишком сложно.

Что ты под «шареньем ссылок» подразумеваешь не знаю, если что аналог shared_ptr есть, но к ссылкам отношения не имеет.

Я подразумеваю то, что подразумеваю. Есть объект и есть раздача ссылок на него кому угодно и всё работает.

С ними тоже всё просто: на объект может быть ровно одна мутабельная ссылка и только при отсутствии обычных. И это тоже (для простых) ссылок проверяется во время компиляции. То есть нельзя «случайно» поменять объект пока кто-то ожидает, что он не изменится. Тоже всё просто и никакой магии.

Причём тут «проверяется» во время конпеляции, если этого нельзя?

Зачем менять объект, если его невозможно поменять. Если его нельзя менять - его менять нельзя. Если его менять можно - его менять можно.

Если я передаю ссылку на строку которая у меня изначально есть - с какого бадуна я не могу её поменять? Кто там и чего будет ожидать?

Ты можешь в пример того, как там что-то неожиданно поменяется и прочее. Зачем мне балабольство?

Или это не то, что ты ожидал услышать и мы снова друг друга не поняли?

Ещё раз. Твой лайвтайм никому не интересен. Запретить всё, а потом насрать везде деструкторов - это днище уровня первого курса и 70-х годов.

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

Я говорю про ту абстракцию, которую они реализуют - а именно срать в рантайм всякой хернёй в рандомных местах.

Давай ещё раз. У нас есть набор каких-то ресурсов, которые я клепаю. Далее происходит работа с ними, а потом освобождение. И вот автоматической освобождение и есть твоя абстракция, а не её куллреализация, которая никому кроме адептов не интересна.

И разница в том, что руками я могу освобождать так, как нужно мне, а у тебя происходит всё так - как тебе наклал конпелятор. И зерокостом оно станет именно тогда, когда сделает это так же, как я сделаю руками.

Банальный пример с аллокацией. Если у меня время жизни объектов, которые я создавал в функции заканчивается в этом функции, то создаются они в уникальном кеше(т.е. банальный стек) этой функции, а после ресетится всё это разом. Т.е. зерокост - это одна аллкация на все объекты, которые живут только здесь.

Твоя же куллхрень насрёт мне 100500 маллоков и фри, ибо реализация на уровне детского сада.

Ну людям свойственно увлекаться, почему бы и нет. Убить плюсы будет непросто, даже если убийца будет лучше по всем показателем. Но всё-таки, что в расте тебе кажется тормозным? Ну раз ты делаешь упор на «фаст».

Всё.

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

Что хочу я - это противоречит основам safe, ибо основа safe - не дать делать мне то, что я хочу. А сгрести мой код под набор убогих паттернов и выкатить убогие реализации оных.

registrant27492 ()
Ответ на: комментарий от DarkEld3r

Ладно - я же хотел показать что такое фаст ещё с темы в новостях «новый раст». Надо забить на убогие тачки и запастить, но мне всё некогда. Запащу.

registrant27492 ()
Ответ на: комментарий от anonymous

Случаев, когда нужно использовать дефолт, много и самых разных.

Дык, тут проблема не с дефолтным значением, а с тем, что хочется вернуть значения разных типов. B свифте можно написать функцию, которая это делает?

DarkEld3r ★★★★★ ()
Ответ на: комментарий от anonymous

Лично я для своего кода получаю:

Да, был не прав, предупреждение может и быть.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от registrant27492

Слушай, тебя никто не заставляет использовать или учить раст. Откуда столько желчи? Смени ник на «передергивающий». У тебя что ни пост, то передергивание. Ты тут так яро кукарекаешь про идеальную сишку, тогда покажи свои работы, которые не лишены тех ошибок, которых можно избежать, используя раст. А то одно лишь кукареканье в духе «Да говно все это. Сишка идеальна. Новые языки ни к чему» и все в таком духе. В общем проходи мимо. Ничего путного ты не написал в своих портянках.

paret ()
Ответ на: комментарий от eao197

глупо рассуждать есть от этого польза или нет.

Почему? Смысл есть - знать о потенциальных «проблемах», не тащить такие «фичи» в другие языки. В конце концов, может оказаться, что в каких-то случаях польза всё-таки есть, а я просто не в курсе.

Там не так все однозначно

Очень даже однозначно:

Dropbox doesn't have a strong C++ ecosystem on the backend, and it takes a lot of work to build one. Given (1), we had basically a blank slate, and our team is C++ and Haskell type folks, we decided to use Rust so we could get C++ with better type safety and fewer sharp corners.

В том смысле, что будь у них достаточно кода на С++, то никакие «знакомства с разработчиками Rust» не помогли бы.

Кстати, про библиотеки - они хоть и написали что-то для себя, но применяют и «общие». То есть (для каких-то случаев) всё не так плохо.

И что делать в этих самых 10%?

Да хотя бы то, что Майерс продвигал int x = void;. Кстати, в D как раз так и сделано. В расте похожая ситуация (std::mem::uninitialized) с тем дополнением, что если компилятор может проверить, что инициализация обязательно будет до использования, то ничего делать и не надо.

Так ведь не зная, что именно возвращают f(a), f(b) и f(c) нельзя сказать, какой тип в итоге имеет выражение

Да, не подумал про это. Хотя я всё равно предпочту так не делать и если уж захотелось, то перегрузить какой-то другой оператор.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от DarkEld3r

хочется вернуть значения разных типов. B свифте можно написать функцию, которая это делает?

Самый простой вариант:

func foo( let v: Bool ) -> Any {
    return v ?
        123.4 :
        "1234";
}

print( foo( false ) )
print( foo( true ) )

Ну и можно, конечно, свой составной тип указать.

anonymous ()
Ответ на: комментарий от DarkEld3r

В том смысле, что будь у них достаточно кода на С++, то никакие «знакомства с разработчиками Rust» не помогли бы.

Я о другом: у них была задача, которую можно делать на C++, а можно на Rust. Наработок для нее ни на C++, ни на Rust нет. Можно взять старый C++ с высокого качества компиляторами и библиотеками. А можно взять Rust, который меньше года как достиг версии 1.0. Берут Rust и плотно при этом сотрудничают с разработчиками Rust-а.

Как по мне, так это выглядит как «захотелось попробовать новую цацку, попробовали, пока нравится».

Потому и сказал, что не так все однозначно.

Да хотя бы то, что Майерс продвигал int x = void;

Ну хорошо, будет в коде вот так:

void f(int & x) {
  x = x * x;
}
void g() {
  int x = void;
  if(some_condition())
    f(x);
}
В чем принципиальная разница с записью просто int x;?

Хотя я всё равно предпочту так не делать и если уж захотелось, то перегрузить какой-то другой оператор.

Ну тут опять уходим в сторону личных предпочтений. Если вам и кому-то другому не нравится перегружать оператор запятая, то вы просто не перегружаете его. А вот если кто-то имеет глубокие Prolog-овские корни и хочет на C++ изобразить что-то вроде Prolog-подобного DSL:

auto some_rule = cond1, cond2, cond3;
auto another_rule = (cond3, cond5), !some_rule;
То почему у него не должно быть возможности сделать это?

Выражусь более конкретно: язык C++ уже слишком большой, чтобы в каждом из проектов задействовать все его возможности. Чаще всего ограничиваются неким подмножеством языка, куда можно включить то, что подходит конкретной команде.

В Rust-е пока еще не так. Но это явно пока. И когда в Rust-е будет своего хлама навалом, неужели тогда будет иметь смысл критика Rust-а в стиле «в Rust-е есть фича X, которая лично мне нафиг не упала, поэтому Rust хуже, чем Swift-3»?

eao197 ★★★★★ ()
Ответ на: комментарий от paret

Слушай, тебя никто не заставляет использовать или учить раст. Откуда столько желчи?

Да нет, просто у тебя разрыв шаблона. В этом мире принято, либо следовать воли партии, либо не противиться ей. Любая критика вызывает анальную боль.

Начинается брехня вида «не учи, никто не заставляет» и прочее. «желчь» и прочие куллстори. В мире пони неспокойно - кто-то не согласен с тем, что мне сказали и во что я верю, а т.к. я просто верю и просто адепт - аргументации у меня нет и ничего по-существу я сказать не могу.

Меня не волнует твой раст - мне на него насрать. Меня волнует пропаганда среди зелёных адептов, которая каждую секунду ретранслируется в мои уши - зачем она мне?

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

Смени ник на «передергивающий». У тебя что ни пост, то передергивание.

Приведи примеры.

Передёргивание - оправдание той же неспособности и убогости пропаганды. Вот у нас рекламируется газетка - газетка - гениальное изобретение, которая вам позволит насрать где угодно и драить пол. Любоые куллязыки решают придуманыне ими же проблемы.

И любой вменяемый человек понимает, что нет смысла решать проблему, если её можно не создавать и уж точно видит какая проблемы высосана из пальца.

Пропаганда действует на зелёности адептов, который понимать не способны, а всё их знание о мире берётся из чтения бложиков авторитетов. И если авторитет сказал, что проблема с уберанием хаты после насирания на пол есть - значит она есть.

После чего прихожу я и задаю наводящий вопрос - зачем срать на пол? У тебя происходит затык, ибо авторитет на этот вопрос не отвечал, да и не ответит, а ты не споосбен отвечать на вопросы в принципе, ибо ретранслятор воли, чужой.

И твои извилины начинают защищаться - пытаясь давить авторитетом, взывать ко всем, взывать к «передёргиванию».

Неспособность к восприятию в глубину больше одного - типичная проблема любого балабола. У него есть мистическое а из которого надо сделать б, но откуда взялось а и зачем получать б - ему не важно.

Ты тут так яро кукарекаешь про идеальную сишку

Ну вперёд - покажи мне примеры, где я кукарекал про «идеальную сишку». Мне очень интересно поглядеть на это.

Особенно отвечая на ветку С++ вс раст.

тогда покажи свои работы

Покажи свои работы на расте, да ладно - хотябы примеры тех ошибок, которые:

которых можно избежать, используя раст

Я ни одну такую обишку не видел, да её и не существует. И да, вот опять же. Сравнение идёт жопа с пальцем. Сравнивается конкретика и утверждение.

Ты либо выкатывай свои работы, в которых ошибок этих нет, который делают то же самое, что работы на си, в которых ошибки эти есть, либо ты изначально пробалаболил.

А то одно лишь кукареканье в духе «Да говно все это. Сишка идеальна. Новые языки ни к чему» и все в таком духе.

О боже, зачем ты пытаешься что-то про меня кукарекать? Мне тебя опять послать искать пруфцы?

В общем проходи мимо. Ничего путного ты не написал в своих портянках.

Понимаешь - оценивать мои портянки может тот, кто обладает хоть каким-то пониманием в теме. С чего они должны быть понятны рандомному балаболу?

Твоя задача жрать что дают и не возникать, поменьше думая. Ты свою задачу крайне трепетно блюдёшь - вот и блюди дальше.

Если со мною не согласен - попытайся кукарекнуть что-то конкретное, а пока этого нет - балабольство меня мало интересует.

registrant27492 ()
Ответ на: комментарий от registrant27492

Прекращай уже свои простыни писать, их все-равно никто не читает полностью.

anonymous ()
Ответ на: комментарий от registrant27492

Давно мечтал узнать те места, в которых раст сделал «прорыв».

Ты слепой, что ли? Например, Rust сверг Перл с почетного первого места по вырвиглазному синтаксису. Если это не прорыв, то я вообще не знаю, что такое прорыв.

anonymous ()
Ответ на: комментарий от registrant27492

В игнор поставил, а всё равно почему-то видно.

в которых ошибок этих нет, который делают то же самое, что работы на си, в которых ошибки эти есть, либо ты изначально пробалаболил.

Любой браузер и Servo.

red75prim ★★ ()
Ответ на: комментарий от registrant27492

Я тебе гарантирую, что любой шарящий пацан не будет никогда писать на русте. По определению.

Ну если определение «шарящего пацана» - это «тот кто никогда не будет писать на расте», то ок.

Ну и ассемблер на строках из 70-х в новом языке - это так мило.

И ведь ты даже не понимаешь, что это не строки. Это макросы. То есть «произвольный текст» в эту «строку» напихать не получится (проверка будет на этапе компиляции).

Гораздо лучше.

Вообще-то да. Да и записать в одну строчку можно и при использовании точки с запятой. Более того, в расте даже return писать не надо - «огромное преимущество» в краткости.

Ты заигнорил этот факт ниже и начал опять толка «разницы нет», но ведь ты сам её нашел.

Стараюсь ничего не игнорировать, но ты слишком часто растекаешься мыслями и в этом легко что-то упустить.

Всегда.

Нет.

Мне не важно что там и где используется - у нас есть конкретные профиты с первого и ноль профитов со второго.

И какие же профиты? Ну кроме «экономии строчки» польза от чего достаточно субъективна.

Про точку с запятой мы ведь оба согласны, что это ерунда.

Ты это понимаешь?

Нет, твоей логики (весьма часто) не понимаю.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от anonymous

Ты слепой, что ли? Например, Rust сверг Перл с почетного первого места по вырвиглазному синтаксису. Если это не прорыв, то я вообще не знаю, что такое прорыв.

Ну лично для меня раст-лапша ничем не отличается от какой-то лиспа-хацкель лапши, где лисп/хацкель используется для чего-то сложнее лабы. Где к нему прикручены черз жопу циклы/типы и прочее. Раст это очередной клон, только у него не получилось использовать использовать для этого дефолтный синтаксис и прошлось брать сишный.

А перл не сказать что настолько убогий, хотя возможно - не особо им интересовался и ничего сложнее хелворда не видел.

registrant27492 ()
Ответ на: комментарий от registrant27492

Ну лично для меня раст-лапша ничем не отличается от какой-то лиспа-хацкель лапши, где лисп/хацкель используется для чего-то сложнее лабы.

Один Перл - это где-то пять какашкелей по вырвиглазности, если постараться. А раст его переплюнул. Это достижение.

anonymous ()
Ответ на: комментарий от registrant27492

Ограничение вызванное убогостью реализации уже является фичёй - отличный дивный мир.

Это сознательное решение вообще-то. По твоему, есть какие-то сложности сделать неявный каст?

Легко.

Покажи.

Это логическая ошибка, которая к конпелятору не имеет никакого отношения.

Совсем не обязательно это логическая ошибка.

Ты понимаешь, что руст хайпиться как «принципиально новый и мощный конпелятор», который естественно должен уметь то, что не умеет никто, иначе это очередная нонейм поделка.

Я-то как раз понимаю. А вот ты похоже нет и доводишь всё до абсурда. Раст предоставляет определённые гарантии, но «сделать всем зашибись» никто не обещал.

Выделение память в таком подходе - это обыденность. Зачем её выделять, если она везде?

Что это вообще должно значить?

DarkEld3r ★★★★★ ()
Ответ на: комментарий от registrant27492

На самом деле раст нихрена не safe, чем кресты, но это никого не волнует. И «без потери скорости» - так же смешно.

Ты много говоришь, а конкретных аргументов так и не было.

С таким же успехом я могу помножить это на ноль использую твоё «unsafe» - видишь сишный каст - значит unsafe и всё наглядно.

Нет. В расте есть один конкретный unsafe, который легко обнаружить как глазами, так и автоматическими средствами. А в плюсах куча вещей, которыми можно выстрелить в ногу и это не всегда бросается в глаза.

Как ты собрался гарантировать проверку указателя в рантайме?

Не в рантайме, а во время компиляции. Да, (опуская подробности) просто нельзя «разыменовать» не проверив.

Ну это проблема твой реализации. Выкатывай.

Я не буду копипастить код из рабочего проекта. А если упрощать, то наверняка, ты скажешь, что это не конкретная задача и прочее бла бла бла. Если нет, то можешь посмотреть на такой пример:

enum Choice {
    A,
    B,
    C,
    D,
}

let c = ...
    
match c {
    Choice::A => {},
    Choice::B => {},
    _ => {}
}

Нет, это решается вменяемыми подходами.

Не решается.

DarkEld3r ★★★★★ ()
Последнее исправление: DarkEld3r (всего исправлений: 1)
Ответ на: комментарий от registrant27492

Если я передаю ссылку на строку которая у меня изначально есть - с какого бадуна я не могу её поменять? Кто там и чего будет ожидать?

Ты можешь в пример того, как там что-то неожиданно поменяется и прочее. Зачем мне балабольство?

Когда ты копию объекта отдаешь в метод, тебе очевидно, что это именно копия. Когда ты отдаешь ссылку, то объект может что угодно делать с твоей строкой. Неизменяемые ссылки могут хоть как-нибудь ограничить его возможности, но он таки может проиндексировать строку и сохранить ссылку у себя, но далее ты _внезапно_ изменяешь эту строку и при последующем использовании какого-нибудь метода этого объекта он обратится к этой уже измененной без его ведома строки и начнет вести себя неопределенным образом. Тебе то видней - строка твоя, делаешь что хочешь, но объект не в курсе о твоих намерениях. Единственный для него вариант подстраховки от твоих слишком хитрых рук - самому делать копию строки. И это мы еще без многопоточности.

Очевидно, что следующие правила раста действительно могут разрулить множество проблем.

  • У объекта лишь один владелец.
  • Либо одна изменяемая ссылка, либо много неизменяемых.

В дополнение к этому могут оказаться полезными маркеры `Send` - гарантия, что объект может быть перемещен в другой поток, и `Sync` - с объектом могут одновременно работать несколько потоков.

Я подразумеваю то, что подразумеваю. Есть объект и есть раздача ссылок на него кому угодно и всё работает.

В примитивных ситуациях.

Что хочу я - это противоречит основам safe, ибо основа safe - не дать делать мне то, что я хочу. А сгрести мой код под набор убогих паттернов и выкатить убогие реализации оных.

К чему это ярое отрицание гарантий раста? Когда ты для проекта выбираешь этот ЯП, ты осознанно встаешь на путь safe ограничений. Следуя примитивным правилам, ты перекладываешь на компилятор ответственность за сохранность памяти и можешь полностью сосредоточиться на выполнении задачи, не отвлекаясь на мелочи. Тебе не нравится, когда водят за ручку? Добро пожаловать в unsafe! Но вне этого небезопасного блока ты опять должен будешь следовать указаниям компилятора.

И разница в том, что руками я могу освобождать так, как нужно мне, а у тебя происходит всё так - как тебе наклал конпелятор. И зерокостом оно станет именно тогда, когда сделает это так же, как я сделаю руками.

Вызывай деструктор руками, оптимизатор.

У тебя же safe, не?

Ты вообще понимаешь что ты толкаешь? Ты понимаешь, что руст хайпиться как «принципиально новый и мощный конпелятор», который естественно должен уметь то, что не умеет никто, иначе это очередная нонейм поделка.

Серебрянной пули нет, есть мощные средства для отделения safe от unsafe. Небезопасные блоки есть в стандартной библиотеке, но это всего-лишь _блоки_, а не 100% небезопасного кода, за котором ты _всегда_ должен внимательно следить и не накосячить на ровном месте.

shaiZaigh ()
Ответ на: комментарий от DarkEld3r

Ну если определение «шарящего пацана» - это «тот кто никогда не будет писать на расте», то ок.

Нет - определение щарящего пацана - это «пацан, который может писать и понимать настолько, что ему понадобился ассемблер». Я 10-й раз повторю про либц - это та причина, почему все куллязычки от неё зависят.

И ведь ты даже не понимаешь, что это не строки. Это макросы.

О божечки. На современном языка это делается так:

rep(len).movsb(a, b);

Это строки, причём убогие. Хотя объяснять это бесполезно.

То есть «произвольный текст» в эту «строку» напихать не получится (проверка будет на этапе компиляции).

Произвольный текст и в оригинале написать не получится, при этом там нету убогих {}, которые не имеют смысла.

О боже, каким место у тебя в ассемблере не будет проверки на этапе конпеляции - как ты сконпелирует хренпойми что?

Вообще-то да. Да и записать в одну строчку можно и при использовании точки с запятой. Более того, в расте даже return писать не надо - «огромное преимущество» в краткости.

Ога, а fn надо. Ты уж определись. Как написать ретурн из цикла в функции, которая воид?

Стараюсь ничего не игнорировать, но ты слишком часто растекаешься мыслями и в этом легко что-то упустить.

Зачем ты отмазываешься? Ты проиграл со скобочками - либо признай, либо попытайся привести более илитные аргументы.

И какие же профиты? Ну кроме «экономии строчки» польза от чего достаточно субъективна.

Ты сам назвал одну из причин - нельзя написать точку с запятой до скобочек.

Экономия строчки - это объективный плюс, ибо чем меньше лишних строчек - тем компактнее код, а чем копактнее код - тем меньше его надо скролить, а чем меньше надо скролить - тем проще пинимать, ибо все объекты находятся в поле зрения.

Про точку с запятой мы ведь оба согласны, что это ерунда.

Без разницы ерунда или нет - раз у пацанов случилась победа - будем им верить. Да и зачем тогда ты говорил об этом точке с запятой, если она ерунда?

Нет, твоей логики (весьма часто) не понимаю.

Это проблема веры. Твоя адепты спастили gis, а ты мне токаешь какую-то херню про строки. Твои адепнты не написали ни одной строки на асм - ты мне толкаешь, что «можно юзать асм». Если можно - почему никто не юзает? А если никто не юзает, то зачем тогда ты начал про это говорить.

registrant27492 ()
Ответ на: комментарий от registrant27492

О божечки. На современном языка это делается так:

rep(len).movsb(a, b);

Что тебе мешает сделать так в rust?

Ты такой невежда...

anonymous ()
Ответ на: комментарий от DarkEld3r

Это сознательное решение вообще-то. По твоему, есть какие-то сложности сделать неявный каст?

Как это мило. А сделать его не явным ещё проще.

Опять же - раст ничего из себя не представляет в плане конпеляторостроения, либо статического анализа, либо safe. Рядовая поделка, но как-то приариться надо.

И пиар клепается на основе такое схемы: мы берём какую-то проблему, которой нет, но это не важно. Далее удаляем вообще возможность её воспроизвести, причём не средствами анализа, либо чего-то - а просто выпиливанием всех фичей, которые её вызвают.

Далее адептам внушаем, что мы решили проблему за счёт чего-то мистического, типа «суперконпелятора» и они уже это херню ретранслируют дальше.

Покажи.

Что кокнретно?

Совсем не обязательно это логическая ошибка.

Зачем ты мне что-то рассказываешь? Если это не ошибка, то никакой проблемы с автокастом не будет, а если она будет, то это логическая ошибка.

Я-то как раз понимаю. А вот ты похоже нет и доводишь всё до абсурда. Раст предоставляет определённые гарантии, но «сделать всем зашибись» никто не обещал.

Это не гарантии, а дерьмо. Я с таким же успехом могу не юзать это в крестах и получить все «супервозможности».

Что это вообще должно значить?

Это значит то, что срать аллкациями на каждый чих - это свойство рантайма раста, как и любой другого рантайма куллязыка. И все абсолютно насрать где происходит аллкация, если она происходит везде и всегда.

registrant27492 ()
Ответ на: комментарий от registrant27492

Нет.

Да.

А где мистический треадсейв?

Про это тоже было, ты невнимательно читал.

Если я передаю ссылку на строку которая у меня изначально есть - с какого бадуна я не могу её поменять? Кто там и чего будет ожидать?

У тебя есть мутабельная строка, ты передаёшь на неё константную ссылку в другой поток. Поток логично ожидает, что раз ссылка константная, то строка останется такой как есть, но на самом деле, ты можешь её поменять. А в расте не можешь пока «живы» другие ссылки на объект.

И вот автоматической освобождение и есть твоя абстракция,

Нет, это обычное RAII особого отношения к лайфтамам не имеющее.

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

Чего? И в плюсах и в расте можно освободить руками в нужном месте, если захотелось.

Что хочу я - это противоречит основам safe

Именно поэтому присутствует unsafe. А вот чего ты упорно не хочешь понимать, так это того, что unsafe не обязан быть размазан по всему коду.

DarkEld3r ★★★★★ ()

Зачем вы с поехавшим?

anonymous ()
Ответ на: комментарий от anonymous

Самый простой вариант:

Постой, разве функция не возвращает всегда один конкретный тип (Any)? Так и в расте можно.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от DarkEld3r

Постой, разве функция не возвращает всегда один конкретный тип (Any)?

Ну да, но опять же в Swift есть и дженерики и алгебраические типы. Что именно ты хотел увидеть?

Так и в расте можно.

Давай сравним, сдается мне в Rust ты так просто его не напишешь, не скастуешь и не используешь. И код будет ужасней на порядок. Впрочем как почти всегда.

anonymous ()
Ответ на: комментарий от eao197

Как по мне, так это выглядит как «захотелось попробовать новую цацку, попробовали, пока нравится».

Ну да, не без этого. Но как ещё иначе применимость нового языка оценить?

В чем принципиальная разница с записью просто int x;?

Подозреваю, что на такой код компилятор будет ругаться. Ведь, в общем случае, он не обязательно видит тело f, а ведь там может быть и обращение вместо инициализации.

А вообще принципиальная разница в том, что инициализацию в void надо писать, то есть это будет сознательное решение, а не потенциальный провтык как сейчас с отсутствием инициализации.

А вот если кто-то имеет глубокие Prolog-овские корни и хочет на C++ изобразить что-то вроде Prolog-подобного DSL:

А если у кого-то «глубокие динамические корни» и он хочет динамическую типизацию? Или «лисповые корни» и хочет чтобы всюду были скобки? Почему их права ущемляются?

Наверное, потому что не все концепции удачно можно в язык вписать. Плюс если всё подряд тащить, то тоже ничего хорошего не будет.

Естественно, не все фичи в каждом проекте нужны. Как раз поэтому их стоит, по возможности, в библиотеки выносить и делать модульными. Конкретно про ДСЛ - лучше в языке иметь гибкие макросы и пусть кому надо делает себе что угодно. Впрочем, в расте, на мой взгляд, макросы могли быть и лучше.

неужели тогда будет иметь смысл критика Rust-а в стиле «в Rust-е есть фича X, которая лично мне нафиг не упала, поэтому Rust хуже, чем Swift-3»?

Ну если фича в 99% проектов только мешается, то почему бы и нет.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от DarkEld3r

Нет. В расте есть один конкретный unsafe, который легко обнаружить как глазами, так и автоматическими средствами. А в плюсах куча вещей, которыми можно выстрелить в ногу и это не всегда бросается в глаза.

Они так же просто вычисляются автоматическими средствами.

Не в рантайме, а во время компиляции. Да, (опуская подробности) просто нельзя «разыменовать» не проверив.

Как ты проверишь указатель во время конпеляции?

проверка;extern-вызов;разименование - это не проканает, либо проканает?

Я не буду копипастить код из рабочего проекта. А если упрощать, то наверняка, ты скажешь, что это не конкретная задача и прочее бла бла бла. Если нет, то можешь посмотреть на такой пример:

Мне нужна конкретная задача - мне насрать насколько она упрощённай. Код тебе пастить не надо - задача там в любом случае примитивная.

Если нет, то можешь посмотреть на такой пример:

Чем это отличается от:

  Choice c = ...;
  switch(c) {
    A : {}; break;
    B : {}; break;
    default : {}; break;
  }

Отсутствием бряков? А если мне надо и на а и на б один блок.

Не решается.

Решается. Нет никаких объективных причин по которым в указателе может возникнуть NULL - все причина в анскилле.

registrant27492 ()
Ответ на: комментарий от shaiZaigh

Небезопасные блоки есть в стандартной библиотеке, но это всего-лишь _блоки_, а не 100% небезопасного кода

Справедливости ради, «небезопасность» легко может за пределы блоков выходить, но если писать нормально, то её можно изолировать на границе модуля.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от registrant27492

Написал - не работает.

facepalm.jpg

Ты очень далёк от понимания rust, но я всё же попробую.

Rust — это инструмент. Он не думает за тебя. Он не решает за тебя проблемы. Он предоставляет возможности! http://is.gd/i4RPwl

Можно сделать так как хочешь именно ты. http://is.gd/MDpBUs

Прекращай...

anonymous ()

Интересно, сколько людей соберется на тупняк царя и будет искренне пытаться ему что-то объяснить.

tailgunner ★★★★★ ()
Ответ на: комментарий от registrant27492

Это строки, причём убогие. Хотя объяснять это бесполезно.

А ты попытайся.

О боже, каким место у тебя в ассемблере не будет проверки на этапе конпеляции - как ты сконпелирует хренпойми что?

Справедливо.

Я сказать хотел, что в расте макросы разбираются на этапе компиляции. Поэтому, скажем, регекспы тоже можно парсить на этапе компиляции, а не в рантайме ругаться на кривой синтаксис. Примерно так же с асмом.

Как написать ретурн из цикла в функции, которая воид?

При помощи break. Или о чём ты? Ну и return в расте есть, просто он в ряде случаев не обязателен.

Ты проиграл со скобочками - либо признай, либо попытайся привести более илитные аргументы.

Ну что я могу сказать? Ты меня не переубедил - по прежнему считаю, что «выигрыш строки» не важен. Аргументов нет, признаю - это вкусовщина. Но ведь ты никогда не признаешь, что «экономить строку» такая же субъективная штука, а будешь делать упор на то, что так больше кода в экран поместится.

Ты сам назвал одну из причин - нельзя написать точку с запятой до скобочек.

Ну написать-то можно, хотя вероятность может и меньше.

Да и зачем тогда ты говорил об этом точке с запятой, если она ерунда?

Это не я начал, если что. Меня вполне устраивает то, что плюсовые компиляторы будут выдавать предупреждение.

Если можно - почему никто не юзает?

Дык, «копипаст» - тоже использование.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от DarkEld3r

Да.

Мне тебе цитатку выкатить? Зачем ты споришь.

Про это тоже было, ты невнимательно читал.

Ну дак выкатывай - каким образом можно статически определить существует ли ссылка на объект в вызванной асинхронно функции несколько раз? Сносить ли объект после неё, либо нет? Сносить ли в ней объкт или нет?

Поток логично ожидает, что раз ссылка константная, то строка останется такой как есть, но на самом деле, ты можешь её поменять.

Никакой логики в этом нет. Никто ничего не ожидает. Константная ссылка говорит лишь о твоём доступе на ro, если лагика подразумевает, что объект неменяется, то он создаётся константой.

Зачем ты мне пишешь убогую брехню во имя оправдания? Константный объект я так же не могу поменять, да и зачем мне его менять, если мне не нужно?

И к расту это не имеет никакого отношения - это просто навязанная константность ничего не отличающая от обычной константности.

Нет, это обычное RAII особого отношения к лайфтамам не имеющее.

Если это не raii, то никакого смысла в лайвтаймах нет, ибо всё просто копируется.

Чего? И в плюсах и в расте можно освободить руками в нужном месте, если захотелось.

Слишком зелёный. Мне не надо освобождать - мне надо выпилить весь убогий раст-рантайм, чтобы делать руками так, как надо мне.

Убогий раст, как и крестовый рантайм не позволяет мне это сделать. А именно это зерокост.

Меня не интересует могу я или нет - меня интересует качество автоматическйо реализации. Весь убогое владение и придумано было как кастыль для автоматического освобождения и в ручном особждении оно не нужно.

Я могу вообще ничего не особождать, если мне это не надо.

Именно поэтому присутствует unsafe. А вот чего ты упорно не хочешь понимать, так это того, что unsafe не обязан быть размазан по всему коду.

Этот unsafe говно по сравнению с unsafe сишки. Зачем мне пародиная на unsafe, если я сам решаю где у меня safe, а где unsafe?

registrant27492 ()
Ответ на: комментарий от registrant27492

Что кокнретно?

То о чём ты говорил. Безопасность каста на этапе компиляции. Или ты только про то, что «меньшие» типы в «большие» можно безопасно кастовать?

Если это не ошибка, то никакой проблемы с автокастом не будет, а если она будет, то это логическая ошибка.

При автокасте ошибка может остаться незамеченной. При явном касте есть некая надежда, что человек задумается над тем, что делает. Или по крайней мере, потом проще будет проблемное место искать.

Это значит то, что срать аллкациями на каждый чих - это свойство рантайма раста

Ты что-то выдумываешь.

Зачем ты мне что-то рассказываешь?

Не стоит этого делать, да?..

DarkEld3r ★★★★★ ()
Ответ на: комментарий от registrant27492

Мне не надо освобождать - мне надо выпилить весь убогий раст-рантайм, чтобы делать руками так, как надо мне.

Пожалуйста!

#![no_std]
#![no_core]

Реализуй своё.

anonymous ()
Ответ на: комментарий от anonymous

Ну да, но опять же в Swift есть и дженерики и алгебраические типы.

Как и в расте. Увидеть я хотел можно ли написать самому аналог ??, которые умеет разные типы возвращать.

Давай сравним, сдается мне в Rust ты так просто его не напишешь

С какой стати? Точно так же выглядеть будет, с поправкой на то, что свифт за тебя в хипе размещает, а в расте это явно делать надо:

fn foo(v: bool) -> Box<Any> {
    if v {
        Box::new(123.4)
    } else {
        Box::new("1234")
    }
}

И код будет ужасней на порядок. Впрочем как почти всегда.

Давай без передёргивания.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от anonymous

Rust — это инструмент. Он не думает за тебя. Он не решает за тебя проблемы.

Т.е. мне надо насрать тонны говна, причём убогого, чтобы это работало как не в сишки из 70-х? Отлично.

Понимаешь в чём штука, когда язык заявляет о современности, а выкатывает мне убогую пасту бородатого gis'а - нахрен он мне нужен?

Зачем ты мне это наваял, если это делается на любом куллязычке на 10строках. Тем более наваял дерьмо - я не просил &mut dest[..], &src[..] - это убожество. Я простил a, b;

А теперь добавь туда rep(rax).movsb(r13, r11).

Прекращай...

Что?

registrant27492 ()
Ответ на: комментарий от registrant27492

Ну дак выкатывай - каким образом можно статически определить существует ли ссылка на объект в вызванной асинхронно функции несколько раз? Сносить ли объект после неё, либо нет? Сносить ли в ней объкт или нет?

Владелец объекта вызывает его деструктор, владелец всегда один.

Я могу вообще ничего не особождать, если мне это не надо.

Не освобождайте, блокируйте вызов деструктора.

shaiZaigh ()
Ответ на: комментарий от anonymous

И, нахрена мне раст? Если кресты в 100раз мощнее? Да и сомневаюсь я, что рантайм там отключаемый - всё 100% сделано на уровне убогой рантайм-лапши 50% которой ллвм сворачивает, а с остальной не справиться.

registrant27492 ()
Ответ на: комментарий от tailgunner

Не, народ соберется посмотреть, как Царь в очередной раз красиво смешает с какашками тебя. И разочарованно разойдется, когда ты все стыдливо подотрешь, как обычно.

anonymous ()
Ответ на: комментарий от registrant27492

Они так же просто вычисляются автоматическими средствами.

Ага, именно поэтому статические анализаторы становятся всё сложнее.

Как ты проверишь указатель во время конпеляции?

Проверю не указатель, а наличие проверки:

fn test(ptr: Option<&i32>) {
    // Так:
    match ptr {
        Some(val) => { /*не нулл - используем*/ }
        None => { /*обрабатываем ошибку*/ }
    }

    // Или так:
    if let Some(val) = ptr {
        // не нулл - используем
    }
}

Чем это отличается от:

Тем что Choice - это (boost) variant. В общем, есть контейнер содержащий variant. Надо обходить и обрабатывать.

Нет никаких объективных причин по которым в указателе может возникнуть NULL

Да ладно? А опциональные значения?

Ну и «анскил» - это тоже вполне объективная причина.

DarkEld3r ★★★★★ ()
Ответ на: комментарий от registrant27492

Т.е. мне надо насрать тонны говна, причём убогого, чтобы это работало как не в сишки из 70-х? Отлично.

Ты сам себе противоречишь. Сначала ты хочешь всё выкинуть и написать своё. Потом чтобы всё сделали за тебя. Rust предоставляет абстракцию, над которой ты можешь сделать так, как нравиться тебе.

Понимаешь в чём штука, когда язык заявляет о современности, а выкатывает мне убогую пасту бородатого gis'а - нахрен он мне нужен?

Ты путаешь понятия современность с явным контролем, который предоставляет rust.

Зачем ты мне это наваял, если это делается на любом куллязычке на 10строках.

Тогда зачем ты в начале написал, что ты дурак?

Тем более наваял дерьмо - я не просил &mut dest[..], &src[..] - это убожество. Я простил a, b;

Потому, что в rust принято оперировать срезами, а не указателями.

А теперь добавь туда rep(rax).movsb(r13, r11).

В очередной раз ты путаешь... В языках оперируют переменными, если ты хочешь оперировать регистрами, то пиши на ассемблере. Когда компилятор будет оптимизировать код, ты точно не можешь знать где окажутся данные. Так же нельзя жёстко навязывать компилятору где хранить данные, до того как они понадобятся.

Прекращай...

Что?

Нести ахинею.

anonymous ()
Ответ на: комментарий от shaiZaigh

Владелец объекта вызывает его деструктор, владелец всегда один.

А каким образом мы можем послать в ассинхронную функцию ссылку, если мы не знаем когда она завершится?

Нам надо либо вешать что-то на её завершение, но это так же невозможно, когда можно вызвать больше одной функции. Значит надо вешать именно рантайм.

Не освобождайте, блокируйте вызов деструктора.

Я не прошу предоставить мне такую возможность - меня это мало волнует.

Вся эта мура работает на основе одной абстракции - это деструкторы, raii и вся эта байда. Но проблема в том, что для рук, где время жизни отслеживается руками - она не нужна и руки от неё не зависит. И в 99% случаев я руками сделаю лучше. Примеры я уже описывал.

Из это вытекает то, что руки > деструктора, а ваша реализация требует её(и других ограничений), а вернее она реализует автоматическую расстановку деструкторов. А раз толкается про зерокост - значит зерокост по сравнению с чем-то? С ручной расстановкой тех же кусков рантайма в тех же местах? По сравнению с другими реализациями? Но они не сравнимы, а тем что сравнимы - имеют такой же кост.

Поэтому реально любай автоматическая система сравнивается с ручкой и зерокост она только тогда, когда минимум такая же. А раз она не такая же - значит не зерокост.

registrant27492 ()
Ответ на: комментарий от DarkEld3r

А вообще принципиальная разница в том, что инициализацию в void надо писать, то есть это будет сознательное решение, а не потенциальный провтык как сейчас с отсутствием инициализации.

Если компилятор будет бить по рукам за int x;, то люди будут просто на автомате писать int x = void; вместо того, чтобы думать о наличии подходящего начального значения для x.

Причем это будут те же самые люди, которые сейчас пишут if(cond);, а потом жалуются, что компилятор позволил им поставить точку с запятой в этом месте.

Как раз поэтому их стоит, по возможности, в библиотеки выносить и делать модульными.

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

В ту же оперу идет и наличие макроса vec в Rust-е. Эдак ведь можно сказать, что не смотря на свою молодость и прогрессивность он оказался настолько убог, что в нем нет нормальных initilizer_list-ов. Приходится макросы ваять. Да еще такие, что различие в одном символе приводит к совершенно нехилой разнице в результатах:

let v1 = vec![8, 8];
let v2 = vec![8; 8];

Как по мне, так это ничем не лучше, чем решение разрешать перегружать оператор запятую в C++. И что, исходя из этого утверждать, что Rust говно, т.к. в нем точка с запятой внутри содержимого vec! меняет смысл происходящего?

Какой-то детский сад, ей богу. Я бы понял, когда в вину C++ ставили то, что константная ссылка на объект — это всего лишь read-only view. И вот в таком коде:

void f(const std::string & v) {
  const auto cp = v;
  std::this_thread::sleep_for(1s);
  ensure(cp == v); // Oops!
}
получить подарочек, т.к. объект v уже мог измениться извне.

Но нет, давайте обвинять C++ в том, что у него override недавно появился, fallthrou будет только в следующем стандарте, operator,() можно переопределять и, самое-то важное, можно ставить точку запятой после условия if-а.

eao197 ★★★★★ ()
Ответ на: комментарий от registrant27492

И, нахрена мне раст? Если кресты в 100раз мощнее?

Тогда и вали из этой темы.

Да и сомневаюсь я, что рантайм там отключаемый - всё 100% сделано на уровне убогой рантайм-лапши 50% которой ллвм сворачивает, а с остальной не справиться.

Нет там рантайма! В core связка с компилятором. Разные трейты-маркеры, пару функций, которые компилятор вызывает если в коде будет вызвана паника. Можешь хоть для стиральной машинки писать если захочешь.

anonymous ()
Ответ на: комментарий от DarkEld3r

Как и в расте. Увидеть я хотел можно ли написать самому аналог ??, которые умеет разные типы возвращать.

Можно, и функцией и оператором. Причем в Swift последние можно создавать новые, в том числе используя юникод.

С какой стати? Точно так же выглядеть будет

    if v {
        Box::new(123.4)
    } else {
        Box::new("1234")
    }
}

И

    return v ?
        123.4 :
        "1234";

Окай.

Давай без передёргивания.

Ну ладно, не на порядок, а раза в два. Ты, кстати, еще печать пропустил, там тоже добавилось бы бойлерплейта.

anonymous ()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.