DEV Community: pintuch

Rust - Reqwest examples

pintuch — Thu, 11 Mar 2021 11:20:57 +0000

Introduction

There are 3 things that need to happen:

Building a client that can be reused across multiple requests
Performing the execution of the network request
Parsing the response

use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build the client using the builder pattern
    let client = reqwest::Client::builder()
        .build()?;

    // Perform the actual execution of the network request
    let res = client
        .get("https://httpbin.org/ip")
        .send()
        .await?;

    // Parse the response body as Json in this case
    let ip = res
        .json::<HashMap<String, String>>()
        .await?;

    println!("{:?}", ip);
    Ok(())
}

Instead of parsing the json body as a dynamic hash-map, you could use a well-defined struct

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Ip {
    origin: String
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build the client using the builder pattern
    let client = reqwest::Client::builder()
        .build()?;

    // Perform the actual execution of the network request
    let res = client
        .get("https://httpbin.org/ip")
        .send()
        .await?;

    // Parse the response body as Json in this case
    let ip = res
        .json::<Ip>()
        .await?;

    println!("{:?}", ip);
    Ok(())
}

Query Strings

let client = reqwest::Client::builder()
    .build()?;

let res = client
    .get("http://httpbin.org")
    .query(&[("foo", "bar")])
    .send()?;

POST JSON Data

The json(..) method on the RequestBuilder takes any value that can be serialized into JSON such as a HashMap or a Struct.

let mut map = HashMap::new();
map.insert("foo", "bar");
map.insert("buzz", "blah");

...
.json(&map)

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize)]
struct Person {
    first_name: String,
    last_name: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct PersonResponse {
    data: String,
    method: String,
    headers: HashMap<String, String>
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let p = Person { 
        first_name: "Foo".into(),
        last_name: "Bar".into(),
    };

    let res = reqwest::Client::new()
        .post("https://httpbin.org/anything")
        .json(&p)
        .send()
        .await?;

    let js = res
        .json::<PersonResponse>()
        .await?;

    let person: Person = serde_json::from_str(&js.data)?;
    println!("{:#?}", person);

    println!("Headers: {:#?}", js.headers);
    Ok(())
}

POST Form data

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Person {
    first_name: String,
    last_name: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let p = Person { 
        first_name: "Foo".into(),
        last_name: "Bar".into(),
    };

    let res = reqwest::Client::new()
        .post("https://httpbin.org/anything")
        .form(&p)
        .send()
        .await?;

    let t = res
        .text()
        .await?;

    println!("{}", t);

//  $ cargo run
//      Finished dev [unoptimized + debuginfo] target(s) in 0.09s
//       Running `target/debug/reqwest-tut`
//  {
//    "args": {}, 
//    "data": "", 
//    "files": {}, 
//    "form": {
//      "first_name": "Foo", 
//      "last_name": "Bar"
//    }, 
//    "headers": {
//      "Accept": "*/*", 
//      "Content-Length": "28", 
//      "Content-Type": "application/x-www-form-urlencoded", 
//      "Host": "httpbin.org", 
//      "X-Amzn-Trace-Id": "Root=1-60453174-384d97870199933007fbb388"
//    }, 
//    "json": null, 
//    "method": "POST", 
//    "origin": "125.125.104.53", 
//    "url": "https://httpbin.org/anything"
//  }
//  
//  
    Ok(())
}

Request Headers

You can set the headers by calling the header(.., ..) method on the request

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .build()?;

    let res = client
        .post("https://httpbin.org/anything")
        .body("arbitrary text")
        .header("X-Person-First", "Foo!")
        .header("X-Person-Last", "Bar!!")
        .send()
        .await?;

    let t = res
        .text()
        .await?;

    println!("{}", t);
// {
//   "args": {}, 
//   "data": "arbitrary text", 
//   "files": {}, 
//   "form": {}, 
//   "headers": {
//     "Accept": "*/*", 
//     "Content-Length": "14", 
//     "Host": "httpbin.org", 
//     "X-Amzn-Trace-Id": "Root=1-604538df-218a5bb97264e7130c298b23", 
//     "X-Person-First": "Foo!", 
//     "X-Person-Last": "Bar!!"
//   }, 
//   "json": null, 
//   "method": "POST", 
//   "origin": "49.206.4.160", 
//   "url": "https://httpbin.org/anything"
// }

    Ok(())
}

You can also set default headers on the client that can be overriden while making individual requests

use reqwest::header;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let mut headers = header::HeaderMap::new();
    headers.insert("X-HEADER-1", header::HeaderValue::from_static("val1"));
    headers.insert("X-HEADER-2", header::HeaderValue::from_static("val2"));

    let client = reqwest::Client::builder()
        .default_headers(headers)
        .build()?;

    let res = client
        .get("https://httpbin.org/anything")
        .body("whatever")
        .header("X-HEADER-1", "overriden val1")
        .send()
        .await?;

    println!("{}", res.text().await?);

    // {
    //   "args": {},
    //   "data": "whatever",
    //   "files": {},
    //   "form": {},
    //   "headers": {
    //     "Accept": "*/*",
    //     "Content-Length": "8",
    //     "Host": "httpbin.org",
    //     "X-Amzn-Trace-Id": "Root=1-60453dad-429e59a434bd460b0a48e7d5",
    //     "X-Header-1": "overriden val1",
    //     "X-Header-2": "val2"
    //   },
    //   "json": null,
    //   "method": "GET",
    //   "origin": "49.206.4.160",
    //   "url": "https://httpbin.org/anything"
    // }

    Ok(())
}

Status Code

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = reqwest::Client::builder().build()?;

    let res = client
        .get("https://httpbin.org/status/400")
        .send()
        .await?;

    match res.status() {
        reqwest::StatusCode::BAD_REQUEST => println!(
            "content-length:{:?} server:{:?}", 
            res.headers().get(reqwest::header::CONTENT_LENGTH),
            res.headers().get(reqwest::header::SERVER),
        ),
        status => println!("status: {}", status),
    }

    // content-length:Some("0") server:Some("gunicorn/19.9.0")
    Ok(())
}

Timeouts

Client Timeout

let client = reqwest::Client::builder()
    .timeout(std::time::Duration::from_millis(500))
    .build()?;

Connect Timeout

let client = reqwest::Client::builder()
    .connect_timeout(std::time::Duration::from_millis(100))
    .build()?;

Request Timeout

let res = client
    .get(&url)
    .timeout(std::time::Duration::from_millis(500))
    .send()
    .await;

Download data

use std::fs::File;
use std::io;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder().build()?;

    let res = client
        .get("https://httpbin.org/image/png")
        .send()
        .await?
        .bytes()
        .await?;

    let mut data = res.as_ref();

    let mut f = File::create("i.png")?;

    io::copy(&mut data, &mut f)?;

    Ok(())
}

// $ file i.png 
// i.png: PNG image data, 100 x 100, 8-bit/color RGB, non-interlaced

Dependency configuration for the samples

[dependencies]
reqwest = { version = "0.11", features = ["json", "blocking", "cookies"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1.0" 
futures = "0.3"

Rust - my dumbness with grokking impl

pintuch — Thu, 07 Jan 2021 22:49:22 +0000

The first time I came across code like this

impl<T> MyTrait for MyStruct<T> {...}

I had wondered why must the generic type T show up next to both the impl as well as MyStruct. Wasn't MyStruct<T> enough to convey the intent?

I had my aha! moment today while working on a program that looked something similar to this:

struct MyStruct<T> {
    x: T    
}

trait Bogus {
    fn do_nothing(&self);
}

// missed the `impl<T>`
impl Bogus for MyStruct<T> {
    fn do_nothing(&self) {
        println!("do nothing")
    }
}

// somewhere way down in the code
type T = i32;

Out of habit, I had missed the type parameter T next to the impl keyword. The code still managed to compile.

Later, I noticed what had happened. So, did I end up implementing the Bogus trait for the generic MyStruct<T> or was it for MyStruct<i32>? As you might have already guessed, it's the latter.

It was now so obvious that the T next to impl serves the purpose of disambiguation. The compiler can't just assume it's a generic type just because the type declaration isn't immediately in our focus.

// implement Bogus Trait for MyStruct<T> where T could be any type
impl<T> Bogus for MyStruct<T> {
    fn do_nothing(&self) {
        println!("do nothing")
    }
}

// implement Bogus Trait for MyStruct<T> where T is a type declared somewhere
impl Bogus for MyStruct<T> {
    fn do_nothing(&self) {
        println!("do nothing")
    }
}

I feel so dumb that it took me so long to grok something so obvious!

Rust - Serde Json By Example

pintuch — Sun, 03 Jan 2021 17:03:23 +0000

Basic struct serialization and deserialization

Serialization happens via serde_json::to_string.
serde_json::to_string_pretty can be used for enhancing the readibility if you're printing the data.

pub fn to_string<T: ?Sized>(value: &T) -> Result<String> 
where
    T: Serialize

Deserialization happens via serde_json::from_str

pub fn from_str<'a, T>(s: &'a str) -> Result<T> 
where
    T: Deserialize<'a>

Since, the return type for both is a Result<T>, the examples below end up unwrap()ing the values.

Unit structs

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct U;

fn main() {
    let u = U;

    // serialization
    let s = serde_json::to_string(&u).unwrap();
    // `s` represented as `null`
    println!("{}", s);

    // deserialization
    let d: U = serde_json::from_str("null").unwrap();
    // `d` is U
    println!("{:?}", d);
}
// Output:
// null
// U

Tuple structs

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct T(u8, f64, bool, String);

fn main() {
    // serialization
    let t = T(10u8, 3.14159, true, "Hello".to_owned());
    let s = serde_json::to_string(&t).unwrap();
    // `s` represented as `[10, 3.14159, true, "Hello"]`
    println!("{}", s);

    // deserialization
    let d: T = serde_json::from_str(r#"[10, 3.14159, true, "Hello"]"#).unwrap();
    // `d` is `T(10u8, 3.14159, true, "Hello".to_owned())`;
    println!("{:?}", d);
}
// Output:
// [10,3.14159,true,"Hello"]
// T(10, 3.14159, true, "Hello")

Haskell Newtype-like structs

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct N(i32);

fn main() {
    // serialization
    let n = N(10i32);
    let s = serde_json::to_string(&n).unwrap();
    // `s` represented as `10`
    println!("{}", s);

    // deserialization
    let d: N = serde_json::from_str("10").unwrap();
    // `d` is `N(10)`;
    println!("{:?}", d);
}
// Output:
// 10
// N(10)

C-like structs

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct C {
    a: i32,
    b: f64,
    c: bool,
    d: String,
}

fn main() {
    // serialization
    let t = C {
        a: 10,
        b: 3.14159,
        c: true,
        d: "Hello".to_owned(),
    };
    let s = serde_json::to_string(&t).unwrap();
    // `s` represented as `{"a": 10, "b": 3.14159, "c": true, "d": "Hello"}`
    println!("{}", s);

    // deserialization
    let d: C = serde_json::from_str(&s).unwrap();
    println!("{:?}", d);
}

// Output:
// {"a":10,"b":3.14159,"c":true,"d":"Hello"}
// C { a: 10, b: 3.14159, c: true, d: "Hello" }

Optional values

The examples you have come across so far had structs with required values.
null is a valid json value that is often used in cases data is missing.
Take for example the following:

#[derive(Serialize, Deserialize)]
struct C {
    a: i32,
    b: f64,
}

// serialization with missing value
let t = C {
  b: 3.14159,
};
serde_json::to_string(&t).unwrap();

The above program would fail to compile since we've missed a entirely

error[E0063]: missing field `a` in initializer of `C`

Deserialization with a null value for a would cause errors.
Its type is i32 and we can't arbitrarily choose 0 to indicate absence of data.
In such cases, it's preferred that we mark the values as Optional as shown below.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct C {
    a: Option<i32>,
    b: f64,
}

fn main() {
    // serialization with missing value
    let t = C {
        a: None,
        b: 3.14159,
    };
    println!("{}", serde_json::to_string(&t).unwrap());
    // `{"a": null, "b": 3.14159}`

    // deserialization with missing value
    let d: C = serde_json::from_str(r#"{"a": null, "b": 3.14159}"#).unwrap();
    // `d` equals `C { a: None, b: 3.14159 }`
    println!("{:?}", d);

    println!("Hello, world!");
}

// Output:
// {"a":null,"b":3.14159}
// C { a: None, b: 3.14159 }
// Hello, world!

Default values

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Test {
    // Use default_str_fun() as the default if "my_str" is missing
    #[serde(default = "default_str_fun")]
    my_str: String,

    // Use MyType::default if "my_type" is missing
    #[serde(default)]
    my_type: MyType,
}

fn default_str_fun() -> String {
    "hi".to_owned()
}

/// Timeout in seconds.
#[derive(Deserialize, Debug)]
struct MyType(Vec<i32>);
impl std::default::Default for MyType {
    fn default() -> Self {
        Self(vec![1, 2, 3])
    }
}

fn main() {
    let d1: Test = serde_json::from_str(r#"{"my_type": [1]}"#).unwrap();
    // `d1` equals `Test { my_str: "hi".to_owned(), my_type: MyType(vec![1]) }`
    println!("{:?}", d1);

    let d2: Test = serde_json::from_str(r#"{"my_str": "hello world"}"#).unwrap();
    // `d2` equals `Test { my_str: "hello world".to_owned(), my_type: MyType(vec![1,2,3]) }`
    println!("{:?}", d2);

    println!("Hello, world!");
}

// Output:
// Test { my_str: "hi", my_type: MyType([1]) }
// Test { my_str: "hello world", my_type: MyType([1, 2, 3]) }
// Hello, world!

Missing field vs null value

A null value isn't the same as a missing field altogether.
The following program panics on deserialization.

// ================
// BROKEN
// ================
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Test {
    // Use default_str_fun() as the default if "my_str" is missing
    #[serde(default = "default_str_fun")]
    my_str: String,

    // Use MyType::default if "my_type" is missing
    #[serde(default)]
    my_type: MyType,
}

fn default_str_fun() -> String {
    "hi".to_owned()
}

/// Timeout in seconds.
#[derive(Deserialize, Debug)]
struct MyType(Vec<i32>);
impl std::default::Default for MyType {
    fn default() -> Self {
        Self(vec![1, 2, 3])
    }
}

fn main() {

    let d: Test = serde_json::from_str(r#"{
        "my_str": "hello world", 
        "my_type": null
    }"#).unwrap();
    println!("{:?}", d);
}

// Output:
// Running `target/debug/playground`
// thread 'main' panicked at 'called `Result::unwrap()` on an 
// `Err` value: Error("invalid type: null, expected a sequence", line: 3, column: 23)', 
// src/main.rs:32:10
// note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

json! macro

The json! macro allows one to construct serde_json::Value objects by hand.

let j: serde_json::Value = json!({
    "a": 10u8,
    "b": 3.14159,
    "c": true,
    "d": "Hello".to_owned(),
});
let s = j.to_string();
// `s` represented as `{"a": 10, "b": 3.14159, "c": true, "d": "Hello"}`

Deserializing to Map

// deserializing to Map<String, Value>
use serde_json::{Value, Map};
println!(
    "{:?}", 
    serde_json::from_str::<Map<String, Value>>(r#"
        {"gender":"male","blah":25}
        "#).unwrap());
// {"blah": Number(25), "gender": String("male")}

enums

The default enum representation has the enum variant 'externally tagging' the content.

#[derive(Serialize, Deserialize)]
enum Color {
    C { red: u8, green: u8, blue: u8 },
    T(u8, u8, u8),
    N(i32),
    D,
}
let a = Color::C { 
    red: 10,
    green: 100,
    blue: 125
}; 
// `a` represented as `{"C":{"red":10,"green":100, "blue": 125}}`

let b = Color::T(10, 100, 125); 
// `b` represented as `{"T":[10,100,125]}`

let c = Color::N(0);
// `c` represented as `{"N":0}`

let d = Color::D;
// `d` represented as `"D"`

It's also possible to delineate the tag and content separately in the object
next to each other

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
#[serde(tag = "type", content = "body")]
enum Color {
    C { red: u8, green: u8, blue: u8 },
    T(u8, u8, u8),
    N(i32),
    D,
}

fn main() {
    let a = Color::C {
        red: 10,
        green: 100,
        blue: 125,
    };
    println!("{}", serde_json::to_string(&a).unwrap());
    // {"type":"C","body":{"red":10,"green":100,"blue":125}}
}

Ommitting the content should merge the tag with the rest of the content.

// ===============
// BROKEN PROGRAM
// ===============

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
#[serde(tag = "type")]
enum Color {
    C { red: u8, green: u8, blue: u8 },
    T(u8, u8, u8),
    N(i32),
    D,
}

fn main() {
    println!("Hello, world!");
    let a = Color::C {
        red: 10,
        green: 100,
        blue: 125,
    };
    println!("{}", serde_json::to_string(&a).unwrap());
}

Wait! The code fails to build. Let's look at the error message.

Compiling playground v0.0.1 (/playground)
error: #[serde(tag = "...")] cannot be used with tuple variants
 --> src/main.rs:7:5
  |
7 |     T(u8, u8, u8),
  |     ^^^^^^^^^^^^^

error[E0277]: the trait bound `Color: Serialize` is not satisfied
    --> src/main.rs:19:42
     |
19   |     println!("{}", serde_json::to_string(&a).unwrap());
     |                                          ^^ the trait `Serialize` is not implemented for `Color`
     | 
    ::: /playground/.cargo/registry/src/github.com-1ecc6299db9ec823/serde_json-1.0.61/src/ser.rs:2221:17
     |
2221 |     T: ?Sized + Serialize,
     |                 --------- required by this bound in `serde_json::to_string`

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

Removing the tuple variant makes it work again! I haven't really spent time figuring
out what's gone wrong here.

// Using just serde `tag` and no `content`

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
#[serde(tag = "type")]
enum Color {
    C { red: u8, green: u8, blue: u8 },

    // commenting out the tuple variant
    // T(u8, u8, u8),

    N(i32),
    D,
}

fn main() {
    let a = Color::C {
        red: 10,
        green: 100,
        blue: 125,
    };
    println!("{}", serde_json::to_string(&a).unwrap());
    // {"type":"C","red":10,"green":100,"blue":125}
}

If you don't want any tag information creeping in the serialized string,
choose the untagged representation. While deserializing, serde would try
each variant and returns the first one that succeeds.

// Untagged version

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
#[serde(untagged)]
enum Color {
    C { red: u8, green: u8, blue: u8 },
    T(u8, u8, u8),
    N(i32),
    D,
}

fn main() {
    let a = Color::C {
        red: 10,
        green: 100,
        blue: 125,
    };
    println!("{}", serde_json::to_string(&a).unwrap());
    // {"red":10,"green":100,"blue":125}
}

Aliasing and renaming fields

You can change the case for individual or all of the fields while serializing
to json representation.

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Address {
    id: i64,
    street_name: String,
    zip_code: String,
    city: String,
}

let address = Address {
    id: 1,
    street_name: "ABC street".to_owned(),
    zip_code: "10101010".to_owned(),
    city: "XYZ City".to_owned(),
};
let js = serde_json::to_string(&address).unwrap();
// js represented as:
// `{"id": 1, "streetName": "ABC street", "zipCode": "10101010", "city": "XYZ City"}`

Fields can also be aliased by multiple names while deserializing the json string.
e.g. field attribute: #[serde(alias = "<Choose your field alias>")]

You can avoid serializing or deserializing a field. The attributes to consider are the following:
#[serde(skip_deserializing)], #[serde(skip_serializing)], #[serde(skip)]

#[derive(Serialize, Deserialize, Debug)]
struct XYZP {
    #[serde(alias = "gender")]
    #[serde(alias = "category")]
    sex: String,

    #[serde(rename = "blah")]
    age_years: u8,

    #[serde(skip)]
    weight_kg: u8,
}

let xyzp = XYZP {
    sex: "male".to_owned(),
    age_years: 25,
    weight_kg: 76,
};

println!("{}", serde_json::to_string(&xyzp).unwrap());
// {"sex":"male","blah":25}

println!(
    "{:?}", 
    serde_json::from_str::<XYZP>(r#"
        {"gender":"male","blah":25}
        "#
    ).unwrap());
// XYZP { sex: "male", age_years: 25, weight_kg: 0 }

Rust - nth element

pintuch — Sat, 02 Jan 2021 10:48:26 +0000

I am new to Rust and have skimmed through most of the chapters of the Rust Book. However, to get some programming practice, I decided to work through few of the 99 scheme problems. The subject of this post is the third problem on that list.

// nth returns an optional value to the nth element
// of the list. The value of n indicates the position
// (= index + 1).

fn nth<T>(xs: &[T], n: usize) -> Option<T> {
    if (n < 1) || n > xs.len() {
        None
    } else {
        Some(xs[n-1])
    }
}

The code above was my first attempt at the problem. Well, how hard could indexing into a slice be? I had already checked the following worked.

let xs = &["he", "el", "lo"];
println!("{}", xs[0]); // he is printed out

But, to my surprise, the Rust compiler was unhappy.

error[E0508]: cannot move out of type `[T]`, a non-copy slice
  --> src/main.rs:18:14
   |
18 |         Some(xs[n-1])
   |              ^^^^^^^
   |              |
   |              cannot move out of here
   |              move occurs because `xs[_]` has type `T`, which does not implement the `Copy` trait

error: aborting due to previous error

For more information about this error, try `rustc --explain E0508`.

The way I interpret the error is that in the absence of a borrow, the indexed value either gets copied or moved out of the slice. The former isn't an option since the generic type T doesn't implement the Copy trait by default. And, I guess, for the latter to work, you'd need to give up the ownership of the value in that position, almost creating a hole in the slice which would be awkward. One could also argue maybe giving up the ownership of the entire slice is a decent compromise that works around the problem of leaving holes. But, then that means you can't de-allocate the rest of the slice anymore as long as the indexed value is in scope. I'm not sure if this was the reason behind the current behavior.

So, to fix, i could try taking a reference or constrain my slice to types that implement the Copy trait. Sure enough, the following code compiles:

// Option<&T> works
fn nth<T>(xs: &[T], n: usize) -> Option<&T> {
    if n < 1 || n > xs.len() {
        None
    }
    else{
        Some(&xs[n-1])
    }
}

And so does this too:

// <T: Copy> works
fn nth<T: Copy>(xs: &[T], n: usize) -> Option<T> {
    if n < 1 || n > xs.len() {
        None
    }
    else{
        Some(xs[n-1])
    }
}

So, what explains this?

let xs = &["he", "el", "lo"]; // xs: &[&str]
println!("{}", xs[0]);

&str is a shared/immutable reference to the static data. Copying the reference should be cheap enough and since it doesn't own the literal slice itself, it should be safe. It's expected that it follows Copy semantics.

But what about String types? Would we run into trouble since String is a pointer to owned heap-allocated data and copying the pointer would simply create two owners to the same piece of data (causing double-free)? Since that can't happen, printing an indexed value from a slice of String values should fail to compile, right?

let xs = &["he", "el", "lo"];
let ys = &[String::from("he"), String::from("el"), String::from("lo")];

println!("{}", xs[0]);
println!("{}", ys[0]);

The code above compiles. However, this doesn't:

let xs = &["he", "el", "lo"];
let x: &str = xs[0];

let ys = &[String::from("he"), String::from("el"), String::from("lo")];
let y: String = ys[0];

println!("{}", xs[0]);
println!("{}", ys[0]);

error[E0508]: cannot move out of type `[std::string::String; 3]`, a non-copy array
  --> src/main.rs:50:21
   |
50 |     let y: String = ys[0];
   |                     ^^^^^
   |                     |
   |                     cannot move out of here
   |                     move occurs because `ys[_]` has type `std::string::String`, which does not implement the `Copy` trait
   |                     help: consider borrowing here: `&ys[0]`

error: aborting due to previous error; 2 warnings emitted

For more information about this error, try `rustc --explain E0508`.

It turns out println! macro has a special behavior. It borrows the value being formatted implicitly, which is why we never see those 'move out of type' errors.