Решението ти не се компилира с пълния тест. Не можеш да променяш сигнатурите на функциите. FibIter::new() не приема аргумент. Идеята на структурата е да е безкраен генератор - помисли как би могъл да я имплементираш без size параметър.

Алтернативно, ако не можеш да се сетиш, можеш да направиш това:

impl FibIter {
    pub fn new() -> FibIter { todo!() }
    pub fn with_size(size: u32) -> FibIter { /* текущуя код */ }

Т.е. да оставиш new функцията неимплементирана и да си направиш друг конструктор, който да използваш в имплементацията на fib_* функциите. Ще загубиш няколко точки от тестовете, които проверяват FibIter директно, но ще получиш точки за fib_* функциите. (todo!() макрото е еквиваленто на panic!("not yet implemented")).

С две думи не е нужно да имплементираш всички функции от условието, можеш да оставиш някои с todo!(). Но трябва да съществуват със същите сигнатури, иначе тестовете не се компилират и ще получиш 0 точки.

Видях току-що коментара, за което се извинявам за малко бавния ми отговор, но малко повечко задачки ми се насъбраха и малко лични не предсказуеми произшествия станах, ето репението без size

pub struct FibIter { pub current: u32, pub prev: u32, }

impl FibIter { pub fn new() -> FibIter { FibIter { current: 0, prev: 0, } }

pub fn next(&mut self) -> u32 {
    if self.current == 0 {
        self.current = 1;
        self.prev = 0;
    } else {
        let temp = self.current;
        self.current = self.current + self.prev;
        self.prev = temp;
    }

    self.current
}

pub fn rev(self) -> RevFibIter {
    RevFibIter {
        size: self.current,
        nums: vec![self.current],
        current: 0,
    }
}

}

pub struct RevFibIter { size: u32, nums: Vec, current: u32, }

impl RevFibIter { pub fn next(&mut self) -> Option { if self.current < self.size { let result = self.nums[self.current as usize]; self.current += 1; Some(result) } else { None } } }

pub fn fib_split(text: &str) -> Vec { let mut result = Vec::new(); let mut iter = FibIter::new(); let mut fib_num = iter.next(); let size = text.len(); let mut i = 0; let mut j: usize = fib_num as usize;

while i < size {

    if j >= size {
        result.push(text[i..].to_string());
        break;
    }
    let mut temp = String::new();
    temp.push_str(&text[i..j]);
    result.push(temp);
    i = j;
    fib_num = iter.next();
    j = j + fib_num as usize;
}

result

}

pub fn fib_split_n(text: &str, n: u32) -> (Vec, &str) { let mut parts = Vec::new(); let mut remaining_text = text; let mut fib_iter = FibIter::new(); let mut count = 0;

while count < n {
    let fib_len = fib_iter.next();
    if remaining_text.len() <= fib_len as usize {
        break;
    }

    let part = &remaining_text[..fib_len as usize];
    parts.push(part.to_string());

    remaining_text = &remaining_text[fib_len as usize..];
    count += 1;
}

(parts, remaining_text)

}

pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec, &str) { let mut parts = Vec::new(); let mut remaining_text = text; let mut fib_iter = FibIter::new(); let mut count = 0;

while count < n {
    let fib_len = fib_iter.next();
    if remaining_text.len() <= fib_len as usize {
        break;
    }

    let part = &remaining_text[..fib_len as usize];
    parts.push(part.to_string());

    remaining_text = &remaining_text[fib_len as usize..];
    count += 1;
}

(parts, remaining_text)

}

fn main() { }

[test]

pub fn test_basic() { let mut fib_iter = FibIter::new(); fib_iter.next();

let mut rev_fib_iter: RevFibIter = fib_iter.rev();
rev_fib_iter.next();

let _words: Vec<String> = fib_split("Fibonacci words!");

let (_words, _rest): (Vec<String>, &str) =
    fib_split_n("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 1);

let (_words, _rest): (Vec<String>, &str) =
    fib_split_n_symmetric("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 1);

}