pub fn closure(&self) -> Vec<RowBuf> {
        let mut closure = vec![self.to_owned()];
        loop {
            let last_row = closure.last().unwrap();
            if last_row.is_rounds() {
                return closure;
            }
            // This unsafety is OK, because `self` is a valid Row and `row` and `self` will always
            // have the same Stage
            let next_row = unsafe { last_row.mul_unchecked(self) };
            closure.push(next_row);
        }
    }
/// Generate all the `Row`s formed by repeatedly permuting a given `Row`.  The first item
/// returned will always be the input `Row`, and the last will always be `rounds`.
///
/// # Example
/// ```
/// use bellframe::{RowBuf};
///
/// // The closure of "18234567" are all the fixed-treble cyclic part heads.
/// assert_eq!(
///     RowBuf::parse("18234567")?.closure(),
///     vec![
///         RowBuf::parse("18234567")?,
///         RowBuf::parse("17823456")?,
///         RowBuf::parse("16782345")?,
///         RowBuf::parse("15678234")?,
///         RowBuf::parse("14567823")?,
///         RowBuf::parse("13456782")?,
///         RowBuf::parse("12345678")?,
///     ]
/// );
/// # Ok::<(), bellframe::InvalidRowError>(())
/// ```
Generate all the `Row`s formed by repeatedly permuting a given `Row`.  The first item
returned will always be the input `Row`, and the last will always be `rounds`.
Generate all the ` Row ` s formed by repeatedly permuting a given ` Row ` . The first item returned will always be the input ` Row ` and the last will always be ` rounds ` .
pub fn closure(&self) -> Vec<RowBuf> {
        let mut closure = vec![self.to_owned()];
        loop {
            let last_row = closure.last().unwrap();
            if last_row.is_rounds() {
                return closure;
            }
            // This unsafety is OK, because `self` is a valid Row and `row` and `self` will always
            // have the same Stage
            let next_row = unsafe { last_row.mul_unchecked(self) };
            closure.push(next_row);
        }
    }
pub fn closure ( & self ) -> Vec < RowBuf > { let mut closure = vec ! [ self to_owned ( ) ] ; loop { let last_row = closure . last ( ) . unwrap ( ) ; if last_row . is_rounds ( ) { return closure ; } // This unsafety is OK, because `self` is a valid Row and `row` and `self` will always // have the same Stage let next_row = unsafe { last_row . mul_unchecked ( self ) } ; closure . push ( next_row ) ; } }
Generate all the `Row`s formed by repeatedly permuting a given `Row`.
Generate all the ` Row ` s formed by repeatedly permuting a given ` Row ` .
&self
&self
example
```
use bellframe::{RowBuf}.

The closure of "18234567" are all the fixed-treble cyclic part heads.
` ` ` use bellframe :: { RowBuf } . The closure of " 18234567 " are all the fixed - treble cyclic part heads .
ok::<(), bellframe::invalidrowerror>(())
None