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

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

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

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

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

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

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

Вторият вариант ще бъде полиморфичен. Напишете структура DynMapIter, която има два generic параметъра - T и U. Структурата се създава от:

  • итератор, който връща елементи от тип T
  • и функция T -> U, която приема аргумент от тип T и връща резултат от тип U.

В този случай не знаем нищо за конкретния тип на първоначалния итератор или на транформиращата функция - и двете се подават като boxed trait objects на функцията new. Отново трябва да попълните липсващия синтаксис. Нямате право да добавяте други типови generic параметри към DynMapIter.

Имплементирайте метода new и трейта Iterator за структурата.

pub struct DynMapIter<T, U> {
    /* ... */
}

impl<???> DynMapIter<???> {
    pub fn new(iter: Box<dyn Iterator???>, func: Box<dyn Fn???>) -> DynMapIter<T, U> {
        todo!()
    }
}

impl<???> Iterator for DynMapIter<???> {
    type Item = U;

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

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

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

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

Решения

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

pub struct DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn FnMut(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn FnMut(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, 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-1btqrfu/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.67s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U>
where
T: 'static,
U: 'static,
{
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-k3hw5p/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.74s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
#[test]
fn test_dyn_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = DynMapIter::new(Box::new(xs.iter()), Box::new(|s| s.len()));
assert_eq!(map_iter.collect::<Vec<_>>(), vec![1, 2, 3],);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-p5y6t9/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.23s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter {iter, func}
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-u0rxw9/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.10s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter:Box<dyn Iterator<Item = T>>,
func: Box<dyn FnMut(T)->U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn FnMut(T)->U>) -> DynMapIter<T, U> {
DynMapIter{iter, func}
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1rygkzh/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.12s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U>
{
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U>
{
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U>
{
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U>
{
type Item = U;
fn next(&mut self) -> Option<Self::Item>
{
self.iter.next().map(|value| (self.func)(value))
}
}
#[test]
fn test_dyn_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = DynMapIter::new(
Box::new(xs.iter()),
Box::new(|s| s.len()),
);
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-s8t7yy/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.76s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1hkxtfc/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.76s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
let temp = self.iter.next()?;
Some((self.func)(temp))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-mgxjrn/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_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter {iter, func}
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
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-1jr6q15/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.05s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> Self {
Self { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|x| (self.func)(x))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1hvj8g2/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_dyn_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 DynMapIter<T, U>
{
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn FnMut(T) -> U>
}
impl<T, U> DynMapIter<T, U>
{
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn FnMut(T) -> U>) -> DynMapIter<T, U>
{
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U>
{
type Item = U;
fn next(&mut self) -> Option<Self::Item>
{
self.iter.next().map(|item| (self.func)(item))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-qr7wfb/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.85s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_map_iter ... ok

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

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

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

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>
) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-cyzbcg/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.81s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn FnMut(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn FnMut(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
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 = DynMapIter::new(
Box::new(xs.iter()),
Box::new(|s| s.len()),
);
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
let xs = &[5, 12, 3, -7];
let map_iter = DynMapIter::new(
Box::new(xs.iter()),
Box::new(|s| s * s),
);
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![25, 144, 9, 49],
);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1r2ney5/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.74s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|v| (self.func)(v))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-9x9ow/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.74s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
Self { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
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-ulipyr/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_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-yd4ol3/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_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1fek06v/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_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(&mut self.func)
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1i27lar/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.77s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-o40j72/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_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-aaxqan/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.69s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1r2o0k5/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.76s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn FnMut(T) -> U>,
}
impl<T,U> DynMapIter<T,U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn FnMut(T)->U>) -> DynMapIter<T, U> {
Self{iter,func}
}
}
impl<T,U> Iterator for DynMapIter<T,U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-riqaf3/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.69s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item=T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T: 'static, U: 'static> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item=T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter {
iter: Box::new(iter),
func: Box::new(func),
}
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|item| (self.func)(item))
}
}
#[test]
fn test_dyn_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = DynMapIter::new(
Box::new(xs.iter()),
Box::new(|s| s.len()),
);
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-11a5k7d/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.74s
     Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)

running 1 test
test solution_test::test_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item = T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item = T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter { iter, func }
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|x| (self.func)(x))
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_dyn_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = DynMapIter::new(Box::new(xs.iter()), Box::new(|s| s.len()));
assert_eq!(map_iter.collect::<Vec<_>>(), vec![1, 2, 3]);
}
}
Compiling solution v0.1.0 (/tmp/d20241119-1739405-141za91/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_dyn_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 DynMapIter<T, U> {
iter: Box<dyn Iterator<Item=T>>,
func: Box<dyn Fn(T) -> U>,
}
impl<T, U> DynMapIter<T, U> {
pub fn new(iter: Box<dyn Iterator<Item=T>>, func: Box<dyn Fn(T) -> U>) -> DynMapIter<T, U> {
DynMapIter {
iter, func
}
}
}
impl<T, U> Iterator for DynMapIter<T, U> {
type Item = U;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|a| (self.func)(a))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_dyn_map_iter() {
let xs = &["x", "xx", "xxx"];
let map_iter = DynMapIter::new(
Box::new(xs.iter()),
Box::new(|s| s.len()),
);
assert_eq!(
map_iter.collect::<Vec<_>>(),
vec![1, 2, 3],
);
}
} 
Compiling solution v0.1.0 (/tmp/d20241119-1739405-1w4p5kt/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_dyn_map_iter ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s