Returning impl Trait

Rust's impl Trait syntax allows for concise and flexible code, especially when returning iterators or other complex types. By using impl Trait, you can abstract away concrete types while ensuring optimal performance through Rust's zero-cost abstractions.

In this challenge, you will implement a function that filters strings from a slice, returning only those that start with a given keyword. The function will return an iterator over the filtered results. This approach demonstrates how to combine Rust's iterator combinators with the impl Trait syntax.

Your Task

Write a function named filter_starts_with that:

Accepts two arguments:
- A slice of String
- A &str keyword
Returns an iterator that filters and yields only the strings starting with the given keyword.

Hints

Click here to reveal hints

Use .iter() to iterate over references to the strings in the slice.
The filter method takes a closure to apply a filtering condition.
Use the starts_with method to check if a string starts with a keyword.
Use move in the closure to capture the keyword.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Maintain

duonghb53

an hour ago

4.34ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, filter: &'a str) -> impl Iterator<Item = &'a String>
 {
    input.iter().filter(move |x| x.starts_with(filter))
 }
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Nicolai

Posmac

7 days ago

3.80ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.into_iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

agamaontherock

10 days ago

3.68ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, 
                              keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Health-Care-Movie

11 days ago

4.09ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |x| x.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Splatrac

splatrac

12 days ago

3.55ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |e| { e.starts_with(keyword) })
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Trịnh Chấn Duy

Duyyy123

13 days ago

5.69ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |x| x.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Liyqq

16 days ago

4.43ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a Vec<String>, prefix: &'a str) -> impl Iterator<Item=&'a String> {
    strings.iter().filter(move |&s| s.starts_with(prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Nathan GAUD

Natchica

a month ago

4.61ms

87.96kb

pub fn filter_starts_with<'a>(slice: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Nguyen Vo Hoang Son

sonmessia

a month ago

3.98ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strs: &'a[String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    strs.iter().filter(move |x| x.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Paolo Cancedda

Pac72

a month ago

3.77ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strs: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    strs.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

roboquaternion

a month ago

3.40ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(list: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    list
        .iter()
        .filter(move |x| x.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

shibu-t

a month ago

4.49ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strs: &'a[String], key: &'a str) -> impl Iterator<Item = &'a String> {
    strs.iter().filter(move|item| item.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

mishbah

a month ago

4.11ms

87.96kb

pub fn filter_starts_with<'a>(
    v: &'a Vec<String>,
    key: &'a str,
) -> impl Iterator<Item = &'a String> {
    v.iter().filter(move |x| x.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

mishbah

a month ago

6.83ms

87.96kb

pub fn filter_starts_with<'a>(
    v: &'a Vec<String>,
    key: &'a str,
) -> impl Iterator<Item = &'a String> {
    v.iter().filter(move |x| x.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

ON-MX

a month ago

3.55ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(v: &'a [String], k: &'a str)  -> impl Iterator<Item = &'a String>{
    v.iter().filter(move |x| x.starts_with(k))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Jason

Jason-fy-wang

a month ago

3.71ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strs: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    strs.iter().filter(move|item| item.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Jason

Jason-fy-wang

a month ago

5.79ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strs: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    strs.iter().filter(move|item| item.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Jakub Wiśniewski

wisniewskij

a month ago

3.52ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(text: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    text.iter().filter(move |e| e.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

asdfman

a month ago

3.58ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(val: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    val.iter().filter(move |x| x.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

vijayabhaskar badireddi

ptcte

a month ago

3.69ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    vec: &'a Vec<String>,
    prefix: &'a str,
) -> impl Iterator<Item = &'a String> + 'a {
    vec.iter().filter(move |i| i.starts_with(prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

chuyuanlinzi

a month ago

3.55ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(vec : &'a Vec<String>, prefix: &'a str) -> impl Iterator<Item = &'a String> + 'a{
    vec.iter().filter(move |i| i.starts_with(prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Assylbek Razakhbergenov

asylbek27

a month ago

4.12ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(words: &'a[String], key: &'a str) -> impl Iterator<Item=&'a String> {
    words.iter().filter(move |word| word.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

VerweyFr

a month ago

3.51ms

87.96kb

pub fn filter_starts_with<'a>(input: &'a[String], key: &'a str) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |e| e.starts_with(&key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Dhananjay Pandit

djpandit007

a month ago

3.64ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a [String], start: &'a str) -> impl Iterator<Item = &'a String> {
    slice
        .iter()
        .filter(move |word| word.starts_with(start))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

rolan

rolan36

a month ago

3.63ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input:&'a [String],keywords:&'a str) -> impl Iterator<Item = &'a String>{
    input.iter().filter(move |x| x.starts_with(keywords))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Namondz

a month ago

5.29ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input:&'a [String],keywords:&'a str) -> impl Iterator<Item = &'a String>{
    input.iter().filter(move |x| x.starts_with(keywords))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Kondorok

a month ago

3.67ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    strings: &'a [String],
    prefix: &'a str,
) -> impl Iterator<Item = &'a String> {
    strings.iter().filter(move |x| x.starts_with(prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Jason

chenjie1219

2 months ago

4.05ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |value| value.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

curiousmindflow

2 months ago

4.81ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a, 'b: 'a>(slice: &'a Vec<String>, keyword: &'b str) -> impl Iterator<Item = &'a String> + 'a {
    slice.into_iter().filter(move |element| element.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Yixian Du

duyixian1234

2 months ago

3.42ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |&e| e.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Aurimas Kuniutis

auriku

2 months ago

3.63ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |&e| e.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Aurimas Kuniutis

auriku

2 months ago

6.32ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |e| e.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

lugtester

2 months ago

9.85ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(sl: &'a Vec<String>, k: &'a str) -> impl Iterator<Item = &'a String> {
    sl.iter()
      .filter(move |x| x.starts_with(k))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

gsspdev

2 months ago

15.70ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(v: &'a [String], k: &'a str)  -> impl Iterator<Item = &'a String>{
    v.iter().filter(move |x| x.starts_with(k))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

rrdpad

2 months ago

4.53ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(v: &'a [String], x: &'a str) -> impl Iterator<Item = &'a String>{
    v.iter().filter(move |w| w.starts_with(x))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

JeromeCheze

2 months ago

3.50ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(items: &'a [String], k: &'a str) -> impl Iterator<Item = &'a String> {
    items.iter().filter(move |x| x.starts_with(k))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Anna Komarova

Vlasanya

2 months ago

3.71ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> + 'a {
    slice.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Benjamin Falk

lumio

2 months ago

8.19ms

87.96kb

pub fn filter_starts_with<'a>(
    slice: &'a [String],
    key: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |x| x.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Cristian Prieto

cprieto

2 months ago

4.47ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(items: &'a [String], key: &'a str) -> impl Iterator<Item=&'a String> {
    items.iter().filter(move |x| x.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Suresh Kumar

toddlers

2 months ago

5.72ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a [String], keyword: &'a str) -> impl Iterator<Item=&'a String>  {
    strings.iter()
    .filter(move |temp| temp.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}
// // Finish the function
// pub fn filter_starts_with<'a>(
//     slice: &'a [String],
//     key: &'a str,
// ) -> impl Iterator<Item = &'a String> {
//     slice.iter().filter(move |s| s.starts_with(key))
// }
// // Example usage
// pub fn main() {
//     let input = vec![
//         String::from("apple"),
//         String::from("apricot"),
//         String::from("banana"),
//         String::from("cherry"),
//     ];
//     let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
//     println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
// }

Paulo Lins

pblins

2 months ago

3.94ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    slice: &'a [String],
    key: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |s| s.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Artem

tich31337

2 months ago

4.07ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(sl: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    sl.iter().filter(move |val| val.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Icarus

IcarusxB

2 months ago

8.92ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a> (slice: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Matthew Li

circles-png

2 months ago

6.93ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    strings.iter().filter(move |string| string.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Tboot

tboot-0510

2 months ago

9.13ms

87.96kb

// to declare that `impl Iterator` captures `'_`, you can introduce a named lifetime parameter `'a`
pub fn filter_starts_with<'a>(words: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item=&'a String> {
    words.iter().filter(move |w| w.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Hung Dinh

nhdinh

2 months ago

3.53ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(haystack: &'a Vec<String>, needle: &'a str) -> impl Iterator<Item=&'a String> {
    haystack.iter().filter(move |x| x.starts_with(needle))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Hung Dinh

nhdinh

2 months ago

3.77ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(haystack: &'a Vec<String>, needle: &'a str) -> impl Iterator<Item=&'a String> {
    haystack.iter().filter(move |x| x.starts_with(needle))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

AnKarl

Zythophilus

2 months ago

3.31ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(haystack: &'a Vec<String>, needle: &'a str) -> impl Iterator<Item=&'a String> {
    haystack.iter()
    .filter(move |x| x.starts_with(needle))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Zeiion

2 months ago

3.46ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(list: &'a Vec<String>, start: &'a str) -> impl Iterator<Item=&'a String> {
    list.iter().filter(move |s| s.starts_with(start))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

tzmijewski

3 months ago

3.81ms

87.96kb

// Finish the function
//pub fn filter_starts_with (list: &Vec<String>, keyword: &str) -> impl Iterator<Item=&String> + '_ {
    pub fn filter_starts_with<'a> (list: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item=&'a String> + 'a {
   // let mut vec: Vec::<_> = vec![];
    //let filteredList: Vec<_> = list.iter()
    list.iter()
        .filter(move  |item | item.starts_with(keyword))//.collect::<Vec<String>>();
        
        //.collect::<Vec<_>>()
        //        .into_iter();
    //filteredList.iter()
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}