Grammers Client

https://docs.rs/grammers-client/latest/
Admin
Grammers Client is a high-level Rust library for accessing Telegram's API, enabling automation of...
Tokens:484,801
Snippets:4,087
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Request login code example (incomplete)

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/auth.rs.html?search=u32+-%3E+bool

Starts an example for requesting a login code, but the code block is incomplete and cut off. It shows the beginning of an async function with a fake API hash constant.

```rust
/// # Examples
///
/// ```
/// # async fn f(client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// // Note: these values are obviously fake.
/// //       Obtain your own with the developer's phone at https://my.telegram.org.
/// const API_HASH: &str = "514727c32270b9eb8cc16daf17e21e57";
/// //       The phone used here does NOT need to be the same as the one used by the developer
/// //       to obtain the API ID and hash.
```

--------------------------------

### as_mut example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Demonstrates using as_mut to get mutable references to the Ok or Err values, allowing mutation through a match.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### react() method example

Source: https://docs.rs/grammers-client/latest/src/grammers_client/message/message.rs.html?search=

Example of reacting to a message with a Unicode emoji. The method is asynchronous and returns a Result.

```rust
# async fn f(message: grammers_client::message::Message, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
message.react("👍").await?;
# Ok(())
# }
```

--------------------------------

### Sign in example

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/auth.rs.html?search=

Shows how to sign in using `client.sign_in(&token, &code)`. The example handles `SignInError::PasswordRequired`, `SignInError::SignUpRequired`, and other errors, then prints the user's first name or a generic message.

```rust
/// # use grammers_client::SignInError;
///
///  async fn f(client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// # const API_HASH: &str = "";
/// # const PHONE: &str = "";
/// fn ask_code_to_user() -> String {
///     unimplemented!()
/// }
///
/// let token = client.request_login_code(PHONE, API_HASH).await?;
/// let code = ask_code_to_user();
///
/// let user = match client.sign_in(&token, &code).await {
///     Ok(user) => user,
///     Err(SignInError::PasswordRequired(_token)) => panic!("Please provide a password"),
///     Err(SignInError::SignUpRequired) => panic!("Sign up required"),
///     Err(err) => {
///         println!("Failed to sign in as a user :(\n{}", err);
///         return Err(err.into());
///     }
/// };
///
/// if let Some(first_name) = user.first_name() {
///     println!("Signed in as {}!", first_name);
/// } else {
///   println!("Signed in!");
/// }
/// # Ok(())
/// # }
```

--------------------------------

### is_ok_and() Example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `is_ok_and()` to check if a `Result` is `Ok` and the value matches a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### is_ok() Example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `is_ok()` to check if a `Result` is `Ok`.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

--------------------------------

### map example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Shows how to use map to apply a function to the Ok value, leaving Err untouched. The example parses lines and multiplies numbers by two.

```rust
let line = "1\n2\n3\n4\n";

for num in line.lines() {
    match num.parse::<i32>().map(|i| i * 2) {
        Ok(n) => println!("{n}"),
        Err(..) => {}
    }
}
```

--------------------------------

### and_then example: using metadata and modified

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Demonstrates using and_then with Path::metadata and modified to get the modification time of a root path and a non-existent path. Shows that the root path succeeds, while the bad path fails with ErrorKind::NotFound.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Create a new Client with SenderPool

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Creates a new client instance using a session and sender pool. The example uses a MemorySession (not for production) and example API_ID values.

```rust
use std::sync::Arc;
use grammers_client::Client;
use grammers_session::storages::MemorySession; // avoid this storage outside tests!
use grammers_mtsender::SenderPool;

// Note: these are example values and are not actually valid.
//       Obtain your own with the developer's phone at https://my.telegram.org.
const API_ID: i32 = 932939;

let session = Arc::new(MemorySession::default());
let pool = SenderPool::new(Arc::clone(&session), API_ID);
let client = Client::new(pool.handle);
```

--------------------------------

### transpose() Example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `transpose()` to convert a `Result<Option<T>, E>` into an `Option<Result<T, E>>`.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

--------------------------------

### Client::send_message example with InputMessage

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/messages.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example usage for `Client::send_message`: sends a plain text message and then a message with `InputMessage` to set text and the `silent` flag. The example is wrapped in a hidden async function that returns a `Result`.

```rust
/// # Examples
///
/// ```
/// # async fn f(peer: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// client.send_message(peer, "Boring text message :-(").await?;
///
/// use grammers_client::message::InputMessage;
///
/// client.send_message(peer, InputMessage::new().text("Sneaky message").silent(true)).await?;
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### Iterate profile photos with iter_profile_photos

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/chats.rs.html

Example for iter_profile_photos. The current photo might not be present in the history. Photos cannot be sent directly; they must be downloaded, uploaded, and then sent. The example iterates over photos and prints each photo's ID.

```rust
# async fn f(peer: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
let mut photos = client.iter_profile_photos(peer);

while let Some(photo) = photos.next().await? {
    println!("Did you know peer has a photo with ID {}?", photo.id());
}
# Ok(())
# }
```

--------------------------------

### is_err_and example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Shows how to use is_err_and to check if a Result is Err and the error value matches a predicate. The example includes cases with different error kinds and an Ok value, and demonstrates using as_ref to avoid consuming the Result.

```rust
use std::io::{Error, ErrorKind};

let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);

let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, Error> = Ok(123);
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, String> = Err("ownership".to_string());
assert_eq!(x.as_ref().is_err_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### and_then example: chaining fallible operations

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Shows how to use and_then to chain operations that may fail. The example defines a function sq_then_to_string that squares a number and converts to string, returning an error on overflow. Demonstrates successful chaining, overflow error, and propagation of an existing error.

```rust
assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

--------------------------------

### Set admin rights with load_current, pin_messages, and ban_users

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/chats.rs.html

Example for set_admin_rights. By default, no permissions are granted; set permissions to true to grant them. The change is applied forever. The example loads current admin rights, then grants pin_messages and ban_users permissions.

```rust
# async fn f(chat: grammers_session::types::PeerRef, user: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
// Let the user pin messages and ban other people
let res = client.set_admin_rights(chat, user)
    .load_current()
    .await?
    .pin_messages(true)
    .ban_users(true)
    .await?;
# Ok(())
# }
```

--------------------------------

### expect example (panics)

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Returns the contained Ok value, consuming self, and panics if the value is Err. The example shows a panic message including the passed message and the Err content.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

--------------------------------

### Upload video with thumbnail using InputMedia

Source: https://docs.rs/grammers-client/latest/grammers_client/media/struct.InputMedia.html

Example for the `thumbnail` method: uploads a video and a thumbnail, then builds an InputMedia with an empty caption, the video as document, and the thumbnail. Requires the `grammers_client` crate and an async client.

```rust
async fn f(client: &mut grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
    use grammers_client::media::InputMedia;

    let video = client.upload_file("video.mp4").await?;
    let thumb = client.upload_file("thumb.png").await?;
    let media = InputMedia::new().caption("").document(video).thumbnail(thumb);
    Ok(())
}
```

--------------------------------

### Sign in as a bot using bot_sign_in

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Signs in to a bot account using a token and API hash. The example shows error handling and printing the bot's first name. Note that the values are fake and should be replaced with real ones.

```rust
// Note: these values are obviously fake.
//       Obtain your own with the developer's phone at https://my.telegram.org.
const API_HASH: &str = "514727c32270b9eb8cc16daf17e21e57";
//       Obtain your own by talking to @BotFather via a Telegram app.
const TOKEN: &str = "776609994:AAFXAy5-PawQlnYywUlZ_b_GOXgarR3ah_yq";

let user = match client.bot_sign_in(TOKEN, API_HASH).await {
    Ok(user) => user,
    Err(err) => {
        println!("Failed to sign in as a bot :(\n{}", err);
        return Err(err.into());
    }
};

if let Some(first_name) = user.first_name() {
    println!("Signed in as {}!", first_name);
} else {
    println!("Signed in!");
}
```

--------------------------------

### Get messages by ID and count missing

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Retrieves up to 100 messages by their IDs. The example counts how many messages could not be retrieved and prints the result.

```rust
let message_ids = [123, 456, 789];

let messages = client.get_messages_by_id(peer, &message_ids).await?;
let count = messages.into_iter().filter(Option::is_some).count();
println!("{} out of {} messages were deleted!", message_ids.len() - count, message_ids.len());
```

--------------------------------

### Get messages by ID and count deleted

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/messages.rs.html

Fetches messages by their IDs from a peer and counts how many were deleted. The example prints the number of deleted messages out of the total requested.

```rust
# async fn f(peer: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
let message_ids = vec![1, 2, 3];
let messages = client.get_messages_by_id(peer, &message_ids).await?;
let count = messages.into_iter().filter(Option::is_some).count();
println!("{} out of {} messages were deleted!", message_ids.len() - count, message_ids.len());
# Ok(())
# }

```

--------------------------------

### Get permissions of a user in a chat with client.get_permissions

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/chats.rs.html?search=

Retrieves the permissions of a user in a chat and prints whether the user is an admin. The example is wrapped in an async function that returns a `Result`.

```rust
/// ```
/// # async fn f(chat: grammers_session::types::PeerRef, user: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
/// let permissions = client.get_permissions(chat, user).await?;
/// println!("The user {} an admin", if permissions.is_admin() { "is" } else { "is not" });
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### expect example (recommended message style)

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Shows the recommended style for expect messages: describe the reason you expect the Result to be Ok, using the word 'should'.

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### Get pinned message from peer

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Retrieves the latest pinned message from a peer. The example prints the message text if one is pinned, otherwise prints a message indicating none are pinned.

```rust
if let Some(message) = client.get_pinned_message(peer).await? {
    println!("There is a message pinned: {}", message.text());
} else {
    println!("There are no messages pinned");
}
```

--------------------------------

### ok example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Demonstrates converting a Result to an Option using ok, which returns Some(value) for Ok and None for Err.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### Get participant permissions with client.get_permissions

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/chats.rs.html

Retrieves the permissions of a user in a chat using client.get_permissions. The example prints whether the user is an admin. Requires a grammers_client::Client and grammers_session::types::PeerRef for both chat and user.

```rust
# async fn f(chat: grammers_session::types::PeerRef, user: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
let permissions = client.get_permissions(chat, user).await?;
println!("The user {} an admin", if permissions.is_admin() { "is" } else { "is not" });
# Ok(())
# }

```

--------------------------------

### Client::new

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html?search=std%3A%3Avec

Creates a new client instance with a sender pool, initializing the connection and session as needed.

```APIDOC
## Client::new

### Description
Creates and returns a new client instance upon successful connection to Telegram. If the session in the configuration did not have an authorization key, a new one will be created and the session will be saved with it. The connection will be initialized with the data from the input configuration.

### Method
`pub fn new(sender_pool: SenderPoolFatHandle) -> Self`

### Parameters
- **sender_pool** (SenderPoolFatHandle) - Required - The sender pool handle used for network connectivity.

### Examples
```rust
use std::sync::Arc;
use grammers_client::Client;
use grammers_session::storages::MemorySession; // avoid this storage outside tests!
use grammers_mtsender::SenderPool;

// Note: these are example values and are not actually valid.
//       Obtain your own with the developer's phone at https://my.telegram.org.
const API_ID: i32 = 932939;

let session = Arc::new(MemorySession::default());
let pool = SenderPool::new(Arc::clone(&session), API_ID);
let client = Client::new(pool.handle);
```
```

--------------------------------

### Client::with_configuration

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Creates a new Client instance with a custom ClientConfiguration, similar to new but allowing additional configuration options.

```APIDOC
## Client::with_configuration

### Description
Like `Self::new` but with a custom `ClientConfiguration`.

### Method
`pub fn with_configuration(sender_pool: SenderPoolFatHandle, configuration: ClientConfiguration) -> Self`

### Parameters
- **sender_pool** (SenderPoolFatHandle) - Required - The sender pool handle.
- **configuration** (ClientConfiguration) - Required - Custom configuration for the client.
```

--------------------------------

### Get messages by ID with client.get_messages_by_id

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/messages.rs.html

Fetches up to 100 messages using their IDs. The example passes an array of message IDs and awaits the result. The returned list has the same length as the input, with None for messages that could not be retrieved or do not belong to the peer.

```rust
# async fn f(peer: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
let message_ids = [123, 456, 789];

let messages = client.get_messages_by_id(peer, &message_ids).await?;
```

--------------------------------

### Create a reply keyboard with from_keys

Source: https://docs.rs/grammers-client/latest/src/grammers_client/message/reply_markup.rs.html

Builds a reply keyboard markup from a matrix of Key rows. The example sends a message with the markup to a peer.

```rust
# async fn f(client: &mut grammers_client::Client, peer: grammers_session::types::PeerRef) -> Result<(), Box<dyn std::error::Error>> {
use grammers_client::message::{InputMessage, ReplyMarkup, Key};

let markup = ReplyMarkup::from_keys(&[
    vec![Key::text("Accept")],
    vec![Key::text("Cancel"), Key::text("Try something else")],
]);
client.send_message(peer, InputMessage::new().text("What do you want to do?").reply_markup(markup)).await?;
# Ok(())
# }
```

--------------------------------

### Get permissions of participant

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Gets permissions of a participant in a chat.

```rust
let permissions = client.get_permissions(chat, user).await?;
println!("The user {} an admin", if permissions.is_admin() { "is" } else { "is not" });
```

--------------------------------

### Request login code example

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/auth.rs.html?search=

Shows how to request a login code for a user account using a phone number and API hash. The phone does not need to match the developer's phone.

```rust
# async fn f(client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
// Note: these values are obviously fake.
//       Obtain your own with the developer's phone at https://my.telegram.org.
const API_HASH: &str = "514727c32270b9eb8cc16daf17e21e57";
//       The phone used here does NOT need to be the same as the one used by the developer
//       to obtain the API ID and hash.

```

--------------------------------

### is_err() Example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `is_err()` to check if a `Result` is `Err`.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### Add audio attribute to InputMedia

Source: https://docs.rs/grammers-client/latest/grammers_client/media/struct.InputMedia.html

Example for the `attribute` method: creates an InputMedia with an empty caption, a document (audio), and an Audio attribute with a duration of 123 seconds, title "Hello", and performer "World". Must be called after setting a file.

```rust
use std::time::Duration;
use grammers_client::media::{Attribute, InputMedia};

let media = InputMedia::new().caption("").document(audio).attribute(
   Attribute::Audio {
       duration: Duration::new(123, 0),
       title: Some("Hello".to_string()),
       performer: Some("World".to_string()),
   }
);
```

--------------------------------

### Client::new

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Creates a new Client instance using a SenderPoolFatHandle. Initializes the connection with the session and API ID from the pool.

```APIDOC
## Client::new

### Description
Creates and returns a new client instance upon successful connection to Telegram. If the session in the configuration did not have an authorization key, a new one will be created and the session will be saved with it.

### Method
`pub fn new(sender_pool: SenderPoolFatHandle) -> Self`

### Parameters
- **sender_pool** (SenderPoolFatHandle) - Required - The sender pool handle that shares the session and API ID.

### Example
```rust
use std::sync::Arc;
use grammers_client::Client;
use grammers_session::storages::MemorySession; // avoid this storage outside tests!
use grammers_mtsender::SenderPool;

// Note: these are example values and are not actually valid.
//       Obtain your own with the developer's phone at https://my.telegram.org.
const API_ID: i32 = 932939;

let session = Arc::new(MemorySession::default());
let pool = SenderPool::new(Arc::clone(&session), API_ID);
let client = Client::new(pool.handle);
```
```

--------------------------------

### offset_date

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.MessageIter.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Changes the starting message date. This allows you to start iterating from messages after a specific date.

```APIDOC
## offset_date

### Description
Changes the starting message date. This allows you to start iterating from messages after a specific date.

### Method
`pub fn offset_date(self, offset: i32) -> Self`

### Parameters
- **offset** (i32) - Required - The date (as a Unix timestamp) to start from.

### Returns
- **Self** - The modified MessageIter instance.
```

--------------------------------

### as_ref example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Shows how to convert a &Result to a Result of references using as_ref, leaving the original unchanged.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### flatten() Examples

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Examples of using `flatten()` to remove one level of nesting from a `Result<Result<T, E>, E>`.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

--------------------------------

### cloned() Example for Result<&mut T, E>

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `cloned()` on a `Result<&mut T, E>` to clone the `Ok` value.

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### Sign in as a bot

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/auth.rs.html

Demonstrates how to authenticate the client using a bot token and API hash. It is recommended to save the session after a successful login.

```rust
# async fn f(client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
// Note: these values are obviously fake.
//       Obtain your own with the developer's phone at https://my.telegram.org.
const API_HASH: &str = "514727c32270b9eb8cc16daf17e21e57";
//       Obtain your own by talking to @BotFather via a Telegram app.
const TOKEN: &str = "776609994:AAFXAy5-PawQlnYywUlZ_b_GOXgarR3ah_yq";

let user = match client.bot_sign_in(TOKEN, API_HASH).await {
    Ok(user) => user,
    Err(err) => {
        println!("Failed to sign in as a bot :(\n{}", err);
        return Err(err.into());
    }
};

if let Some(first_name) = user.first_name() {
    println!("Signed in as {}!", first_name);
} else {
    println!("Signed in!");
}

# Ok(())
# }
```

--------------------------------

### copied() Example for Result<&mut T, E>

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `copied()` on a `Result<&mut T, E>` to copy the `Ok` value.

```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

--------------------------------

### pub async fn download_media<P: AsRef<Path>>(&self, path: P) -> Result<bool, InvocationError>

Source: https://docs.rs/grammers-client/latest/grammers_client/message/struct.Message.html?search=

Downloads the message media if applicable. Returns true if there was media to download, false otherwise. Shorthand for Client::download_media.

```APIDOC
## pub async fn download_media<P: AsRef<Path>>(&self, path: P) -> Result<bool, InvocationError>

### Description
Download the message media in this message if applicable. Returns `true` if there was media to download, or `false` otherwise. Shorthand for `Client::download_media`.

### Method
Async method on `Message` struct.

### Parameters
- **path** (`P: AsRef<Path>`) - Required - The file path where the media will be saved.

### Returns
- `Result<bool, InvocationError>` - Ok(true) if media was downloaded, Ok(false) if no media, or an error if the download fails.

```

--------------------------------

### send_album example: Send an album with a photo URL

Source: https://docs.rs/grammers-client/latest/src/grammers_client/client/messages.rs.html

Shows how to use Client::send_album to send an album of media items. Requires an InputMedia with a caption and photo URL. The method returns a vector of Option<Message>.

```rust
# async fn f(peer: grammers_session::types::PeerRef, client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
use grammers_client::media::InputMedia;

client.send_album(peer, vec![InputMedia::new().caption("A album").photo_url("https://example.com/cat.jpg")]).await?;
# Ok(())
# }
```

--------------------------------

### unwrap_err() Success Example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Returns the contained Err value, consuming self. This example shows the successful case where the value is an Err.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

--------------------------------

### cloned() Example for Result<&T, E>

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `cloned()` to map a `Result<&T, E>` to `Result<T, E>` by cloning the `Ok` value.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
```

--------------------------------

### Sign in with login code using client.sign_in

Source: https://docs.rs/grammers-client/latest/grammers_client/client/struct.Client.html

Signs in using a login token and code obtained from request_login_code. Handles PasswordRequired and SignUpRequired errors. Recommended to save the session after successful login.

```rust
async fn f(client: grammers_client::Client) -> Result<(), Box<dyn std::error::Error>> {
fn ask_code_to_user() -> String {
    unimplemented!()
}

let token = client.request_login_code(PHONE, API_HASH).await?;
let code = ask_code_to_user();

let user = match client.sign_in(&token, &code).await {
    Ok(user) => user,
    Err(SignInError::PasswordRequired(_token)) => panic!("Please provide a password"),
    Err(SignInError::SignUpRequired) => panic!("Sign up required"),
    Err(err) => {
        println!("Failed to sign in as a user :(\n{}", err);
        return Err(err.into());
    }
};

if let Some(first_name) = user.first_name() {
    println!("Signed in as {}!", first_name);
} else {
  println!("Signed in!");
}
}
```

--------------------------------

### copied() Example for Result<&T, E>

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Example of using `copied()` to map a `Result<&T, E>` to `Result<T, E>` by copying the `Ok` value.

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
```

--------------------------------

### into_ok() Example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Returns the contained Ok value, but never panics. This is a nightly-only experimental API. It can be used instead of unwrap as a maintainability safeguard.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### iter_mut example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Returns a mutable iterator over the possibly contained value. The example shows modifying the value through the iterator and that it yields none for Err.

```rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### iter example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Returns an iterator over the possibly contained value. The example shows that the iterator yields one value for Ok and none for Err.

```rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### inspect example

Source: https://docs.rs/grammers-client/latest/grammers_client/type.Result.html

Calls a function with a reference to the contained value if Ok, and returns the original result. The example shows chaining inspect with map and expect.

```rust
let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("literal `4` should parse as a `u8`");
```
Tokens:
Raw