fn get_links(link_nodes: Select) -> Option<String> {

        let mut rel_permalink: Option<String> = for node in link_nodes {
            link = String::from(node.value().attr("href")?);

            return Some(link);
        };

        Some(rel_permalink)
    }

This is what I’m trying to do, and I’ve been stuck with this code for an hour, I simply don’t know how to put this function togheter… Essentially I would like to take some link_nodes and just return the link String, but I’m stuck in the use of Option with the ? operator… Pheraps trying to write it with match would clear things out(?)

Also I come from JavaScript in which expressions do not have their own scope, meaning I’m having troubles to understand how to get out a variable from a for loop, should I initialize the rel_permalink variable as the for loop result?

This are the errors i get:

error[E0308]: mismatched types
  --> src/main.rs:55:49
   |
55 |           let mut rel_permalink: Option<String> = for node in link_nodes {
   |  _________________________________________________^
56 | |             link = String::from(node.value().attr("href")?);
57 | |
58 | |             return Some(link);
59 | |         };
   | |_________^ expected `Option<String>`, found `()`
   |
   = note:   expected enum `Option<String>`
           found unit type `()`
note: the function expects a value to always be returned, but loops might run zero times
  --> src/main.rs:55:49
   |
55 |         let mut rel_permalink: Option<String> = for node in link_nodes {
   |                                                 ^^^^^^^^^^^^^^^^^^^^^^ this might have zero elements to iterate on
56 |             link = String::from(node.value().attr("href")?);
   |                                                          - if the loop doesn't execute, this value would never get returned
57 |
58 |             return Some(link);
   |             ----------------- if the loop doesn't execute, this value would never get returned
   = help: return a value for the case when the loop has zero elements to iterate on, or consider changing the return type to account for that possibility
  • gigapixel@mastodontti.fi
    0·
    19 days ago

    @dontblink For stuff like this, I tend to prefer rusts iterator combinators, but I admit it’s a bit more advanced. So in this case you’d do

    fn get\_links(link\_nodes: scraper::html::Select\<'\_, '\_\>) -\> Vec\<String\> {  
 link\_nodes  
 .into\_iter() // convert select to iterator  
 .filter\_map(|node| node.value().attr("href")) // only select nodes with an href attribute, and select that value  
 .map(ToString::to\_string) // map that value to a string  
 .collect()  
}
    • gigapixel@mastodontti.fi
      0·
      19 days ago

      @dontblink The idea of the iterator is to assemble all of your computation lazily and only perform it at the final step. In this case you don’t actually perform any the actions until you call collect, which essentially creates a loop that goes through the original Select and performs the calculations and pushes the results to a Vec.

      • gigapixel@mastodontti.fi
        0·
        19 days ago

        @dontblink

        enum OperativeSystem {  
 Linux,  
 Windows,  
 Mac,  
 Unrecognised,  
}

fn find\_os(os: OperativeSystem) -\> String {  
 match os {  
 OperativeSystem::Linux =\> "This pc uses Linux".into(),  
 OperativeSystem::Windows =\> "This pc uses Windows, unlucky you!".into(),  
 OperativeSystem::Mac =\> "This pc uses Mac, I'm really sorry!".into(),  
 \_ =\> "unrecognised".into(),  
 }  
}

        If you want to return either a Boolean or a String you can introduce an enum

        • gigapixel@mastodontti.fi
          0·
          19 days ago

          @dontblink e.g.

          enum OsResponseType {  
 Message { message: String },  
 Bool(bool),  
}

fn find\_os(os: OperativeSystem) -\> OsResponseType {  
 match os {  
 OperativeSystem::Linux =\> OsResponseType::Message {  
 message: "This pc uses Linux".into(),  
 },  
 OperativeSystem::Windows =\> OsResponseType::Bool(false),  
 OperativeSystem::Mac =\> OsResponseType::Bool(true),  
 \_ =\> OsResponseType::Bool(false),  
 }  
}

          Note the logic here is nonsense

          • gigapixel@mastodontti.fi
            1·
            19 days ago

            @dontblink It feels like you should never OsResponseType::Bool(true) so you could probably encode that in the enum just as the same Unrecognised

            enum OsResponseType {  
 Message { message: String },  
 Unrecognised  
}
            • dontblink@feddit.itOP
              1·
              16 days ago

              Thank you so much, You are taking a lot of effort to answer my doubts and I really appreciate!

              So essentially match can return different types, but of course I have to specify it in the function signature, wheter using an enum or other ways, this makes sense! This was a missing piece in my puzzle, I didn’t consider the fact that the match return here was the function return type as well, and i had encoded -> String as return type.