Corrode, проект транслятора из C в Rust, получил финансирование Mozilla

Ну тащемта, он прав насчет выразительности (сам того не зная, ЛОЛ).

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

Вот смотри, списки: Вставка в зад, Rust:

    /// Adds the given node to the back of the list.
    fn push_back_node(&mut self, mut node: Box<Node<T>>) {
        unsafe {
            node.next = None;
            node.prev = self.tail;
            let node = Some(Shared::new(Box::into_raw(node)));

            match self.tail {
                None => self.head = node,
                Some(tail) => (**tail).next = node,
            }

            self.tail = node;
            self.len += 1;
        }
    }

То же на Си:

// Insert an item to a list
void bgrt_item_insert(bgrt_item_t *item, bgrt_item_t *head)
{
    // A tail of a list
    bgrt_item_t * tail;
    tail = head->prev;
    // Insert an item between a head and a tail
    item->prev = tail;
    item->next = head;

    head->prev = item;
    tail->next = item;
}

Вырезать из списка на Rust:

    fn pop_front_node(&mut self) -> Option<Box<Node<T>>> {
        self.head.map(|node| unsafe {
            let node = Box::from_raw(*node);
            self.head = node.next;

            match self.head {
                None => self.tail = None,
                Some(head) => (**head).prev = None,
            }

            self.len -= 1;
            node
        })
    }

void bgrt_item_cut(bgrt_item_t *item)
{
    bgrt_item_t * prev;
    bgrt_item_t * next;
    prev = item->prev; //Previous item
    next = item->next; //Next item

    next->prev = prev;
    prev->next = next;

    item->prev = item;
    item->next = item;
}

То же на Си:

3 потенциальных сегфолта.

Интересно, а почему так:

void bgrt_item_cut(bgrt_item_t *item)
{
    bgrt_item_t * prev;
    bgrt_item_t * next;
    prev = item->prev; //Previous item
    next = item->next; //Next item

void bgrt_item_cut(bgrt_item_t *item)
{
    bgrt_item_t * prev = item->prev; //Previous item
    bgrt_item_t * next = item->next; //Next item

Интересно, а почему так:

Потому-что как у K&R, добавляет илитарности.

Не все компиляторы понимают современные диалекты Си.

Где?

Не все компиляторы понимают современные диалекты Си.

Т.е. C89, например, это современный диалект С? Збс.

У каждого компилятора, фактически, свой стандарт языка.

Некоторые требуют инициализацию константой.

Всегда ваш, К.О.

У каждого компилятора, фактически, свой стандарт языка

Да, но в виде расширения основного, например, того же С89. И подстраивание под какие-то левые компиляторы только делает код менее переносимым.

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

Зато на расте я могу писать

vec.iter().filter().map()

Кстати, где они?

Так это обычная цепочка вызовов же...

map(filter(iter(vec)));

Шок. Нет.

Ну, тебе виднее.

А от чего шок, собственно?

Шок для вас. Ибо вы сравниваете совершенно разные вещи.

Это был пример лаконичного кода. Покажите аналог этого кода на С:

let a = [1i32, 2, -5, 100, -100];
for n in a.into_iter().filter(|x| **x > 0).map(|x| x * 2) {
    print!("{} ", n);
}

// 2 4 200 

Не покажу. Лямбды не завезли.

Цитирую:

Ну тащемта, он прав насчет выразительности (сам того не зная, ЛОЛ).
В задачах низкоуровневого системного программирования С более выразителен, чем Rust.

Corrode, проект транслятора из C в Rust, получил финансирование Mozilla (комментарий)

Как будите отнекиваться теперь?

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

В «низкоуровневом системном программировании» нет необходимости прохода по набору данных? Окей...

Как вам такой пример:

match v {
    0...999 => println!("some 1"),
    1000...1999 => println!("some 2"),
    2000...2999 => println!("some 3"),
    _ => println!("error"),
}

И это я закрывая глаза на goto clear_data;.

Или все ваши выкрики с галёрки ограничиваются применимостью раста для микроконтроллеров? Ну тут не скажу. Возможно в чём-то Си будет привычней.

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

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

В таких случаях будет просто

static const some_struct_t table[TABLE_SZ] = 
{
    //XMACRO USED HERE
};
/*...*/
    n = TABLE_SZ;
    while(n--)
    {
        do_something(table+n);
    }

Ну то есть для микроконтроллеров с парой КБ памяти Rust не годится. Ок. Тут спорить не буду.

Не только на микроконтроллерах.

В любых системах реального времени стараются избежать циклов где только можно.

Количество оперативной памяти тут не при чём.

Это довольно узкая область. И в неё Rust не метит. Его цель убить Си на x86, ARM, etc. То есть десктоп, мобилки, сервера и тд.

Сколько таких недоязыков уже было...

C и C++ созданы для того, чтоб писать программы, и поэтому они востребованы, мощны и вечны.

а смешные недоязычки, созданые ололошами с полыхающими пуканами чтоб «убить С/С++» появляются, газуют в лужи и исчезают.

В данном случае у раста много шансов. И я делаю всё, чтобы их стало больше.