Несколько файлов в (двоичном) проекте

Question

Я пытаюсь найти подходящий способ разбить мой бинарный проект на несколько файлов. В книге Rust 7.1 Пакеты и ящики начинается с включения примера создания проекта bin с автомобилем go, но остальные примеры - lib. Меня не волнует иерархия моего кода, так как я не выставляю его в библиотеке. Другие, более старые вопросы ( например ) упоминают, что вам обычно нужно <module_name>/mod.rs; хотя это не является строго обязательным, это кажется подходящим для больших библиотечных проектов.

У меня есть три файла:

src / main.rs:

mod A;
mod B;

fn main() {
    let a = A::A { a: 123 };
    let b = B::B { b: 3.14 };

    println!("{:?}", a);
    println!("{:?}", b);
}

src / A.rs:

use crate::B;

#[derive(Debug)]
pub struct A {
    pub a : u32
}

impl From<B::B> for A {
    fn from(b : B::B) -> A {
        A { a: b.b as u32 }
    }
}

src / B.rs:

use crate::A;

#[derive(Debug)]
pub struct B {
    pub b : f32
}

impl From<A::A> for B {
    fn from(a : A::A) -> B {
        B { b: a.a as f32 }
    }
}

Это работает как ожидается (предупреждения о случаях змеи были удалены для краткости):

$ cargo run
A { a: 123 }
B { b: 3.14 }

Однако, это выглядит как песня и танец немного больше, чем необходимо: квалификационные ссылки со своим именем модуля для каждой ссылки кажутся чрезмерными. Я бы предположил, что мог бы сделать что-то вроде mod A::A или use A::* для «импорта» типов, функций и т. Д. c.

Является ли это ожидаемым идиоматическим c способом разделения кода?

Редактировать:

В ходе обсуждения я обновил свой источник для использования use a::*. Новый код:

main.rs:

mod a;
mod b;
use a::*; // !
use b::*; // !

fn main() {
    let a = A { a: 123 };
    let b = B { b: 3.14 };

    println!("{:?}", a);
    println!("{:?}", b);
}

a.rs:

use crate::b::*;

#[derive(Debug)]
pub struct A {
    pub a : u32
}

impl From<B> for A {
    fn from(b : B) -> A {
        A { a: b.b as u32 }
    }
}

b.rs:

use crate::a::*;

#[derive(Debug)]
pub struct B {
    pub b : f32
}

impl From<A> for B {
    fn from(a : A) -> B {
        B { b: a.a as f32 }
    }
}

Включая как mod a;, так и use a::*; (изменено в соответствии с соглашением snake_case, но важно предотвратить конфликт имен с ранее введенным в верхний регистр модулем A конфликтуя со структурой A (все еще в верхнем регистре), теперь можно ссылаться на компоненты без квалификации.