Комментарии (12)

1. 

   evgenymarkov

   08.08.2015 21:18

   #8529723

   +3

   Отличная новость, больше тулчейнов хороших и разных для хорошего языка! А пока есть небольшая проблема с компиляцией rustc для ARM: для сборки используется помимо g++ некий snapshot, а он предоставляется только для x86 архитектур. Может кто-то подсказать как это обойти? Я в курсе, что официально пока что поддерживаются только x86, но кого это когда-то останавливало?)
   В гугле удалось найти только про кросскомпиляцию программ с использованием --target и указанием различных тулчейнов.

   
   

   1. 

      stepik777

      09.08.2015 10:17

      #8529875

      Вообще любой Rust компилятор может компилировать для любой другой поддерживаемой платформы, нужно только сначала скомпилировать стандартную библиотеку для этой платформы. Если нет нативной сборки rustc для какой-то платформы, то, видимо, единственный способ её получить — это кросскомпиляция.
      Сам я такого не пробовал, так что подробнее рассказать не могу.

1. 

   NeoCode

   08.08.2015 23:30

   #8529785

   +1

   А можно подробнее узнать про «типы с динамическим размером»? Что это такое, в чем особенности реализации, какие задачи решают и т.д.
   Я так понимаю это не то же самое что обычные динамические структуры данных вроде списков и векторов?
   

   
   

   1. 

      IRainman

      09.08.2015 07:08

      #8529855

      -2

      У меня ощущение, что это подразумевается своеобразный полиморфизм этапа выполнения, когда структура (декларация) класса могут меняться в процессе работы, соответственно и размер объектов будет меняться. Меняется размер, наверняка, с помощью какого нибудь метода «эволюция» или нечто подобного.

   
   

   1. 

      stepik777

      09.08.2015 10:35

      #8529877

      +3

      Это типы, размер которых неизвестен на этапе компиляции, их нельзя использовать напрямую, можно пользоваться только ссылками на них.
      На сколько я знаю, есть 2 вида таких типов:
      1. Слайс (slice, в этой статье они называются срезами) — это часть массива или вектора, обозначается [T].
      2. Трейт-объект (trait-object) — любой объект, реализующий данный трейт (интерфейс). Аналог в С++ — абстрактные классы, нельзя использовать абстрактный класс, можно использовать только указатель на него.
      
      Особенность ссылок на эти объекты, в том, что они состоят из двух частей — указателя на сам объект и некоей дополнительной информации. В случае со слайсом этой дополнительной информацией будет размер слайса или указатель на его конец (я не знаю деталей реализации), а в случае с трейт-объектом — это указатель на таблицу методов (аналог vtable в C++).

      
      

      1. 

         NeoCode

         09.08.2015 17:18

         #8530035

         +1

         А что следует понимать под «размером типа»? Размер объекта этого типа или что-то другое?
         Можно ли сказать, что в C++ размер объектов std::vector, std::list и т.п. также неизвестен во время компиляции? (я бы так сказал, но вдруг в терминах Rust под этим понимается что-то другое...)
         Если да — то что нового привнес Rust в работу с такими динамическими структурами данных, по сравнению с тем же С++?

         
         

         1. 

            stepik777

            09.08.2015 18:58

            #8530053

            Да, я имел в виду размер объекта этого типа.
            Размер std::vector — это то, что возвращает sizeof, то есть размер нескольких указателей, это не тип динамического размера.
            
            Например тип u32 — это тип со статическим размером, переменная типа u32 имеет размер 4 байта, а переменная типа &u32 (ссылка на u32) — 4 или 8 байт, в зависимости от архитектуры.
            Если вам нужно сослаться на область памяти, где последовательно хранятся 32-битные числа (например кусок вектора или массива), то можно использовать &[u32], эта ссылка имеет фиксированный размер, в то же время размер [u32] может быть произвольным.
            
            Если вам нужно сослаться на область памяти в С++, вы можете создать структуру вида:
            

            template<typename T>
            struct slice {
                T* begin;
                size_t size;
            }
            

            Это будет тоже самое, что &[u32] в Расте, но выразить сам тип [u32] в C++ нельзя.
            
            

            
            

            1. 

               NeoCode

               09.08.2015 19:21

               #8530061

               Ну хорошо, в случае std::vector там тоже где-то будет указатель на начало и дополнительная информация — указатель на последний элемент, на конец буфера и еще что-то. В случае std::list — указатель на начало и дополнительная информация — указатель на следующий элемент списка.
               Все-же как-то все очень непонятно, что именно они там с этими «типами с динамическим размером» сделали.

               
               

               1. 

                  Googolplex

                  10.08.2015 00:46

                  #8530253

                  +3

                  stepik777 всё правильно объясняет.
                  
                  В большинстве языков, в частности, и в Rust, типы так или иначе имеют фиксированный размер, который известен компилятору. Примитивные типы, конкретные структуры, фиксированные массивы и прочее — их размер, т.е. необходимое для них число байт, всегда известны.
                  
                  С другой стороны, существуют типы, размер которых на этапе компиляции неизвестен точно. Например, это «абстрактный» массив — т.е. некоторая последовательность элементов одного типа, но с неизвестной длиной. Другой пример — тип, объединяющий все типы, реализующие какой-нибудь трейт. Например, если Display — это трейт, то Display в контексте типа обозначает любой тип, реализующий этот трейт. Понятно, что потенциально любой тип может реализовывать трейт, поэтому размер таких «объединяющих» типов тоже неизвестен.
                  
                  Типы с неизвестным размером можно использовать только при выполнении двух условий:
                  

                  1. доступ к их объектам осуществляется только через указатель;
                  2. вместе с указателем должна храниться какая-то дополнительная информация, позволяющая «обойти» статическое незнание конкретики о типе.

                  
                  
                  Первое условие нужно, потому что вы не можете использовать объекты типа с неизвестным размером по значению — для этого компилятору придётся выделить память на стеке, но как её выделить, если нужный размер неизвестен? Размер же указателя известен всегда.
                  
                  Второе условие нужно, потому что, не зная дополнительной информации о конкретном значении, вы не сможете его использовать. Например, в случае с массивом вам необходимо знать его длину, иначе вы не сможете безопасно получить элемент по его индексу. В случае с трейт-объектом вам нужно знать, метод из какой именно реализации трейта необходимо вызвать. В случае с массивами дополнительная информация — это длина массива, а в случае с трейт-объектами — это таблица виртуальных методов. В Rust эта информация хранится непосредственно в объекте-ссылке/указателе, поэтому ссылки/указатели на типы с динамическим размером в Rust называются fat pointers, толстыми указателями.
                  
                  Например, возьмём тип &[i32] — срез i32. Это ссылка на тип с динамическим размером [i32]. Обычно ссылки реализуются в виде указателей, например, &i32 на самом низком уровне представляется в виде одного 8-байтного или 4-байтного числа. Но &[i32] — это толстый указатель, и он состоит из двух чисел: указателя на начало массива и длины этого массива. При создании &[i32], т.е. при взятии ссыли на массив и преобразовании её в срез, информация о длине исходного массива сохраняется внутри толстого указателя.
                  
                  &Display — это трейт-объект для трейта Display. В переменной такого типа может храниться указатель на любой тип, который реализует трейт Display. Однако для того, чтобы такую переменную можно было бы использовать, нужно вместе с указателем на значение хранить ссылку на таблицу методов Display, которые реализует тип, значение которого лежит в этой переменной. Поэтому &Display — это толстый указатель, который состоит из указателя на значение и указателя на таблицу виртуальных методов для типа этого значения. При создании ссылки на объект и преобразовании её в трейт-объект указатель на таблицу виртуальных методов сохраняется внутри толстого указателя.
                  
                  В модуле std::raw лежат структуры, описывающие толстые указатели для разных видов DST. Эти типы можно напрямую преобразовывать (с помощью mem::transmute(), аналога reinterpret_cast из C++) в ссылки на типы с динамическим размером, т.е., например, можно преобразовать std::raw::Slice в &[i32] и наоборот.
                  
                  Что касается изменений именно в данном релизе, то теперь можно сказать, что типы с динамическим размером поддерживаются компилятором (практически) в полном объёме. Например, можно создавать умные указатели, аналогичные Box из стандартной библиотеки, которые будут прозрачно работать с DST, т.е. автоматически становиться толстыми указателями, если они используются для DST. Раньше этого было сделать нельзя.

                  
                  

                  1. 

                     NeoCode

                     10.08.2015 15:00

                     #8530923

                     То есть по сути это «толстые указатели» — на самом деле обычные структуры/классы, которые ведут себя как указатели и содержат дополнительную информацию? Некий аналог умных указателей С++, с какой-то поддержкой со стороны компилятора?
                     Может ли программист придумать свой DST? Будет ли компилятор понимать что это «DST» и работать с ним тем особым образом, как он работает со встроенными?

                     
                     

                     1. 

                        Googolplex

                        10.08.2015 16:24

                        #8531047

                        +1

                        Это не совсем «обычные структуры/классы», знание о них заложено в компилятор. Например, в случае с трейт-объектами это не обойти никак, потому что в трейт-объектах дополнительная информация — это указатель на vtable, который знает только компилятор. Я думаю, что, теоретически, срезы, которые содержат дополнительную информацию о длине, можно было бы реализовать в сторонней библиотеке, но на данный момент срезы также встроены в язык. То, что лежит в std::raw — это совместимое представление толстых указателей в виде структур, но это не значит, что эти структуры на самом деле используются.
                        
                        Да, программист может определять свои DST. Например, Path и CStr из стандартной библиотеки — это типы с динамическим размером. Однако на данный момент возможности по созданию DST сильно ограничены, и их реализация не очень, скажем так, приятна глазу. По факту, можно создавать и использовать срезоподобные DST (как вышеописанные Path и CStr). Возможно, можно как-то заюзать этот механизм для сохранения собственной информации. Чего-то большего пока что сделать нельзя, например, нельзя как-то описать толстый указатель с дополнительной информацией в виде собственной структуры, но, я думаю, кто-нибудь может написать RFC по этому поводу, и, возможно, что-то такое будет в будущем добавлено в язык. Пока что, насколько я понимаю, особой необходимости в этом нет.

1. 

   vsb

   09.08.2015 07:33

   #8529859

   Простейший пример типа с динамическим размером: [T] это массив неизвестного (на этапе компиляции) размера.