ImaraHistogram,

    let mut dd = diffs::Replace::new(D {

    let result = D {

    });
    match algorithm {
        Algorithm::Patience => diffs::patience::diff(
            &mut dd,
            lines_a,
            0,
            lines_a.len(),
            lines_b,
            0,
            lines_b.len(),
        )
        .unwrap_or(()),
        Algorithm::Myers => diffs::myers::diff(
            &mut dd,
            lines_a,
            0,
            lines_a.len(),
            lines_b,
            0,
            lines_b.len(),
        )
        .unwrap_or(()),
    }
    dd.into_inner()

    };
    return match algorithm {
        Algorithm::Patience => {
            let mut dd = diffs::Replace::new(result);
            diffs::patience::diff(
                &mut dd,
                lines_a,
                0,
                lines_a.len(),
                lines_b,
                0,
                lines_b.len(),
            )
            .unwrap_or(());
            dd.into_inner()
        }
        Algorithm::Myers => {
            let mut dd = diffs::Replace::new(result);
            diffs::myers::diff(
                &mut dd,
                lines_a,
                0,
                lines_a.len(),
                lines_b,
                0,
                lines_b.len(),
            )
            .unwrap_or(());
            dd.into_inner()
        }
        Algorithm::ImaraHistogram => {
            let source = imara_diff::intern::InternedInput::new(&Lines(lines_a), &Lines(lines_b));
            imara_diff::diff(imara_diff::Algorithm::Histogram, &source, result)
        }
    };

/// struct used for imara interning see InternedInput
struct Lines<'a>(&'a [Line<'a>]);
impl<'a> imara_diff::intern::TokenSource for &Lines<'a> {
    type Token = &'a Line<'a>;
    type Tokenizer = core::slice::Iter<'a, Line<'a>>;
    fn tokenize(&self) -> Self::Tokenizer {
        self.0.iter()
    }
    fn estimate_tokens(&self) -> u32 {
        self.0.len() as u32
    }
}
impl imara_diff::Sink for D {
    type Out = D;
    fn process_change(&mut self, before: std::ops::Range<u32>, after: std::ops::Range<u32>) {
        debug!(
            "Process change: old:{:?}-{:?} new:{:?}-{:?}",
            before.start, before.end, after.start, after.end
        );
        self.r.push(Replacement {
            old: before.start as usize,
            old_len: before.len(),
            new: after.start as usize,
            new_len: after.len(),
            is_cyclic: false,
        });
    }
    fn finish(self) -> Self::Out {
        self
    }
}