Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Определение перечисления

Если структуры дают вам способ группировать связанные поля и данные вместе, например, Rectangle с его width и height, то перечисления дают вам способ сказать, что значение является одним из возможного набора значений. Например, мы можем захотеть сказать, что Rectangle — это одна из возможных фигур, которая также включает Circle и Triangle. Для этого Rust позволяет нам закодировать эти возможности в виде перечисления.

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

Любой IP-адрес может быть либо адресом версии четыре, либо адресом версии шесть, но не обоими одновременно. Это свойство IP-адресов делает структуру данных перечисления подходящей, потому что значение перечисления может быть только одним из его вариантов. И адреса версии четыре, и версии шесть по-прежнему принципиально являются IP-адресами, поэтому они должны рассматриваться как один и тот же тип, когда код имеет дело с ситуациями, применимыми к любому виду IP-адреса.

Мы можем выразить эту концепцию в коде, определив перечисление IpAddrKind и перечислив возможные виды, которые может иметь IP-адрес: V4 и V6. Это варианты перечисления:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Теперь IpAddrKind — это пользовательский тип данных, который мы можем использовать в другом месте нашего кода.

Значения перечисления

Мы можем создать экземпляры каждого из двух вариантов IpAddrKind следующим образом:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Обратите внимание, что варианты перечисления находятся в пространстве имён под его идентификатором, и мы используем двойное двоеточие для разделения двух. Это полезно, потому что теперь оба значения IpAddrKind::V4 и IpAddrKind::V6 имеют один и тот же тип: IpAddrKind. Затем мы можем, например, определить функцию, которая принимает любой IpAddrKind:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

И мы можем вызвать эту функцию с любым вариантом:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Использование перечислений имеет ещё больше преимуществ. Подумав подробнее о нашем типе IP-адреса, в настоящее время у нас нет способа хранить фактические данные IP-адреса; мы знаем только, какого вида он. Учитывая, что вы только что узнали о структурах в главе 5, вас может соблазнить решить эту проблему с помощью структур, как показано в листинге 6-1.

fn main() {
    enum IpAddrKind {
        V4,
        V6,
    }

    struct IpAddr {
        kind: IpAddrKind,
        address: String,
    }

    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };

    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };
}
Листинг 6-1: Хранение данных и варианта IpAddrKind IP-адреса с использованием struct

Здесь мы определили структуру IpAddr, которая имеет два поля: поле kind типа IpAddrKind (перечисление, которое мы определили ранее) и поле address типа String. У нас есть два экземпляра этой структуры. Первый — home, и он имеет значение IpAddrKind::V4 в качестве своего kind со связанными данными адреса 127.0.0.1. Второй экземпляр — loopback. Он имеет другой вариант IpAddrKind в качестве своего значения kind, V6, и имеет адрес ::1, связанный с ним. Мы использовали структуру, чтобы объединить значения kind и address вместе, так что теперь вариант связан со значением.

Однако представление той же концепции с использованием только перечисления более кратко: вместо перечисления внутри структуры мы можем поместить данные непосредственно в каждый вариант перечисления. Это новое определение перечисления IpAddr говорит, что оба варианта, V4 и V6, будут иметь связанные значения String:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

Мы прикрепляем данные к каждому варианту перечисления напрямую, так что нет необходимости в дополнительной структуре. Здесь также легче увидеть другую деталь того, как работают перечисления: имя каждого варианта перечисления, которое мы определяем, также становится функцией, которая создаёт экземпляр перечисления. То есть IpAddr::V4() — это вызов функции, который принимает аргумент String и возвращает экземпляр типа IpAddr. Мы автоматически получаем эту функцию-конструктор, определённую в результате определения перечисления.

Есть ещё одно преимущество использования перечисления вместо структуры: каждый вариант может иметь разные типы и объёмы связанных данных. IP-адреса версии четыре всегда будут иметь четыре числовых компонента со значениями от 0 до 255. Если бы мы хотели хранить адреса V4 как четыре значения u8, но по-прежнему выражать адреса V6 как одно значение String, мы не смогли бы сделать это со структурой. Перечисления легко справляются с этим случаем:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let home = IpAddr::V4(127, 0, 0, 1);

    let loopback = IpAddr::V6(String::from("::1"));
}

Мы показали несколько различных способов определения структур данных для хранения IP-адресов версии четыре и версии шесть. Однако, как оказалось, желание хранить IP-адреса и кодировать, какого они вида, настолько распространено, что стандартная библиотека имеет определение, которое мы можем использовать! Давайте посмотрим, как стандартная библиотека определяет IpAddr. У неё есть точно такое же перечисление и варианты, которые мы определили и использовали, но она встраивает данные адреса внутрь вариантов в форме двух разных структур, которые определяются по-разному для каждого варианта:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

Этот код иллюстрирует, что вы можете поместить любой вид данных внутрь варианта перечисления: строки, числовые типы или структуры, например. Вы даже можете включить другое перечисление! Кроме того, типы стандартной библиотеки часто не намного сложнее того, что вы могли бы придумать сами.

Обратите внимание, что даже несмотря на то, что стандартная библиотека содержит определение для IpAddr, мы всё ещё можем создавать и использовать наше собственное определение без конфликта, потому что мы не привнесли определение стандартной библиотеки в нашу область видимости. Мы поговорим подробнее о привнесении типов в область видимости в главе 7.

Давайте рассмотрим другой пример перечисления в листинге 6-2: у этого есть большое разнообразие типов, встроенных в его варианты.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}
Листинг 6-2: Перечисление Message, варианты которого хранят различные объёмы и типы значений

Это перечисление имеет четыре варианта с разными типами:

  • Quit: не имеет связанных данных вообще
  • Move: имеет именованные поля, как структура
  • Write: включает одну String
  • ChangeColor: включает три значения i32

Определение перечисления с вариантами, подобными тем, что в листинге 6-2, похоже на определение различных видов определений структур, за исключением того, что перечисление не использует ключевое слово struct, и все варианты группируются вместе под типом Message. Следующие структуры могли бы содержать те же данные, что и предшествующие варианты перечисления:

struct QuitMessage; // единичная структура
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // кортежная структура
struct ChangeColorMessage(i32, i32, i32); // кортежная структура

fn main() {}

Но если бы мы использовали разные структуры, каждая из которых имеет свой собственный тип, мы не смогли бы так же легко определить функцию, которая принимает любой из этих видов сообщений, как мы могли бы с перечислением Message, определённым в листинге 6-2, которое является единым типом.

Есть ещё одно сходство между перечислениями и структурами: точно так же, как мы можем определять методы для структур с помощью impl, мы также можем определять методы для перечислений. Вот метод с именем call, который мы могли бы определить для нашего перечисления Message:

fn main() {
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }

    impl Message {
        fn call(&self) {
            // здесь было бы определено тело метода
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();
}

Тело метода использовало бы self, чтобы получить значение, для которого мы вызвали метод. В этом примере мы создали переменную m, которая имеет значение Message::Write(String::from("hello")), и именно это self будет в теле метода call, когда выполняется m.call().

Давайте рассмотрим другое перечисление в стандартной библиотеке, которое очень распространено и полезно: Option.

Перечисление Option

В этом разделе исследуется пример Option, которое является ещё одним перечислением, определённым стандартной библиотекой. Тип Option кодирует очень распространённый сценарий, в котором значение может быть чем-то или может быть ничем.

Например, если вы запрашиваете первый элемент в непустом списке, вы получите значение. Если вы запрашиваете первый элемент в пустом списке, вы получите ничего. Выражение этой концепции в терминах системы типов означает, что компилятор может проверить, обработали ли вы все случаи, которые должны обрабатываться; эта функциональность может предотвратить ошибки, которые чрезвычайно распространены в других языках программирования.

Дизайн языка программирования часто рассматривается в терминах того, какие функции вы включаете, но функции, которые вы исключаете, тоже важны. В Rust нет функции null, которая есть во многих других языках. Null — это значение, которое означает, что там нет значения. В языках с null переменные всегда могут находиться в одном из двух состояний: null или не-null.

В своей презентации 2009 года «Null References: The Billion Dollar Mistake» Тони Хоар, изобретатель null, сказал следующее:

Я называю это своей ошибкой на миллиард долларов. В то время я проектировал первую всеобъемлющую систему типов для ссылок в объектно-ориентированном языке. Моей целью было обеспечить абсолютную безопасность всех использований ссылок, с проверкой, выполняемой автоматически компилятором. Но я не смог устоять перед искушением добавить нулевую ссылку, просто потому, что это было так легко реализовать. Это привело к бесчисленным ошибкам, уязвимостям и системным сбоям, которые, вероятно, причинили миллиард долларов боли и ущерба за последние сорок лет.

Проблема с нулевыми значениями заключается в том, что если вы попытаетесь использовать нулевое значение как ненулевое, вы получите ошибку того или иного рода. Поскольку это свойство null или не-null повсеместно, очень легко допустить такого рода ошибку.

Однако концепция, которую пытается выразить null, всё ещё полезна: null — это значение, которое в настоящее время недействительно или отсутствует по какой-то причине.

Проблема на самом деле не в концепции, а в конкретной реализации. Как таковая, Rust не имеет null, но у него есть перечисление, которое может кодировать концепцию присутствия или отсутствия значения. Это перечисление — Option<T>, и оно определено стандартной библиотекой следующим образом:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Перечисление Option<T> настолько полезно, что оно даже включено в prelude; вам не нужно явно привносить его в область видимости. Его варианты также включены в prelude: вы можете использовать Some и None напрямую без префикса Option::. Перечисление Option<T> по-прежнему является обычным перечислением, а Some(T) и None по-прежнему являются вариантами типа Option<T>.

Синтаксис <T> — это функция Rust, о которой мы ещё не говорили. Это параметр обобщённого типа, и мы рассмотрим обобщения более подробно в главе 10. Пока всё, что вам нужно знать, это то, что <T> означает, что вариант Some перечисления Option может содержать один фрагмент данных любого типа, и что каждый конкретный тип, используемый вместо T, делает общий тип Option<T> другим типом. Вот несколько примеров использования значений Option для хранения числовых типов и типов char:

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

Тип some_number — Option<i32>. Тип some_char — Option<char>, что является другим типом. Rust может вывести эти типы, потому что мы указали значение внутри варианта Some. Для absent_number Rust требует, чтобы мы аннотировали общий тип Option: компилятор не может вывести тип, который будет содержать соответствующий вариант Some, только глядя на значение None. Здесь мы сообщаем Rust, что подразумеваем, что absent_number будет типа Option<i32>.

Когда у нас есть значение Some, мы знаем, что значение присутствует, и значение содержится внутри Some. Когда у нас есть значение None, в некотором смысле это означает то же самое, что null: у нас нет действительного значения. Так почему же наличие Option<T> лучше, чем наличие null?

Короче говоря, потому что Option<T> и T (где T может быть любым типом) — это разные типы, компилятор не позволит нам использовать значение Option<T> так, как если бы оно определенно было действительным значением. Например, этот код не скомпилируется, потому что пытается добавить i8 к Option<i8>:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let sum = x + y;
}

Если мы запустим этот код, мы получим сообщение об ошибке, подобное этому:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
help: the following other types implement trait `Add<Rhs>`
 --> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/ops/arith.rs:98:8
  |
  = note: `i8` implements `Add`
 ::: /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/ops/arith.rs:113:0
  |
  = note: in this macro invocation
 --> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/internal_macros.rs:22:8
  |
  = note: `&i8` implements `Add<i8>`
 ::: /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/internal_macros.rs:33:8
  |
  = note: `i8` implements `Add<&i8>`
 ::: /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/core/src/internal_macros.rs:44:8
  |
  = note: `&i8` implements `Add`
  = note: this error originates in the macro `add_impl` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Сурово! По сути, это сообщение об ошибке означает, что Rust не понимает, как сложить i8 и Option<i8>, потому что это разные типы. Когда у нас есть значение типа i8 в Rust, компилятор гарантирует, что у нас всегда есть действительное значение. Мы можем действовать уверенно, не проверяя на null перед использованием этого значения. Только когда у нас есть Option<i8> (или какой бы тип значения мы ни использовали), нам нужно беспокоиться о возможном отсутствии значения, и компилятор гарантирует, что мы обработаем этот случай, прежде чем использовать значение.

Другими словами, вы должны преобразовать Option<T> в T, прежде чем вы сможете выполнять с ним операции T. Как правило, это помогает поймать одну из самых распространённых проблем с null: предположение, что что-то не является null, когда на самом деле это так.

Устранение риска ошибочного предположения о ненулевом значении помогает вам быть более уверенным в своём коде. Чтобы получить значение, которое может быть null, вы должны явно согласиться, сделав тип этого значения Option<T>. Затем, когда вы используете это значение, вы обязаны явно обработать случай, когда значение равно null. Везде, где значение имеет тип, отличный от Option<T>, вы можете безопасно предположить, что значение не равно null. Это было осознанным дизайнерским решением Rust, чтобы ограничить распространённость null и повысить безопасность кода на Rust.

Итак, как вы получаете значение T из варианта Some, когда у вас есть значение типа Option<T>, чтобы вы могли использовать это значение? Перечисление Option<T> имеет большое количество методов, которые полезны в различных ситуациях; вы можете ознакомиться с ними в его документации. Знакомство с методами Option<T> будет чрезвычайно полезно в вашем путешествии по Rust.

В общем, чтобы использовать значение Option<T>, вам нужен код, который будет обрабатывать каждый вариант. Вам нужен некоторый код, который будет выполняться только тогда, когда у вас есть значение Some(T), и этому коду разрешено использовать внутреннее T. Вам нужен некоторый другой код, который будет выполняться только если у вас есть значение None, и у этого кода нет доступного значения T. Выражение match — это конструкция управления потоком, которая делает именно это при использовании с перечислениями: она будет выполнять разный код в зависимости от того, какой вариант перечисления у неё есть, и этот код может использовать данные внутри соответствующего значения.