Телеграмм чат группы rustlang

> Мы считаем важным, чтобы вызов С++ из Rust соответствовал следующим критериям:
1. Слово "unsafe" не должно быть нужно до тех пор, пока мы не делаем что-то менее безопасное, чем нормальный С++
....
....
2. ....
3. ....

Я бы это так перевел. Мб я что-то совсем не понмаю, но, кажется, это значит "Мы хотим вызывать любой С++ код без слова unsafe"

источник

16:01пожаловаться #5

ВК

Василий Карбовничий... in Rust — русскоговорящее сообществo

Vlad Beskrovnyy

Я примерно так же перевел. Мол у нас все на плюсах. и это для нас обычный код. он не unsafe. поэтому мы не хотим чтобы слово unsafe вводило всех в заблуждение

источник

16:05пожаловаться #6

Agrailag in Rust — русскоговорящее сообществo

Василий Карбовничий

стадия отрицания

источник

16:06пожаловаться #7

Vlad Beskrovnyy in Rust — русскоговорящее сообществo

Хотяяя, я, кажется, все-таки неправильно понял. Имеется в виду, что unsafe не должен быть нужен только из-за самого факта вызова С++. Как сложно этих плюсовиков понять иногда....

источник

16:07пожаловаться #8

Vladimir in Rust — русскоговорящее сообществo

Vlad Beskrovnyy

Мне кажется они просто хотят сейфовый врапер, а не как-то патчить код раста

источник

16:07пожаловаться #9

Oleg Andreev in Rust — русскоговорящее сообществo

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

источник

16:08пожаловаться #10

ВК

Василий Карбовничий... in Rust — русскоговорящее сообществo

Vladimir

Мне кажется они просто хотят сейфовый врапер, а не как-то патчить код раста

safe!(%плюсовый_код%)

источник

16:08пожаловаться #11

Oleg Andreev in Rust — русскоговорящее сообществo

Ровно как если либа растовая и внутри на трансмьютах

источник

16:08пожаловаться #12

Vlad Beskrovnyy in Rust — русскоговорящее сообществo

Vladimir

Мне кажется они просто хотят сейфовый врапер, а не как-то патчить код раста

нутиптого

источник

16:08пожаловаться #13

Alex Zhukovsky in Rust — русскоговорящее сообществo

Andrey

use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            Cons(_, item) => Some(item),
            Nil => None,
        }
    }
}

fn main() {
    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));

    println!("a initial rc count = {}", Rc::strong_count(&a));
    println!("a next item = {:?}", a.tail());

    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));

    println!("a rc count after b creation = {}", Rc::strong_count(&a));
    println!("b initial rc count = {}", Rc::strong_count(&b));
    println!("b next item = {:?}", b.tail());

    if let Some(link) = a.tail() {
        *link.borrow_mut() = Rc::clone(&b);
    }

    println!("b rc count after changing a = {}", Rc::strong_count(&b));
    println!("a rc count after changing a = {}", Rc::strong_count(&a));

    // Uncomment the next line to see that we have a cycle;
    // it will overflow the stack
    // println!("a next item = {:?}", a.tail());
}

RefCell<Rc> назвать незаметным сложно

источник

16:08пожаловаться #14

Alex Zhukovsky in Rust — русскоговорящее сообществo

Andrey

use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            Cons(_, item) => Some(item),
            Nil => None,
        }
    }
}

fn main() {
    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));

    println!("a initial rc count = {}", Rc::strong_count(&a));
    println!("a next item = {:?}", a.tail());

    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));

    println!("a rc count after b creation = {}", Rc::strong_count(&a));
    println!("b initial rc count = {}", Rc::strong_count(&b));
    println!("b next item = {:?}", b.tail());

    if let Some(link) = a.tail() {
        *link.borrow_mut() = Rc::clone(&b);
    }

    println!("b rc count after changing a = {}", Rc::strong_count(&b));
    println!("a rc count after changing a = {}", Rc::strong_count(&a));

    // Uncomment the next line to see that we have a cycle;
    // it will overflow the stack
    // println!("a next item = {:?}", a.tail());
}

trait Node<T> {}

#[derive(Debug)]
struct Nil;

impl<T> Node<T> for Nil {}

#[derive(Debug)]
struct LinkedList<T, U: Node<T>> {
    head: T,
    tail: U,
}

fn nil() -> Nil {
    Nil {}
}

fn cons<T, U: Node<T>>(head: T, tail: U) -> LinkedList<T, U> {
    LinkedList {
        head,
        tail
    }
}

impl<T, U: Node<T>> Node<T> for LinkedList<T, U> {}

fn main() {
    let list = cons(10, cons(20, nil()));
    println!("{:?}", list);
}

написал такой без рц и никаких стаковерфлоу

источник

16:09пожаловаться #15

Emmanuel Goldstein in Rust — русскоговорящее сообществo

Alex Zhukovsky

trait Node<T> {}

#[derive(Debug)]
struct Nil;

impl<T> Node<T> for Nil {}

#[derive(Debug)]
struct LinkedList<T, U: Node<T>> {
    head: T,
    tail: U,
}

fn nil() -> Nil {
    Nil {}
}

fn cons<T, U: Node<T>>(head: T, tail: U) -> LinkedList<T, U> {
    LinkedList {
        head,
        tail
    }
}

impl<T, U: Node<T>> Node<T> for LinkedList<T, U> {}

fn main() {
    let list = cons(10, cons(20, nil()));
    println!("{:?}", list);
}

написал такой без рц и никаких стаковерфлоу

Напихай в него побольше элементов и получишь стаковерфлоу на этапе компиляции, лол

источник

16:11пожаловаться #16

Alex Zhukovsky in Rust — русскоговорящее сообществo

Emmanuel Goldstein

Напихай в него побольше элементов и получишь стаковерфлоу на этапе компиляции, лол

да не получишь, ArrayLen же как-то живет)

источник

16:11пожаловаться #17

Вафель in Rust — русскоговорящее сообществo

Alex Zhukovsky

trait Node<T> {}

#[derive(Debug)]
struct Nil;

impl<T> Node<T> for Nil {}

#[derive(Debug)]
struct LinkedList<T, U: Node<T>> {
    head: T,
    tail: U,
}

fn nil() -> Nil {
    Nil {}
}

fn cons<T, U: Node<T>>(head: T, tail: U) -> LinkedList<T, U> {
    LinkedList {
        head,
        tail
    }
}

impl<T, U: Node<T>> Node<T> for LinkedList<T, U> {}

fn main() {
    let list = cons(10, cons(20, nil()));
    println!("{:?}", list);
}

написал такой без рц и никаких стаковерфлоу

Это обычно HList'ом называется... И по сути это тупл

источник

16:12пожаловаться #18

Alex Zhukovsky in Rust — русскоговорящее сообществo

если ты сделаешь очень большой КОНСТАНТНЫЙ список тогда мб и да

источник

16:12пожаловаться #19

Alex Zhukovsky in Rust — русскоговорящее сообществo

Вафель

Это обычно HList'ом называется... И по сути это тупл

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

источник

16:12пожаловаться #20