Почему использование Some для обертки кортежа типа в & []?

Question

Я использую ящик twitter_stream для извлечения данных из Twitter.API поддерживает фильтрацию данных по некоторому параметру;в моем случае я пытаюсь фильтровать, используя ограничивающий прямоугольник.Библиотека принимает Option<((f64, f64), (f64, f64))>, поэтому я создаю кортеж в такой форме:

let bounds = ((0.59 as f64, 0.59 as f64), (0.59 as f64, 0.59 as f64));

Когда я делаю Some(bounds), чтобы обернуть это в Option, я получаю тип Option<&[((f64, f64), (f64, f64))]>

Это добавляет &[] вокруг моего кортежа, и я не понимаю, что это значит или почему он там.По-моему, это означает, что теперь есть заимствованный массив с одним элементом вокруг кортежа, но я не понимаю, зачем будет массив, и я попытался добавить .to_owned() везде, и это ничего не изменило, поэтомуМне кажется, что я далеко от базы.

Код:

extern crate twitter_stream;

use twitter_stream::rt::{self, Future, Stream};
use twitter_stream::{Token, TwitterStreamBuilder};

fn main() {
    let bounds = ((0.59 as f64, 0.59 as f64), (0.59 as f64, 0.59 as f64));
    let future = TwitterStreamBuilder::filter(Token::new(
        "consumer_key",
        "consumer_secret",
        "access_token",
        "access_secret",
    ))
    .locations(Some(bounds))
    .listen()
    .unwrap()
    .flatten_stream()
    .for_each(|json| {
        println!("{}", json);
        Ok(())
    })
    .map_err(|e| println!("error: {}", e));

    rt::run(future);
}

Ошибка:

error[E0277]: the trait bound `std::option::Option<&[((f64, f64), (f64, f64))]>: std::convert::From<std::option::Option<((f64, f64), (f64, f64))>>` is not satisfied
 --> src/main.rs:9:14                                                                                                  
  |                                                                                                                    
9 |             .locations(Some(bounds))                                                                               
  |              ^^^^^^^^^ the trait `std::convert::From<std::option::Option<((f64, f64), (f64, f64))>>` is not implemented for `std::option::Option<&[((f64, f64), (f64, f64))]>`
  |                                                                                                                    
  = help: the following implementations were found:                                                                    
            <std::option::Option<&'a T> as std::convert::From<&'a std::option::Option<T>>>                             
            <std::option::Option<&'a mut T> as std::convert::From<&'a mut std::option::Option<T>>>                     
            <std::option::Option<T> as std::convert::From<T>>                                                          
  = note: required because of the requirements on the impl of `std::convert::Into<std::option::Option<&[((f64, f64), (f64, f64))]>>` for `std::option::Option<((f64, f64), (f64, f64))>`

Answer 1

Вы читаете сообщение об ошибке в обратном направлении.Немного очищенный, он говорит:

предел черты Option<&[BoundingBox]>: From<Option<BoundingBox>> не удовлетворен

То есть невозможно создать &[BoundingBox] из BoundingBox.

Метод locations определяется как:

pub fn locations(
    &mut self, 
    locations: impl Into<Option<&'a [BoundingBox]>>
) -> &mut Self

То есть он принимает любой тип, который может быть преобразован в Optionкусок координатных полей.Вы пытаетесь предоставить только Option одного поля координат.

Вместо этого создайте массив из одного значения и создайте срез:

.locations(Some(&[bounds][..]))

или

.locations(Some(std::slice::from_ref(&bounds)))

Вы также можете использовать тот факт, что Option<T> реализует From<T>:

.locations(&[bounds][..])

Или

.locations(std::slice::from_ref(&bounds))

См. Также:

• Аргументы функции по умолчанию в Rust

---

Для удобства чтения я делаю вид, что псевдоним этого типа существует:

type BoundingBox = ((f64, f64), (f64, f64));