Ну, например const у глобальных переменных, глобальные переменные с одинаковыми именами без extern в разных единицах трансляции. Оно откомпилируется, но не слинкуется.
SDCC.

Угу:

В Rust вообще есть очень "приятная" штука, причем вне блока unsafe - "затенение" переменной.
После такого так и хочется вспомнить какой-либо бейсик..
Я даже представить не могу, чтобы где-то в программе мне захотелось переменную в пределах видимости переделать в переменную другого типа.
Да и вообще, в части терминологии, в Расте столько занятного, что слова порой заканчиваются.

fn main() {
println!("Shadowing!");

let mut x: i32 = 5; // это изменяемая переменная. Если Вы не знали, что переменные могут быт неизменяемыми - Вы Раст не видели.
println!("x = {}", x);

x = 7; // допустимо присвоение значения
println!("x = {}", x);

let x: i32 = 8; // тут мы говорим, что x уже неизменяемая переменная - нормально, да?
println!("x = {}", x);

x = 9; // увы - низя присвоить
println!("x = {}", x);

let x = "Затенение"; // ха-ха - "затеняем" i32 в String
println!("x = {}", x);


} // main

Бывает, но не все же так ужасно
- Не понимаю чего так все все восхищаются Карузо. Слуха у него нет, голоса нет, картавит, шепелявит, фальшивит...
- А где ты его слышал?
- Да Рабинович вчера напел.

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


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

Так не с бухты-барахты написал, а посмотрел на примеры программ. Первое, что бросилось в глаза - изобилие восклицательных знаков,
прям не программа. а обращение ЦК КПСС к народу по случаю очередной годовщины. Но после общепризнанного ошибочного включения 'println'
в Паскаль, writeln намекает, что разработчикам в детстве сильно нравился Васик. Синткасис в соновном сишный, слегка разбавленный
паскалеобразными объявлениями типов. Пробежался наискось по оглавлению документации - что-то напоминает очередной язык, который позиционируется как самый быстрый системный язык, который по сложившейся традиции тащит всякий непотреб в виде динамического типов или встроенной потокобезопасности.

По сути язык программирования, можно сравнить с конструктором лего, где его элементы соответсвуют одной или нескольким машинным командам, либо сравнительно небольшому набору (пролог, эпилог функций, фрейм стека для доступа к локальным переменным и прочее). И чем полнее коллекция таких элементов тем богаче язык. Это такие языки как к примеру тот же С/С++ или Объект-Паскаль.
"Богатые возможности" языков в виде "управляемой памяти" или "динамических типов", это уже увесистые кирпичи в таком конструкторе.
Причем ирония состоит в том, что апологеты таких языков еще утверждают что частое использование reinterpret_cast - плохой стиль программирования,
хотя сами употребляют его перманентно по умолчанию, скрыв от программиста.
Поэтому утверждения о силе и мощи этих языков все же спорны. Как по мне, язык без кирпичей и гибче и богаче, и отличаются такие языки лишь синтаксисом.

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


Плохой стиль программирования - это ручное приведение типов, но никак не автоматическая типизация. В ручном приведении, особенно таком, как reinterpret_cast, а хуже того - C-cast ни компилятор, ни рантайм не знают что там к чему приводится и как, вся ответственность лежит на программисте.
А в автоматическом преобразовании типов всем рулит автомат(а не человек), который и отвечает за корректность работы этого механизма. Динамическая типизация - это динамический полиморфизм - очень мощная техника на нынешнее время, без нее сейчас никак.


Самый богатый язык и без кирпичей вообще - это машинный код. Без запретов, без ограничений, без правил.

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

Золотая середина это такая, где программист и процессор делают минимум работы, а компилятор - максимум.
Но и тут приходится искать середину, отдавая доп. работу либо процессору, либо компилятору, либо программисту, иначе программы либо очень тормозят, либо очень долго пишутся и долго ищутся и правятся баги, либо очень долго компилируются.
Задача современных языков - как раз таки найти эту середину и каждый язык решает ее по своему, и не каждое такое решение подходит под конкретную задачу или конкретному программисту. Многие настолько зависимы от С, что даже плюсы им не под силу, не говоря уже про другие языки со слегка другим синтаксисом, он им гораздо важнее других вещей. Я их понимаю, сам такой, но все равно пытаюсь осваивать.

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


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


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

Это еще одно замечательное свойство С/С++: за ним всегда приблизительно видны те ассемблерные квантики, которые он будет генерировать.

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


Точно такие же расходы(или больше) будут, если эту динамику сделать вручную на С или на асме. А там, где рантайм-поддержка на нужна - компилятор все сделает сам и дотошно проверит программиста, чтобы последний не тупанул, или уменьшит вероятность тупняка.


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

Согласитесь, что про программирование меги на расте Вы слегка погорячились.


Вы опять уводите в сторону: на С/С++ эту динамику не нужно делать, потому что он не поддерживает динамическую типизацию принципиально.
Динамическая типизация позволяет сделать короче исходный текст программы за счет увеличения рабочего кода и скорости выполнения.
Сомнительное удовольствие. Я уж лучше напишу имя второй переменной.


У ассемблера предусмотрена возможность непосредственной вставки (DB, DW) не только недокументированной инструкции,
но и даже отсутствующей в машинном коде инструкции, если вдруг такая бы появилась. Не проще ли считать ассемблер просто машинным кодом та и все.

Сообщение отредактировал aiwa - Sep 14 2016, 08:47

https://github.com/avr-rust/rust https://github.com/avr-llvm/llvm пока что криво и с напильником, но работает. Москва тоже не сразу строилась


Можно пример кода? а то я на пальцах плохо понимаю.


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

Ох как резко то всё в холливар скатывается, когда brag начинает рассказывать о новых модных языках и лямбдах в С++ )))))))))

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

Судя по конфигурационному файлу пока еще не криво: бэкенд-компилятор стандартный LLVM, а фронт-енд компилятор - СLang или GCC.
Таким макаром можно писать для AVR хоть на турецком. Посмотрим, когда построится Москва, сколько прогрессивного будет зарублено
и насколько он будет отличаться от собратьев.



Берем пример из раста подаваемый динамическое типизирование как прогрессивное преимущество:
{
а = 5; // это тип u32

a = "abcd"; // а это та же переменная, но имеющая совершенно другой тип.
}

с С++ уже надо вводить другую переменную:
{
u32 а = 5; // это тип u32

char b[] = "abcd"; //
}

C++ выделяет в фрейме стека 4 байта для переменной а и на этом накладные расходы заканчиваются. Информацию об "а" он хранит во время компиляции
и просто генерирует команды 32-битной обработки. Раст же поместит в 4-байта в стеке указатель на участок памяти, который содержит непосредственно саму
переменную "а", и информацию о ее типе, скорее всего в виде таблицы вызовов кода команд 32-ти битной обработки. Грубо говоря оформление типа u32
в виде класса с виртуальными функциями базовых операций 32-х разрядной арифметики.
Поэтому вместо одной ассемблерной команды для a+=5 в случае статического типизирования, раст вынужден будет выполнять call или jump на эту функцию сложения u32-типа.
Могу ошибаться, но мелкософтные делфи, которые обозвали шарпом делают именно так: Все типы происходят от одного предка. Оставленные для совместимости "int" да "char" соответствуют классам TInt и TChar.
И запись "int a = 5" означает "создать в управляемой куче объект класса Tint и инициализировать его 5." Названия, естественно, условны - передана лишь суть.


Так вроде бы и не сплеча: предварил, что языка не знаю и оцениваю только синтаксис. Причем такая оценка априори субъективна.

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


Сообщение отредактировал aiwa - Sep 14 2016, 13:48