Rust как сделать макрос
Предисловие
Прежде всего давайте определим задачу, которую мы будем решать с помощью макросов: мы попробуем определить некоторый абстрактный RPC API в виде трейта, который потом реализует как серверная часть, так и клиентская; а процедурные макросы, в свою очередь, помогут обойтись нам без кучи шаблонного кода. Несмотря на то, что реализовывать мы будем несколько абстрактный API, задача на самом деле довольно жизненная, и, помимо прочего, идеально подходит для демонстрации возможностей процедурных макросов.
Сам API у нас будет выполнен по очень простому принципу: есть 4 типа запросов:
- GET запросы без параметров, например: /ping .
- GET запросы с параметрами, параметры к которым будут передаваться в виде URL query, например: /status?name=foo&count=15 .
- POST запросы без параметров.
- POST запросы с параметрами, которые передаются в виде JSON объектов.
Во всех случаях сервер будет отвечать валидным JSON объектом.
В качестве серверного бэкенда мы будем использовать крейт warp .
В идеале хочется получить нечто подобное:
Для начала напомню, что процедурными макросами в Rust'е называются специальные плагины к компилятору, которые получают на вход некоторое синтаксическое дерево, с которым производят некоторые манипуляции, а затем возвращают модифицированное дерево для последующей компиляции.
В рамках этой статьи мы будем рассматривать два вида таких макросов: derive-макросы, позволяющие автоматически реализовать трейт для какой-то структуры (многим они уже знакомы по serde ), и атрибутные макросы, которые можно использовать для большего спектра задач.
Разбираем методы интерфейсного трейта
Для начала напишем код, который будет разбирать отдельный метод трейта с интерфейсом, который в общем случае будет выглядеть примерно так:
И объявим набор атрибутов для метода, которые мы можем указывать:
Парсить мы будем сигнатуру функции, которая имеет тип syn::Signature , и в этом случае полностью положиться на помощь darling'а мы уже не сможем: большую часть разбора синтаксического дерева придется писать самим, но вот атрибуты методов легко можно получить с помощью знакомого нам уже FromMeta .
А чтобы среди атрибутов метода отыскать нужный нам http_api_endpoint мы напишем небольшую вспомогательную функцию. Мы будем преобразовывать тип нашего атрибута в syn::NestedMeta для того, чтобы была возможность обрабатывать вложенные метаданные вида (foo = "bar", boo(first, second)) .
Теперь можно переходить к разбору сигнатуры. Как я уже упоминал выше, нам нужно рассмотреть
два варианта — с дополнительным аргументом и без оного:
Заключение
Никто не мешает при помощи макросов пойти дальше и выводить еще и openapi или swagger
спецификацию для типажей-интерфейсов. Но мне кажется, в этом случае лучше пойти другим путем и по спецификации написать генератор Rust кода, это даст больший простор для маневров.
Если писать этот генератор в виде build зависимости, то можно воспользоваться библиотеками
syn и quote , таким образом, написание генератора будет очень комфортным и простым. Впрочем, это уже вдаль идущие размышления :)
Полностью рабочий код, примеры которого приводились в данной статье можно найти по этой
ссылке.
Cargo уже взрослый
Cистема сборки компилятора и стандартной библиотеки Rust была переписана на сам Rust с использованием Cargo — стандартного пакетного менеджера и системы сборки, принятой в экосистеме Rust.
С этого момента Cargo является системой сборки по умолчанию. Это был долгий процесс, но он наконец-то принес свои плоды. Авторы утверждают, что новая система сборки используется с декабря прошлого года в master ветке репозитория и пока все идет хорошо.
Теперь файл с названием build.rs , лежащий на одном уровне с Cargo.toml будет интерпретироваться как билд скрипт.
Уже даже завели уже вмержили pull request на удаление всех makefile; интеграция запланирована на релиз 1.17.
Все это готовит почву к прямому использованию пакетов из crates.io для сборки компилятора, как и в любом другом проекте. А еще это неплохая демонстрация возможностей Cargo.
Возможности наших макросов для RUST
Полный контроль отдачи, любая чувствительность мыши и FOV.
Автоматически определит оружие в руках и включит нужный макрос. (Есть альтернативный метод переключения на кнопках)
Имеет маленький удобный оверлей где видно активное оружие, все ваши бинды и выставленные прицелы и насадки.
Множество приятных дополнений таких как: включение прицела в центре экрана с кастомизацией, фастап в любой материал нажатием одной кнопки и антиафк.
Макросы в Rust
Вернемся к нашим баранам.
С самого начала программисты хотели писать поменьше, а получать побольше. В разное время под этим понимали разные вещи, но условно можно выделить два метода сокращения кода:
- Выделение логически законченных частей кода для многократного использования
- Выделение несамостоятельных фрагментов кода, ничего не значащих вне своего контекста
Первый принцип больше соответствует традиционной декомпозиции программ: разделению кода на функции, методы, классы и т. п.
К второму можно отнести макросы, инклуды и прочий препроцессинг. В языке Rust для этого предусмотрено три механизма:
- Обычные макросы
- Процедурные макросы
- Плагины компилятора
Обычные макросы (в документации macro by example) используются, когда хочется избежать повторения однообразного кода, но выделять его в функцию нерационально, либо невозможно. Макросы vec! или println! являются примерами таких макросов. Задаются декларативным образом. Работают по принципу сопоставления и подстановки по образцу. Реализация основана на базе работы 1986-го года, из которой они получили свое полное название.
Процедурные макросы являются первой попыткой стабилизации интерфейса плагинов компилятора. В отличие от обычных декларативных макросов, процедурные макросы представляют собой фрагмент кода на Rust, который выполняется в процессе компиляции программы и результатом работы которого является набор токенов. Эти токены компилятор будет интерпретировать как результат подстановки макроса.
На данный момент компилятором предусмотрено только использование процедурных макросов для поддержки пользовательских атрибутов derive . В будущем количество сценариев будет расширяться.
Плагины компилятора являются самым мощным, но сложным и нестабильным (в смысле API) средством, которое доступно только в ночных сборках компилятора. В документации приведен пример плагина поддержки римских цифр в качестве числовых литералов.
Пример макроса
Поскольку макросы не ограничены лексическим контекстом функции, они могут генерировать определения и для более высокоуровневых сущностей. Например, макросом можно определить целый impl блок, или метод вместе с именем, списком параметров и типом возвращаемого значения.
Макро-вставки возможны практически во всех местах иерархии модуля:
Макросы довольно часто применяются в библиотеках, когда приходится определять однотипные конструкции, например серию impl для стандартных типов данных.
Например, в стандартной бибилотеке Rust макросы используются для компактного объявления реализации типажа PartialEq для всевозможных сочетаний срезов, массивов и векторов:
Мы же рассмотрим более показательный пример. А именно, реализацию макроса vec! , который выполняет роль конструктора для Vec :
Шаблон сопоставления напоминает регулярные выражения с возможными квантификаторами * и + . Кроме метапеременных через двоеточие указываются еще предполагаемые типы (designator). Например, тип expr соответствует выражению, ident — любому идентификатору, а ty — идентификатору типа. Подробнее про синтаксис макросов написано в руководстве по макросам и в документации, а в porting guide можно найти актуальный разбор макроса vec! с описанием каждой ветви.
Указание типов метапеременных позволяет более точно определить область применимости макроса, а также отловить возможные ошибки.
Чистота и порядок
Макрос в Rust должен быть написан так, чтобы генерировать лексически корректный код. Это означает, что не всякий набор символов может быть валидным макросом. Это позволяет избежать многих проблем, связанных с использованием препроцессора в C/C++.
В безобидном с виду фрагменте кода мы вместо одного элемента вытащили два, вычислили не тот результат, какой ожидали, а последней строкой еще и спровоцировали неопределенное поведение. Три серьезных ошибки на две строки кода — это как-то многовато.
Конечно, пример синтетический, но мы все прекрасно знаем, как постоянная смена требований и людей в команде могут запутать даже хороший некогда код.
Корень зла лежит в том, что препроцессор C/C++ орудует на уровне текста, а компилятору приходится разбирать уже испорченную препроцессором программу.
Напротив, макросы в Rust разбираются и применяются самим компилятором и работают на уровне синтаксического дерева программы. Поэтому описанные выше проблемы не могут возникнуть в принципе.
- не затеняют переменные
- не нарушают порядка разбора условий
- не дают скрытых побочных эффектов
- не приводят к неопределенному поведению
Такие макросы называются гигиеничными. Одним из следствий является то, что макрос не может объявить переменную, видимую за его пределами.
Зато в пределах макроса можно заводить переменные, которые гарантировано не пересекутся с переменными выше по коду. Например, описанный выше макрос vec! можно переписать с использованием промежуточной переменной. Для простоты рассмотрим только основную ветвь:
Таким образом, код
после подстановки макроса будет преобразован в
Процедурные макросы
Когда возможностей обычных макросов недостаточно, в бой идут процедурные.
Как уже было сказано выше, процедурные макросы так называются, потому что вместо простой подстановки они могут вернуть совершенно произвольный набор токенов, являющийся результатом выполнения некоторой процедуры, а точнее функции. Эту функцию мы и будем изучать.
С точки зрения пользователя использование будет выглядеть так:
Для начала заглянем в исходный код библиотеки, к счастью он не такой большой:
А теперь разберем его по косточкам и попытаемся понять, что он делает.
Во первы?х строках библиотеки задается тип специальный единицы трансляции proc-macro , который говорит, что это будет не абы-что, а плагин к компилятору. Затем подключаются необходимые библиотеки proc_macro и syn со всем инструментарием. Первая задает основные типы, вторая — предоставляет средства парсинга Rust кода в абстрактное синтаксическое дерево (AST). В свою очередь, библиотека quote предоставляет очень важный макрос quote! который мы увидим в действии чуть позже.
Наконец, импортируется необходимый тип TokenStream , поскольку он фигурирует в прототипе функции.
Далее следует собственно функция, выступающая в роли точки входа в процедурный макрос:
На вход она получает набор токенов из компилятора, составляющих тело макроса. На выходе компилятор ожидает получить другой набор токенов, являющихся результатом применения макроса. Таким образом, функция derive() работает как своеобразный фильтр.
Тело функции весьма нехитрое. Сначала мы преобразуем входной набор токенов в строку, а затем разбираем строку как абстрактное синтаксическое дерево. Самое интересное происходит внутри вызова функции new_for_struct() , который принимает AST на вход, а отдает процитированные токены (об этом позже). Наконец, полученные токены преобразуются обратно в строку (не спрашивайте меня, почему так), парсятся в TokenStream и отдаются уже в качестве результата работы макроса компилятору.
Если честно, я тоже не понимаю, зачем тасовать данные туда-сюда через строки и почему нельзя было сразу сделать вменяемый интерфейс, ну да ладно. Возможно, в будущем ситуация изменится.
Давайте разберемся в том, что делает функция new_for_struct() . Но сначала посмотрим на те структуры, для которых нам может потребоваться сгенерировать конструкторы.
Итак, на вход нам могут подать:
Понятное дело, что синтаксические деревья у всех трех вариантов будут различными. И это нужно учитывать при генерировании метода new() . Собственно, все что делает new_for_struct() , — это смотрит на переданное AST дерево, определяет, с каким вариантом она имеет дело данный момент и генерирует нужную подстановку. А если ей на вход передали незнамо что — она начинает паниковать.
Давайте посмотрим на код, генерирующий подстановку для обычной структуры. Здесь код дробить уже неудобно, поэтому я вставлю комментарии прямо в текст:
Вся хитрость здесь заключена в макросе quote! который позволяет цитировать фрагменты кода, подставляя вместо себя набор соответствующих токенов. Обратите внимание на метапеременные, начинающиеся с решетки. Они унаследованы из лексического контекста, в котором находится цитата.
Если все еще не понятно «как оно работает», взгляните на результат применения процедурного макроса к описанной выше структуре Normal .
Сама структура еще раз:
Результат применения процедурного макроса:
Внезапно, все становится на свои места. Оказывается, мы только что собственноручно сгенерировали impl блок для структуры, добавили в него ассоциированную функцию-конструктор new() с документацией (!), двумя параметрами x и y соответствующих типов и с реализацией, которая возвращает нашу структуру, последовательно инициализируя ее поля значениями из своих параметров.
Поскольку Rust может понять из контекста, чему соответствуют x и y до и после двоеточия, все компилируется успешно.
В качестве упражнения, оставшиеся две ветви предлагаю разобрать самостоятельно.
Черная магия метапрограммирования: как работают макросы в Rust 1.15
В прошлой статье мы познакомились с одной из самых интересных возможностей языка Rust — процедурными макросами.
Как и обещал, сегодня я расскажу о том, как писать такие макросы самостоятельно и в чем их принципиальное отличие от печально известных макросов препроцессора в C/C++.
Но сначала пройдемся по релизу 1.15 и поговорим о других новшествах, поскольку для многих они оказались не менее востребованы.
Что можно почитать?
Язык Rust развивается очень интенсивно. Издатели, натурально, не успевают и не берутся выпускать книги, поскольку они устаревают еще до того, как на страницах высохнет краска.
Тем, кто уже имеет опыт программирования на других языках, и вообще достаточно взрослый, чтобы разбираться самостоятельно, подойдет другая книга. Предполагается, что она лучше подает материал и должна прийти на смену первой книге. А тем, кому нравится учиться на примерах, подойдет Rust by Example.
Людям, знакомым с C++, может быть интересна книга, а точнее porting guide, старающаяся подать материал в сравнении с C++ и делающая акцент на различиях языков и на том, какие проблемы Rust решает лучше.
Если вас интересует история развития языка и взгляд с той стороны баррикад, крайне рекомендую блоги Aaron Turon и Niko Matsakis. Ребята пишут очень живым языком и рассказывают о текущих проблемах языка и о том, как предполагается их решать. Зачастую из этих блогов узнаешь куда больше актуальной информации, чем из других источников.
Наконец, если вы не боитесь драконов и темных углов, то можете взглянуть на Растономикон. Только предупреждаю, после прочтения этой книги вы уже не сможете смотреть на Rust прежним образом. Впрочем, я отвлекся…
Разбираем интерфейсный трейт целиком
Теперь можно приступить к разбору трейта с интерфейсом в целом. Интерфейсный трейт всегда состоит исключительно из методов, разбор которых мы описали выше, а также дополнительных атрибутов.
Таким образом, мы можем разобрать его без особых сложностей:
Быстрее! Выше! Сильнее!
Компилятор стал быстрее. А недавно еще и объявили о том, что система инкрементальной компиляции перешла в фазу бета-тестирования. На моих проектах время компиляции после незначительных изменений уменьшилось с
4 секунд, хотя окончательная линковка все еще занимает приличное время. Пока инкрементальная компиляция работает только в ночных сборках и сильно зависит от характера зависимостей, но прогресс радует.
Алгоритм slice::sort() был переписан и стал намного, намного, намного быстрее. Теперь это гибридная сортировка, реализованная под влиянием Timsort. Раньше использовалась обычная сортировка слиянием.
В C++ мы можем определить перекрывающую специализацию шаблона для некоторого типа, но пока не можем наложить ограничения на то, какие типы вообще могут использоваться для специализации этого шаблона. Работы в этом направлении ведутся, но пока все очень сложно.
Стабильный Rust всегда умел задавать ограничения типажей, но с недавних пор появилась возможность доопределить, а точнее перекрыть обобщенную реализацию более конкретной, если она задает более строгие ограничения. Это позволяет оптимизировать код для частных случаев, не нарушая при этом обобщенный интерфейс.
В частности, в релизе 1.15 была добавлена специализированная реализация метода extend() для Vec<T> , где T: Copy , которая использует простое линейное копирование регионов памяти, что привело к значительному ускорению.
Помимо этого были ускорены реализации методов chars().count() , chars().last() , и char_indices().last() .
Поддержка IDE
Этого пока нет в стабильном Rust, но тем не менее новость слишком значительная, чтобы о ней умолчать. Дело в том, что недавно разработчики Rust Language Server объявили о выходе альфа-версии своего детища.
Language Server Protocol это стандартный протокол, который позволяет редакторам и средам разработки общаться на одном языке с компиляторами. Он абстрагирует такие операции, как автодополнение ввода, переход к определению, рефакторинг, работу с буферами и т.д.
Это означает, что любой редактор или IDE, которые поддерживают LSP автоматически получают поддержку всех LSP-совместимых языков.
Уже сейчас можно попробовать базовые возможности на совместимых редакторах, только авторы настоятельно советуют осторожно относиться к своим данным, ибо код еще довольно сырой.
Axios macro - это программа с макросами для RUST и не только. Axios убирает отдачу и автоматически определяет оружие в руках. Можно ставить любую сенсу и фов, имеет в себе много полезных плюшек для комфортной игры.
Обновлен и работает
Новые архитектуры
У раста появилась поддержка уровня Tier 3 для архитектур i686-unknown-openbsd , MSP430 , и ARMv5TE . Недавно стало известно, что в релизе LLVM 4.0 появляется поддержка архитектуры микроконтроллеров AVR. Разработчики Rust в курсе этого и уже готовятся почти все сделали для интеграции новой версии LLVM и новой архитектуры.
Более того, уже есть проекты использования Rust в embedded окружении. Разработчики компилятора опрашивают сообщество для выяснения потребностей этой пока малочисленной, но важной группы пользователей.
Новое в Rust 1.15
С момента выпуска 1.14 прошло около 6 недель. За это время в новый релиз успели войти 1443 патча (неслабо, правда?) исправляющие баги и добавляющие новые возможности. А буквально на днях появился и хотфикс 1.15.1, с небольшими, но важными исправлениями.
За подробностями можно обратиться к странице анонса или к детальному описанию изменений (changelog). Здесь же мы сконцентрируемся на наиболее заметных изменениях.
Пишем API на Rust с помощью процедурных макросов
Процедурные макросы в Rust — это очень мощный инструмент кодогенерации, позволяющий обходиться без написания тонны шаблонного кода, или выражать какие-то новые концепции, как сделали, к примеру, разработчики крейта async_trait .
Тем не менее, многие вполне обоснованно побаиваются пользоваться этим инструментом, в основном из-за того, что разбор синтаксического дерева и атрибутов макроса зачастую превращается в "закат солнца вручную", так как задачу приходится решать на очень низком уровне.
В данной статье я хочу поделиться некоторыми, на мой взгляд, удачными подходами к написанию процедурных макросов, и показать, что на сегодняшний день процедурные макросы можно создавать относительно просто и удобно.
Создаем макрос FromUrlQuery
Как мне кажется, самый идиоматичный подход к написанию процедурных макросов — это объявление некоторого трейта, а потом создание макроса, который будет его выводить для пользовательских типов данных. Конечно, мы можем в дерайв-макросах генерировать любой код, но использование их для других целей неизбежно приведет к недопониманию.
Итак, приступим. Для начала объявим наш трейт по разбору URL query. Данный трейт позволит нам получать из произвольной строки структуру данных, для которой этот трейт реализован. Выглядеть он будет так:
Чтобы иметь возможность автоматически реализовывать этот трейт, нам потребуется процедурный макрос. Данный макрос относится к типу макросов derive макросов и должен объявляться следующим образом:
Обычный джентльменский набор писателя процедурных макросов — это библиотеки syn , quote . Первый крейт является парсером Rust синтаксиса, он содержит в себе все типы токенов, встречающиеся в синтаксическом дереве.
Во втором крейте содержится очень важный макрос quote! , который по сути является шаблонизатором и позволяет просто писать некоторый шаблонный Rust код, который будет потом преобразован в выходной набор токенов.
Помимо этих двух обязательных зависимостей есть еще много вспомогательных крейтов, одним из самых полезных, на мой взгяд, является darling . Этот крейт содержит набор процедурных макросов и трейтов для облегчения типовых задач по разбору структур или атрибутов макросов (то есть, входных данных для нашего процедурного макроса).
Обычно код разбора AST и атрибутов макроса превращается в кошмар, выглядящий как куча вложенных условий, понять которые крайне сложно.
Мы же будем использовать крейт darling , благодаря чему наш код будет намного короче и проще в поддержке.
Искомая структура, для которой мы выводим FromUrlQuery , не должна быть пустой, она не должна быть кортежем и для простоты эксперимента она не будет содержать шаблонных параметров и лайфтаймов. То есть, это всегда что-то такого вида:
В darling 'е есть много вспомогательных макросов, но нас сейчас интересует только несколько из них.
Первый макрос — это FromField , который выводит десериализацию интересующих нас свойств поля структуры из синтаксического дерева:
Хочу отметить, что при этом если бы мы хотели знать, публичное это поле или нет, то могли бы изменить сигнатуру на следующую:
Второй интересующий нас макрос — это FromDeriveInput , который выводит десериализацию уже для целой структуры или перечисления:
И все, на этом наш парсер готов.
Можно приступать к написанию кодогенератора.
Чтобы не перегружать статью сверх меры, мы просто будем делегировать десериализацию URL query в serde . При этом мы спрячем serde максимально глубоко, чтобы он не просочился в обязательные зависимости. Мы будем создавать точную копию нашей структуры и выводить для нее Deserialize , а для реального парсинга запросов будем использовать крейт serde_urlencoded . Но чтобы пользователям не приходилось самим добавлять serde в зависимости, мы в основном крейте сделаем реэкспорты.
А теперь посмотрим, как же будет в реальности выглядеть процесс кодогенерации FromUrlQuery :
Да, это все уже не выглядит слишком сложным или очень рутинным, по сути мы просто пишем то, что хотим получить, с одной стороны не сталкиваясь с большими когнитивными трудностями, а с другой получая весьма лаконичный и понятный код. Но, к сожалению, не всегда жизнь бывает такой простой; все становится гораздо интереснее сложнее, если есть необходимость написать не дерайв макрос, а атрибутный.
Вот тут нам уже не поможет FromDeriveInput , нет в darling 'е готового набора инструментов для разбора трейтов, так что придется нам немного повозиться с AST. Но не так черт страшен, как его малюют, поэтому давайте приступим:
Код объявления атрибутных макросов несколько отличается и выглядит вот так:
Есть еще один крайне важный нюанс, над которым мне в свое время пришлось поломать голову: если мы просто решим, что раз уж нам дали целиком синтаксическое дерево трейта со всеми внутренними атрибутами (например, интересующий нас http_api_endpoint ), то мы будем лишь частично правы. Да, они будут видны при разборе TokenStream , но при этом же компилятор будет нам выдавать ошибку "cannot find attribute http_api_endpoint in this scope", что несколько сбивает с толку. Ошибка эта возникает потому, что компилятор не знает о существовании такого атрибута, поэтому не знает, как с ним работать. О том, что этот атрибут нужен для наших внутренних нужд, компилятор не знает, поэтому и реагирует соответственно.
Теперь компилятор знает, что такой атрибут существует, и не будет ругаться на неизвестное имя.
Переходим к кодогенерации
Как было указано в начале статьи, для работы с запросами мы будем использовать крейт warp .
Поэтому, прежде чем приступать к кодогенерации, необходимо разобраться с тем, как устроен warp и каким образом к нему подключаются обработчики запросов. Все в warp'е крутится вокруг концепции, которая называется Filter . Фильтры можно комбинировать в цепочки при помощи комбинаторов and , map , and_then , где каждый наложенный фильтр конкретизирует то, как будет обрабатываться запрос.
Например, если мы хотим просто написать обработчик запросов, который на GET запрос будет просто возвращать некоторый JSON, то мы просто пишем что-то в таком стиле:
Для случая с GET запросами с параметрами мы лишь немного изменим обертку, которую мы написали выше, добавив еще один фильтр в цепочку:
Обработчики остальных двух типов запросов пишутся схожим образом.
Собираем обработчики воедино
Помимо комбинаторов and , которое объединяет фильтры в цепочку, существует еще комбинатор
or , которое позволяет выбирать из двух фильтров подходящий по ситуации, фактически, таким
образом мы организовываем роутинг запросов, причем правила могут быть очень сложными.
Давайте просто взглянем на пример из документации:
И вот теперь мы можем приступить к генерации тела искомой функции serve_ping_interface . Для начала реализуем генерацию соответствующих warp фильтров для соответствующих методов трейта, где service это объект, реализующий бизнес-логику.
А теперь с помощью комбинатора or собираем все фильтры воедино.
Готовые макросы и скрипты для «Rust»
На этой странице вы можете скачать абсолютно бесплатно готовые макросы и скрипты для «Rust». Установка макроса на обычную клавиатуру и мышку происходит в два клика.
l[SENS 1.0 FOV 75] Доброго времени суток! Представляю вашему вниманию Лицензи..
Макрос чтобы гасить отдачу у автомата калашникова в игре Rust Настройки: Поле ..
жмёт почти идеально в точку, настраивал под FOV 90, input.sensitivity 0.66 . ..
Имбовый макрос для 8x который может попадать на 200+метров Он убирает отдачу по..
мой первый макрос, жмёт почти идеально в точку, настраивал под FOV 90, input.sen..
Макросс создал сам, Макросс рассчитан на калаш без обвессов, Макросс хорошо о..
Макрос для Ак-47 с прицелом 8х, использовать макрос с драйвером для более стабил..
Этот макрос позволит вам стрелять практически без отдачи. Для этого макроса нужн..
Макрос для сенсы 0.66 и Fov 90, нужно немного жать с макросом Макрос нужно испо..
Заходите в редактор A4tech ставите любую кнопку,ваш макрос работает, Слив макр..
Лучший макрос АК-47 от VAUSE Работает ТОЛЬКО с 8X Настройки : FOV 75 - ..
Лучший макрос АК-47 от VAUSE Работает ТОЛЬКО с 8X Настройки : FOV 75 - ..
Лучший макрос АК-47 от VAUSE Работает с голографическим прицелом и железным п..
Настройки в игре: - FOV 90 - Чувствительность 0.66 Настройки в программе: 1..
макрос для М249! довольно хорошо работает и на 8х сенса 0.5 в точку Советую, ..
Макрос на АК без прицела,тупо by Djem,мужики пользуйтесь :3 У макроса полностью..
Очень крутой макрос на Томпсон. Проверенно лично мной,проверял на таких сервера..
Максро для томсона, отдачи 0 стрельба в точку. Sens 0.4-0.5 Установка. 1.Наж..
Sens 1. Приватный макрос для AK-47. Работает на любой мишке при настройках сенса..
Настройки в игре: - FOV 90 - Чувствительность 0.66 Настройки в программе: 1..
Best MP5 Macro by ноунейм999666228 Works with Iron Sights and Holograpic S..
Хороший макрос на оружие АК - 47. Жмет в точку до 140 метров отдача рандом. Н..
Заключение
Потенциал процедурных макросов только предстоит выявить. Обозначенные в прошлой статье примеры — только вершина айсберга и самый прямолинейный вариант использования. Есть гораздо более интересные проекты, как например проект сборщика мусора, реализованного целиком лексическими средствами языка Rust.
Надеюсь, что статья оказалась вам полезной. А если после ее прочтения вы еще и захотели поиграться с языком Rust, я буду считать свою задачу выполненной полностью :)
Читайте также: