pub trait IntoOkExt: Iterator + Sized {
// Provided method
fn into_ok(self) -> impl Iterator<Item = Result<Self::Item, ()>> { ... }
}Provided Methods§
Sourcefn into_ok(self) -> impl Iterator<Item = Result<Self::Item, ()>>
fn into_ok(self) -> impl Iterator<Item = Result<Self::Item, ()>>
Examples found in repository?
examples/note_chopper.rs (line 41)
29fn main() {
30 let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();
31
32 let chop_size = file.ppq() as u64 / 16;
33
34 let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
35
36 for (i, track) in file.iter_all_tracks().enumerate() {
37 println!("Chopping track {} of {}", i, file.track_count());
38
39 let cached = track.collect_vec_result().unwrap();
40
41 let non_note_events = cached.iter().cloned().into_ok().filter_non_note_events();
42
43 let notes = cached
44 .iter()
45 .cloned()
46 .into_ok()
47 .events_to_notes()
48 .unwrap_items();
49 let chopped = notes.map(|n| chop_note(n, chop_size).into_ok());
50 let flattened = chopped.merge_all().notes_to_events();
51
52 // let notes = pipe!(cached.iter().cloned()|>wrap_ok()|>events_to_notes()|>unwrap_items());
53 // let flattened = pipe!(notes|>wrap_ok()|>notes_to_events());
54
55 let merged = merge_events(flattened, non_note_events);
56
57 writer
58 .try_open_next_track()
59 .unwrap()
60 .write_events_iter(merged.unwrap_items())
61 .unwrap();
62 }
63}More examples
examples/benchmark.rs (line 77)
32fn main() {
33 let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
34 let repeats = 4;
35
36 println!("Opening midi...");
37 let file = MIDIFile::open(filename, None).unwrap();
38
39 println!("Tracks: {}", file.track_count());
40
41 let loaded_tracks = file
42 .iter_all_tracks()
43 .map(|t| t.collect_vec_result().unwrap())
44 .collect::<Vec<_>>();
45
46 let mut nc: u64 = 0;
47 for track in loaded_tracks.iter() {
48 for e in track {
49 if let Event::NoteOn(_) = **e {
50 nc += 1
51 }
52 }
53 }
54 println!("Note count: {nc}");
55
56 do_run("Parse all tracks individually", repeats, || {
57 for track in file.iter_all_tracks() {
58 for _ in track {}
59 }
60 });
61 do_run("Merge all tracks together while parsing", repeats, || {
62 let merged = file.iter_all_tracks().merge_all();
63 for _ in merged {}
64 });
65 do_run("Clone all events", repeats, || {
66 let iters = loaded_tracks.iter().map(|t| t.iter().cloned());
67 for track in iters {
68 for _ in track {}
69 }
70 });
71 do_run(
72 "Clone all events, then wrap and unwrap them in Result",
73 repeats,
74 || {
75 let iters = loaded_tracks
76 .iter()
77 .map(|t| t.iter().cloned().into_ok().unwrap_items());
78 for track in iters {
79 for _ in track {}
80 }
81 },
82 );
83 do_run("Merge all tracks together while cloning", repeats, || {
84 let iters = loaded_tracks
85 .iter()
86 .map(|t| t.iter().cloned().into_ok())
87 .collect::<Vec<_>>();
88 let merged = iters.into_iter().merge_all();
89 for _ in merged {}
90 });
91 do_run("Write each track while cloning", repeats, || {
92 let output = Cursor::new(Vec::<u8>::new());
93 let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
94
95 let iters = loaded_tracks.iter().map(|t| t.iter().cloned());
96 for track in iters {
97 let mut track_writer = writer.try_open_next_track().unwrap();
98 for e in track {
99 track_writer.write_event(e).unwrap();
100 }
101 }
102 });
103 do_run("Merge each track while cloning then write", repeats, || {
104 let output = Cursor::new(Vec::<u8>::new());
105 let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
106
107 let iters = loaded_tracks
108 .iter()
109 .map(|t| t.iter().cloned().into_ok())
110 .collect::<Vec<_>>();
111 let merged = iters.into_iter().merge_all().unwrap_items();
112 let mut track_writer = writer.try_open_next_track().unwrap();
113 for e in merged {
114 track_writer.write_event(e).unwrap();
115 }
116 });
117}Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.