pub mod fiasco
Лучший язык, в котором правильно сделаны модули (ну или неймспейсы) - Кложа. Один файл === один неймспейс. Неймспейс может называться только так, как называется файл, и никак иначе. И лежать он должен тоже ровно по пути пакета. То есть (ns me.tonsky.hello) может и должен лежать в me/tonsky/hello.clj и нигде иначе. Сначала меня это почему-то напрягло - эй! свободу ограничивают! а как же самовыражение??? Это при том что в остальном Кложа - довольно либеральный язык и позволяет любую другую дичь творить спокойно и вообще говоря это чуть ли не единственное место, где абстракция «как организовать свой проект на файловой системе» протекла в язык, который, вообще говоря, весь такой интерпретируемый, динамичный, код может есть с руки и про файлы ничего не знает.
Но потом я проникся и оценил, особенно когда в других языках поработал. Кайф в том, что это не позволяет разводить бардака. Потому что в жизни, даже если все люди хорошие, рукопожатные и намерения у всех без исключения самые добрые, если бардак физически что-то не мешает развести - его разведут. Ну вот Кложа мешает. Живите с этим. И живут! И как живут!
Тут-то судьба забросила меня в Балтийское море, на остров Котлин. У Котлина какой основополагающий принцип? Если где-то что-то запрещают, у нас разрешают! Все обиженные, обездоленные приходите к нам и творите что хотите. Этот же принцип применен и к файловой системе. В Джаве ведь как? Один файл == один класс. Какое расточительство! В Котлине один файл == сколько угодно классов, объектов, функций, констант и чего угодно еще. Более того, файл может объявлять объекты в пакете, в котором он даже не находится. То есть какой-нибудь src/main/kotlin/me/tonsky/hello.kt может спокойно объявлять package go.fuck.yourself; и никому за это ничего не будет!
Что же тут не так? Помимо самоочевидного бардака, становится довольно сложно понять, где что находится. Скажем, ищу я класс me.tonsky.Draggable. Смотрю в me/tonsky/ папку а там layout.kt, main.kt и scene.kt. Ну офигеть! Класс может быть в любом. То есть на самом деле это не один файл содержит множество объектов. Это один модуль размазан на несколько файлов с ничего не говорящими названиями. Разница тонкая, но существенная.
Вы, конечно, скажете: дисциплина, братан! Большие, важные классы рассовывай как в Джаве, по классу на файл. А всякую мелочевку и сопутствующий хлам клади там же рядом, чтобы файлов не плодить. Но это ведь еще хуже! Большие классы я как-нибудь уж запомню, а вот маленькие вещи хотелось бы как раз уметь находить как-то более предсказуемым способом.
Все это, конечно стимулирует продажу IDE от одноименной компании, но почувствуйте разницу! Язык, разработанный на деньги IDE вендора, и язык, который при разработке не предполагал, что у вас вообще будет какой-то редактор (а судя по форматированию классов в clojure.lang писал его Рич в блокноте и пропорциональным шрифтом).
А потом вскрывается еще одна беда - разные файлы-то, получается, срут в общее пространство имен! То есть если ты в oops.kt написал val default = 1, то у тебя вдруг перестал работать wtf.kt про который ты даже не слышал, просто потому что он тоже определил val default = 0 когда-то а в алфавите W идет после O. Никакой изоляции. Не будешь же, в самом деле, по папке с одним файлом заводить на каждый класс. Сомнительное, короче, удобство.
А потом я пришел в Раст. Его систему с модулями я настолько не понял, что специально сейчас сидел перечитывал. Итак:
Официальная документация объясняет как объявлять модули, в том числе вложенные, внутри одного файла. Объяснению посвящены четыре главы из пяти. Очень подробно и наглядно объясняется все, кроме того, зачем кому-то когда-то это может в принципе понадобиться. Естественно никто так не делает.
Раст, как и многие начинающие программисты, живет в заблуждении, что модули бывают вложенными. И что эта вложенность может быть зачем-то нужна, что модуль-родитель и модуль-ребенок связаны чем-то большим, чем общим префиксом имени.
Как следствие, Раст позволяет ссылаться на над/под-модули с помощью относительных путей. Я тоже думал, что это давно пройденный урок и уже все без исключения на планете знают, насколько это хреновая идея: относительные пути не ищутся, легко путаются, плохо рефакторятся, плохо копи-пастятся и вообще слишком хрупки и зависимы от контекста, чтобы экономия пары-тройки букв оправдывала их существование. Просто сразу нет.
Раст позволяет импортить как модули, так и отдельные типы. Причем синтаксис общий. Что создает еще больше путаницы. Модуль - это неймспейс, средство изоляции имен, не больше. Тип - это уже что-то полезное. Давайте уже как-то разделять.
Видимо, по старой доброй C-традиции, в Расте сделали include вместо import. То есть когда ты говоришь use module, ты не просто создаешь некий синтаксический псевдоним, действующий исключительно до конца файла для разрешения имен. Нет, ты буквально добавляешь все что было в module в текущий файл. Не сослался, а скопировал и вставил себе. Это плохо, потому что вместо понятной модели «есть штука, она одна и существует там, где написана, плюс есть способы сослаться на штуку, псевдонимы, они могут быть любыми» мы получаем «одна и та же штука, размноженная N раз в N местах». А я еще удивлялся, почему одни и те же функции и из std::, и из core:: торчат. Вот почему!
Ну и на вишенку, модуль определяется не в том файле, где он написан, а в его родителе! Скажем, если вы сделали govno.rs, и написали в нем код, вы потом идете в lib.rs и в нем уже пишете mod govno;. Или, если хотите, определить его публично, pub mod govno;. То есть понимаете, да? Если вам интересно, торчит ли govno.rs наружу, вы не можете зайти в него и посмотреть. Вам нужно сообразить, кто его родитель, найти в этом родителе (в произвольном достаточно месте) надпись mod govno; и там узнать, есть ли префикс pub у него. Если вы хотите создать какой-то достаточно глубокий модуль, скажем, kak::zhe::vse::zaebalo, вам нужно пойти и создать всех промежуточных родителей и в каждом написать ровно по одной строчке:
lib.rs:
pub mod kak;
kak.rs:
pub mod zhe;
kak/zhe.rs:
pub mod vse;
kak/zhe/vse.rs:
pub mod zaebalo;
kak/zhe/vse/zaebalo.rs:
В каком-то смысле это все следствие относительности имен и «удобства» их использования. В каком-то - следствие концепции вложенности. Этот пример прекрасно ее иллюстрирует: слишком много возни, слишком много вопросов, а в чем профит не ясно. Скажем, если модуль kak будет публичным, zhe - нет, vse - тоже нет, и наконец zaebalo - публичным. Смогу я его в конце концов заимпортить? Если нет, то в чем смысл pub в pub mod zaebalo;? Если да, то в чем смысл того, что промежуточные модули - приватные? И сколько файлов мне придется посетить, чтобы вычислить, доступен ли zaebalo для импорта?
Короче. Я не очень понимаю, как тут можно запутаться, но опыт показывает что путаются все и постоянно. Модули - плоские. Пути - абсолютные. Один файл === один модуль. Все, что надо знать про модуль, написано в нем самом. Будете делать свой язык - смотрите не объебитесь.