BTreePage,

    pub fn changes<T>(&self, txn: &GenericTxn<T>) -> Result<Vec<(u64, ChangeHash)>, Error>

    /// Iterator over the changes in this document, in the order they were
    /// applied (i.e. oldest first).
    pub fn changes<'a, T>(
        &'a self,
        txn: &'a GenericTxn<T>,
    ) -> Changes<'a, T, impl BTreePage<L64, StoredHash>>

        T: sanakirja::LoadPage<Error = sanakirja::Error> + sanakirja::RootPage,

        T: sanakirja::LoadPage<Error = sanakirja::Error>,

        let mut changes = Vec::new();
        for x in btree::iter(&txn.txn, &self.changes, None)? {
            let (t, hash) = x?;
            changes.push((t.0, (*hash).into()));

        Changes {
            inner: Some(btree::iter(&txn.txn, &self.changes, None)),

    }

        Ok(changes)

    /// Iterator over the changes in this document, in reverse order (i.e.
    /// newest first).
    pub fn rev_changes<'a, T>(
        &'a self,
        txn: &'a GenericTxn<T>,
    ) -> RevChanges<'a, T, impl BTreePage<L64, StoredHash>>
    where
        T: sanakirja::LoadPage<Error = sanakirja::Error>,
    {
        RevChanges {
            inner: Some(btree::rev_iter(&txn.txn, &self.changes, None)),
        }

    /// Record a change to the document.

        let last = if let Some(max) = btree::rev_iter(&txn.txn, &self.changes, None)?.next() {

        self.extend_with(txn, Some(change))
    }
    /// Record a series of changes to the document.
    pub fn extend_with<T, I>(&mut self, txn: &mut MutTxn<T>, changes: I) -> Result<(), Error>
    where
        I: IntoIterator<Item = ChangeHash>,
    {
        let mut last = if let Some(max) = btree::rev_iter(&txn.txn, &self.changes, None)?.next() {

        btree::put(
            &mut txn.txn,
            &mut self.changes,
            &L64(last + 1),
            &change.into(),
        )?;

        for change in changes {
            last += 1;
            btree::put(&mut txn.txn, &mut self.changes, &L64(last), &change.into())?;
        }

}
/// Iterator over the changes in a [`Doc`] in the order they were applied.
///
/// Created by [`Doc::changes`].
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct Changes<'a, T, P>
where
    T: sanakirja::LoadPage,
    P: BTreePage<L64, StoredHash>,
{
    inner: Option<Result<btree::Iter<'a, T, L64, StoredHash, P>, sanakirja::Error>>,

impl<'a, T, P> Iterator for Changes<'a, T, P>
where
    T: sanakirja::LoadPage<Error = sanakirja::Error>,
    P: BTreePage<L64, StoredHash> + 'a,
{
    type Item = Result<(u64, ChangeHash), Error>;
    fn next(&mut self) -> Option<Self::Item> {
        let inner = self.inner.take()?;
        inner.map_or_else(
            |e| Some(Err(e.into())),
            |mut iter| {
                iter.next().map(|page| {
                    let x = page
                        .map_err(Into::into)
                        .map(|(t, hash)| (t.0, ChangeHash::from(*hash)));
                    self.inner = Some(Ok(iter));
                    x
                })
            },
        )
    }
}
/// Iterator over the changes in a [`Doc`] in reverse order (newest first).
///
/// Created by [`Doc::rev_iter`].
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct RevChanges<'a, T, P>
where
    T: sanakirja::LoadPage,
    P: BTreePage<L64, StoredHash>,
{
    inner: Option<Result<btree::RevIter<'a, T, L64, StoredHash, P>, sanakirja::Error>>,
}
impl<'a, T, P> Iterator for RevChanges<'a, T, P>
where
    T: sanakirja::LoadPage<Error = sanakirja::Error>,
    P: BTreePage<L64, StoredHash> + 'a,
{
    type Item = Result<(u64, ChangeHash), Error>;
    fn next(&mut self) -> Option<Self::Item> {
        let inner = self.inner.take()?;
        inner.map_or_else(
            |e| Some(Err(e.into())),
            |mut iter| {
                iter.next().map(|page| {
                    let x = page
                        .map_err(Into::into)
                        .map(|(t, hash)| (t.0, ChangeHash::from(*hash)));
                    self.inner = Some(Ok(iter));
                    x
                })
            },
        )
    }
}

struct StoredDoc {

pub struct StoredDoc {

struct StoredHash([u8; 32]);

pub struct StoredHash([u8; 32]);

use itertools::Itertools;

    for change in &changes {
        idx.put_change(&mut txn, *change)?;
    }

    idx.extend_with(&mut txn, changes.iter().copied())?;

        .changes(&txn)?
        .iter()
        .map(|(_, hash)| *hash)
        .collect::<Vec<_>>();

        .changes(&txn)
        .map_ok(|(_, hash)| hash)
        .collect::<Result<Vec<_>, _>>()?;

itertools.workspace = true

itertools = "0.11.0"

 "itertools",

 "itertools 0.10.5",

dependencies = [
 "either",
]
[[package]]
name = "itertools"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"

 "itertools 0.11.0",