Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Адаптери за итератори (част 1)

Краен срок
19.11.2024 18:00
Точки
2

Срокът за предаване на решения е отминал

use solution::*;
#[test]
fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s| s.len());
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
}

Напишете собствена имплементация на трансформиращ адаптер за итератори.

Първият вариант ще бъде generic. Структурата трябва да съдържа две полета:

  • iter: I - итератор
  • func: F - функция, която приема като аргумент стойности от тип елементите на итератора и връща стойности от друг тип

Очаква се да използвате директно подадените стойности за I и F - не са нужни Box, &dyn и други. Трябва да попълните generic параметрите, където е необходимо. Не всички места, на които трябва да сложите generic параметри, са указани. Можете да добавяте и допълнителни generic-и, освен I и F, където са ви необходими.

Трябва да имплементирате метод new и трейта Iterator за структурата.

pub struct MapIter<???> {
    iter: I,
    func: F,
}

impl MapIter {
    pub fn new(iter: I, func: F) -> MapIter {
        todo!()
    }
}

impl Iterator for MapIter {
    type Item = ???;

    fn next(&mut self) -> Option<Self::Item> {
        todo!()
    }
}

Тази задача е главно упражнение върху синтаксиса, затова получавате финалния тест наготово. Постарайте се кода ви да се компилира с него, за да изкарате точки (и не пропускайте pub-овете)

#[test]
fn test_map_iter() {
    let xs = &["x", "xx", "xxx"];
    let map_iter = MapIter::new(xs.iter(), |s| s.len());

    assert_eq!(
        map_iter.collect::<Vec<_>>(),
        vec![1, 2, 3],
    );
}

Решения

Никола
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Никола

pub struct MapIter<I, F, U>
where
I: Iterator,
F: FnMut(I::Item) -> U,
{
iter: I,
func: F,
}
impl<I, F, U> MapIter<I, F, U>
where
I: Iterator,
F: FnMut(I::Item) -> U,
{
pub fn new(iter: I, func: F) -> MapIter<I, F, U> {
MapIter { iter, func }
}
}
impl<I, F, U> Iterator for MapIter<I, F, U>
where
I: Iterator,
F: FnMut(I::Item) -> U,
{
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
match self.iter.next() {
Some(elem) => Some((self.func)(elem)),
None => None,
}
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1b77lxj/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.71s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Пресияна Борисова
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Пресияна Борисова

pub struct MapIter<I, F, R>
where
I: Iterator,
F: Fn(I::Item) -> R,
{
iter: I,
func: F,
}
impl<I, F, R> MapIter<I, F, R>
where
I: Iterator,
F: Fn(I::Item) -> R,
{
pub fn new(iter: I, func: F) -> MapIter<I, F, R> {
MapIter { iter, func }
}
}
impl<I, F, R> Iterator for MapIter<I, F, R>
where
I: Iterator,
F: Fn(I::Item) -> R,
{
type Item = R;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-3v1t2t/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.72s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Венцислав Монев
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Венцислав Монев

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, IteratorItem> MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> IteratorItem,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, IteratorItem> Iterator for MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> IteratorItem,
{
type Item = IteratorItem;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
#[test]
fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s| s.len());
assert_eq!(map_iter.collect::<Vec<_>>(), vec![1, 2, 3],);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-gzdi8f/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.16s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Александър Глушков
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Глушков

pub struct MapIter<I, F, K>
where
I: Iterator,
F: Fn(I::Item) -> K,
{
iter: I,
func: F,
}
impl<I, F, K> MapIter<I, F, K>
where
I: Iterator,
F: Fn(I::Item) -> K,
{
pub fn new(iter: I, func: F) -> MapIter<I, F, K> {
MapIter {iter, func}
}
}
impl<I, F, K> Iterator for MapIter<I, F, K>
where
I: Iterator,
F: Fn(I::Item) -> K,
{
type Item = K;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-m1e2v5/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.78s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Милица Тончева
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Милица Тончева

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, B> MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> B,
{
pub fn new(iter: I, func: F) -> MapIter<I, F>
{
MapIter {iter, func}
}
}
impl<B, I, F> Iterator for MapIter<I, F>
where
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B,
{
type Item = B;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-9aja9z/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.82s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Юлиян Палов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Юлиян Палов

pub struct MapIter<I, F>
{
iter: I,
func: F,
}
impl<I, F, U> MapIter<I, F> where I: Iterator, F: FnMut(I::Item) -> U,
{
pub fn new(iter: I, func: F) -> MapIter<I, F>
{
MapIter { iter, func }
}
}
impl<I, F, U> Iterator for MapIter<I, F> where I: Iterator, F: FnMut(I::Item) -> U,
{
type Item = U;
fn next(&mut self) -> Option<Self::Item>
{
self.iter.next().map(&mut self.func)
}
}
#[test]
fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s| s.len());
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-9278dq/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.80s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Ясен Ефремов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Ясен Ефремов

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<B, I: Iterator, F: FnMut(I::Item) -> B> MapIter<I, F> {
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<B, I: Iterator, F: FnMut(I::Item) -> B> Iterator for MapIter<I, F> {
type Item = B;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-19pff3u/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.71s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Александър Иванов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Иванов

pub struct MapIter<I, F>
where
I: Iterator,
{
iter: I,
func: F,
}
impl<ResultItemType, I: Iterator, F: Fn(I::Item) -> ResultItemType> MapIter<I, F> {
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<ResultItemType, I: Iterator, F: Fn(I::Item) -> ResultItemType> Iterator for MapIter<I, F> {
type Item = ResultItemType;
fn next(&mut self) -> Option<Self::Item> {
let temp: I::Item = self.iter.next()?;
Some((self.func)(temp))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1tqnhti/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.71s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Стоян Генчев
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Стоян Генчев

pub struct MapIter<I, F, A, B> where I: Iterator<Item=A>, F: FnMut(A) -> B {
iter: I,
func: F,
}
impl<I, F, A, B> MapIter<I, F, A, B> where I: Iterator<Item=A>, F: FnMut(A) -> B {
pub fn new(iter: I, func: F) -> MapIter<I, F, A, B> {
MapIter { iter, func }
}
}
impl<I, F, A, B> Iterator for MapIter<I, F, A, B> where I: Iterator<Item=A>, F: FnMut(A) -> B {
type Item = B;
fn next(&mut self) -> Option<Self::Item> {
match self.iter.next() {
None => None,
Some(x) => Some((self.func)(x))
}
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-10wspyn/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.73s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Станислав Иванов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Станислав Иванов

pub struct MapIter<I: Iterator, F: Fn(I::Item) -> R, R> {
iter: I,
func: F,
}
impl<I: Iterator, F: Fn(I::Item) -> R, R> MapIter<I, F, R> {
pub fn new(iter: I, func: F) -> Self {
Self { iter, func }
}
}
impl<I: Iterator, F: Fn(I::Item) -> R, R> Iterator for MapIter<I, F, R> {
type Item = R;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|x| (self.func)(x))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1s0kp4e/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.72s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Ана Илиева
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Ана Илиева

pub struct MapIter<I, F>
{
iter: I,
func: F,
}
impl<I, F, B> MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> B
{
pub fn new(iter: I, func: F) -> MapIter<I, F>
{
MapIter { iter, func }
}
}
impl<I, F, B> Iterator for MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> B
{
type Item = B;
fn next(&mut self) -> Option<Self::Item>
{
self.iter.next().map(&mut self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-9pcgnf/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.84s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Станислав Стаматов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Станислав Стаматов

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, R> MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> R,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter {
iter: iter,
func: func,
}
}
}
impl<I, F, R> Iterator for MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> R,
{
type Item = R;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
}
#[test]
fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s| s.len());
assert_eq!(map_iter.collect::<Vec<_>>(), vec![1, 2, 3],);
}
fn main() {} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-era8az/solution)
warning: function `main` is never used
  --> src/lib.rs:39:4
   |
39 | fn main() {}
   |    ^^^^
   |
   = note: `#[warn(dead_code)]` on by default

warning: `solution` (lib) generated 1 warning
    Finished test [unoptimized + debuginfo] target(s) in 0.79s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Енислав Енчев
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Енислав Енчев

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I : Iterator, F : FnMut(I::Item) -> T, T> MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> T,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I : Iterator, F : FnMut(I::Item) -> T, T> Iterator for MapIter<I, F>
{
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
#[test]
fn main(){
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s| s.len());
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
let xs = &[5, 12, 3, -7];
let map_iter = MapIter::new(xs.iter(), |s| s * s);
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![25, 144, 9, 49],
);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-hd9ef8/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.71s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Виктор Веселинов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Виктор Веселинов

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, T, U> MapIter<I, F>
where
I: Iterator<Item = T>,
F: FnMut(T) -> U,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, T, U> Iterator for MapIter<I, F>
where
I: Iterator<Item = T>,
F: FnMut(T) -> U,
{
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
// #[test]
// fn test_map_iter() {
// let xs = &["x", "xx", "xxx"];
// let map_iter = MapIter::new(xs.iter(), |s| s.len());
//
// assert_eq!(
// map_iter.collect::<Vec<_>>(),
// vec![1, 2, 3],
// );
// }
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1krt116/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.75s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Дария Лазарова
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Дария Лазарова

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, A, B> MapIter<I, F>
where
I: Iterator<Item = A>,
F: Fn(A) -> B,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, A, B> Iterator for MapIter<I, F>
where
I: Iterator<Item = A>,
F: Fn(A) -> B,
{
type Item = B;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-d8b3u7/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.70s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Стилиян Иванов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Стилиян Иванов

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, T> MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> T,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, T> Iterator for MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> T,
{
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-4jp22x/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.68s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Михаил Цанков
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Михаил Цанков

pub struct MapIter<I: Iterator, F: Fn(I::Item) -> R, R> {
iter: I,
func: F,
}
impl<I: Iterator, F: Fn(I::Item) -> R, R> MapIter<I, F, R> {
pub fn new(iter: I, func: F) -> MapIter<I, F, R> {
MapIter { iter, func }
}
}
impl<I: Iterator, F: Fn(I::Item) -> R, R> Iterator for MapIter<I, F, R> {
type Item = R;
fn next(&mut self) -> Option<Self::Item> {
match self.iter.next() {
Some(v) => Some((self.func)(v)),
None => None,
}
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-hv4kcj/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.70s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Божидар Виденов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Божидар Виденов

pub struct MapIter<I: Iterator, F> {
iter: I,
func: F,
}
impl<I: Iterator, U, F: Fn(I::Item) -> U> MapIter<I, F> {
pub fn new(iter: I, func: F) -> MapIter<I, F> {
Self { iter, func }
}
}
impl<I: Iterator, U, F: Fn(I::Item) -> U> Iterator for MapIter<I, F> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
let val = self.iter.next();
return match val {
None => None,
Some(res) => Some((self.func)(res)),
};
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1y540t7/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.68s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Калоян Рибаров
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Калоян Рибаров

pub struct MapIter<I: Iterator, F: FnMut(I::Item) -> O, O> {
iter: I,
func: F,
}
impl<I: Iterator, F: FnMut(I::Item) -> O, O> MapIter<I, F, O> {
pub fn new(iter: I, func: F) -> MapIter<I, F, O> {
MapIter { iter, func }
}
}
impl<I: Iterator, F: FnMut(I::Item) -> O, O> Iterator for MapIter<I, F, O> {
type Item = O;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-atbq3h/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.70s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Петър Велков
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Петър Велков

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl <I, F, R> MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> R,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, R> Iterator for MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> R,
{
type Item = R;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|x| (self.func)(x))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-u4c6ve/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.99s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Василен Петков
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Василен Петков

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, T> MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> T,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, T> Iterator for MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> T,
{
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-xmg4l/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.99s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Владимир Стоянов
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Владимир Стоянов

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, Ret> MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> Ret,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, Ret> Iterator for MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> Ret,
{
type Item = Ret;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|x| (self.func)(x))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-26qxq9/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.71s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Клементина Картевска
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Клементина Картевска

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F, T> MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> T,
{
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I, F, T> Iterator for MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> T,
{
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-143pzj4/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.75s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Габриела Димитрова
  • Некоректно
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Габриела Димитрова

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F> MapIter<I, F> {
pub fn new(iter: I, func: F) -> Self {
MapIter { iter, func }
}
}
impl<I, F> Iterator for MapIter<I, F>
where
I: Iterator,
F: Fn(I::Item) -> usize,
{
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
}
#[test]
pub fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s: &&str| s.len());
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-5bfi1/solution)
error[E0282]: type annotations needed
 --> tests/solution_test.rs:7:45
  |
7 |     let map_iter = MapIter::new(xs.iter(), |s| s.len());
  |                                             ^  - type must be known at this point
  |
help: consider giving this closure parameter an explicit type
  |
7 |     let map_iter = MapIter::new(xs.iter(), |s: /* Type */| s.len());
  |                                              ++++++++++++

For more information about this error, try `rustc --explain E0282`.
error: could not compile `solution` due to previous error
Ивона Стоянова
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Ивона Стоянова

pub struct MapIter<I, F> {
iter: I,
func: F,
}
// generic Iterator, Function and return type T used throughout the impl
impl<I, F, T> MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> T,
{
pub fn new(iter: I, func: F) -> MapIter<I,F> {
Self { iter, func }
}
}
// impl trait Iterator with its required Item field and
// next method. Item is returned by the iterator, if Some()
impl<I, F, T> Iterator for MapIter<I, F>
where
I: Iterator,
F: FnMut(I::Item) -> T,
{
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1mhu2nc/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.71s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Ангел Пенчев
  • Коректно
  • 1 успешни тест(а)
  • 0 неуспешни тест(а)
Ангел Пенчев

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I: Iterator, F: Fn(I::Item) -> B, B> MapIter<I, F> {
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter { iter, func }
}
}
impl<I: Iterator, F: Fn(I::Item) -> B, B> Iterator for MapIter<I, F> {
type Item = B;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|x| (self.func)(x))
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s| s.len());
assert_eq!(map_iter.collect::<Vec<_>>(), vec![1, 2, 3]);
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1gdqg8a/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.70s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Ивайло Генчев
  • Некоректно
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Ивайло Генчев

pub struct MapIter<I, F> {
iter: I,
func: F,
}
impl<I, F> MapIter<I, F> {
pub fn new(iter: I, func: F) -> MapIter<I, F> {
MapIter {
iter, func
}
}
}
impl<RT, I: Iterator, F> Iterator for MapIter<I, F> where F: Fn(I::Item) -> RT {
type Item = RT;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|a| (self.func)(a))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = MapIter::new(xs.iter(), |s: &&str| s.len());
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-eg22ao/solution)
error[E0282]: type annotations needed
 --> tests/solution_test.rs:7:45
  |
7 |     let map_iter = MapIter::new(xs.iter(), |s| s.len());
  |                                             ^  - type must be known at this point
  |
help: consider giving this closure parameter an explicit type
  |
7 |     let map_iter = MapIter::new(xs.iter(), |s: /* Type */| s.len());
  |                                              ++++++++++++

For more information about this error, try `rustc --explain E0282`.
error: could not compile `solution` due to previous error