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
    link
    fedilink
    arrow-up
    0
    ·
    edit-2
    5 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
      link
      fedilink
      arrow-up
      0
      ·
      5 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
        link
        fedilink
        arrow-up
        1
        ·
        5 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
          link
          fedilink
          arrow-up
          1
          ·
          2 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.