min_infmachine_lltk 0.1.0

//! Low level toolkit to generate MinInfMachines. It provides builders with label handling,
//! helpers that simplify writing strucutal code (for example routine calling, big data
//! writing) and integrated builder that simplify usage of noticed helpers.
//!
//! Path to generate MinInfMachine is using some builder, put all code and generate code
//! using `to_code` method. Further optional steps are optimization that provided by `table_opt`
//! module. Simple example:
//!
//! ```rust
//! use min_infmachine::*;
//! use min_infmachine_lltk::builder::*;
//! use min_infmachine_lltk::handler_builder::*;
//! use min_infmachine_lltk::table_opt::*;
//! use min_infmachine_lltk::*;
//!
//! fn main() {
//!     let mut builder = mi_std_sv_hbuilder_new(None, None, 1);
//!     builder.i(MINF_TBRF);
//!     builder.i(MINF_STOP);
//!     let (code, labels) = builder.to_code();
//!     let table = to_table(code);
//!     let mut machine = MinInfMachine::<usize>::new_with_table(table).unwrap();
//!     let machine = machine.to_toml().unwrap();
//!     println!("{}", machine);
//! }
//! ```
//!
//! Package `min_infmachine_blabla_cpu` is simple any bit CPU written by using this toolkit.
//! It is good example to learn that toolkit.

use std::fmt::{self, Debug, Display};
use std::num::TryFromIntError;

use gate_calc_log_bits::*;

/// Machine function: memory address read and move memory address position forward.
pub const MACH_MEM_ADDRESS_READ_FORWARD: u8 = 0;
/// Machine function: memory read.
pub const MACH_MEM_READ: u8 = 1;
/// Machine function: memory read and write 0.
pub const MACH_MEM_READ_WRITE_0: u8 = 2;
/// Machine function: memory read and write 1.
pub const MACH_MEM_READ_WRITE_1: u8 = 3;
/// Machine function: move memory address position backward.
pub const MACH_MEM_ADDRESS_BACKWARD: u8 = 4;
/// Machine function: memory address read.
pub const MACH_MEM_ADDRESS_READ: u8 = 5;
/// Machine function: memory address read and write 0.
pub const MACH_MEM_ADDRESS_READ_WRITE_0: u8 = 6;
/// Machine function: memory address read and write 1.
pub const MACH_MEM_ADDRESS_READ_WRITE_1: u8 = 7;
/// Machine function: temp buffer read and move temp buffer position forward.
pub const MACH_TEMP_BUFFER_READ_FORWARD: u8 = 8;
/// Machine function: temp buffer read.
pub const MACH_TEMP_BUFFER_READ: u8 = 9;
/// Machine function: temp buffer read and write 0.
pub const MACH_TEMP_BUFFER_READ_WRITE_0: u8 = 10;
/// Machine function: temp buffer read and write 1.
pub const MACH_TEMP_BUFFER_READ_WRITE_1: u8 = 11;
/// Machine function: move temp buffer position backward.
pub const MACH_TEMP_BUFFER_BACKWARD: u8 = 12;
/// Machine function: Stop 3.
pub const MACH_STOP_3: u8 = 13;
/// Machine function: Stop 2.
pub const MACH_STOP_2: u8 = 14;
/// Machine function: Stop.
pub const MACH_STOP: u8 = 15;

/// Machine function: memory address read and move memory address position forward.
pub const MACH_MARF: u8 = MACH_MEM_ADDRESS_READ_FORWARD;
/// Machine function: memory read.
pub const MACH_MR: u8 = MACH_MEM_READ;
/// Machine function: memory read and write 0.
pub const MACH_MRW0: u8 = MACH_MEM_READ_WRITE_0;
/// Machine function: memory read and write 1.
pub const MACH_MRW1: u8 = MACH_MEM_READ_WRITE_1;
/// Machine function: move memory address position backward.
pub const MACH_MAB: u8 = MACH_MEM_ADDRESS_BACKWARD;
/// Machine function: memory address read.
pub const MACH_MAR: u8 = MACH_MEM_ADDRESS_READ;
/// Machine function: memory address read and write 0.
pub const MACH_MARW0: u8 = MACH_MEM_ADDRESS_READ_WRITE_0;
/// Machine function: memory address read and write 1.
pub const MACH_MARW1: u8 = MACH_MEM_ADDRESS_READ_WRITE_1;
/// Machine function: temp buffer read and move temp buffer position forward.
pub const MACH_TBRF: u8 = MACH_TEMP_BUFFER_READ_FORWARD;
/// Machine function: temp buffer read.
pub const MACH_TBR: u8 = MACH_TEMP_BUFFER_READ;
/// Machine function: temp buffer read and write 0.
pub const MACH_TBRW0: u8 = MACH_TEMP_BUFFER_READ_WRITE_0;
/// Machine function: temp buffer read and write 1.
pub const MACH_TBRW1: u8 = MACH_TEMP_BUFFER_READ_WRITE_1;
/// Machine function: move temp buffer position backward.
pub const MACH_TBB: u8 = MACH_TEMP_BUFFER_BACKWARD;
/// Machine function: Stop 3.
pub const MACH_S3: u8 = MACH_STOP_3;
/// Machine function: Stop 2.
pub const MACH_S2: u8 = MACH_STOP_2;
/// Machine function: Stop.
pub const MACH_S: u8 = MACH_STOP;

const DFS_EXT_ADD: usize = 1usize << (usize::BITS - 1);

/// Machine function type.
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum MinInfFunc {
    #[default]
    /// Machine function: memory address read and move memory address position forward.
    MemAddressReadForward,
    /// Machine function: memory read.
    MemRead,
    /// Machine function: memory read and write 0.
    MemReadWrite0,
    /// Machine function: memory read and write 1.
    MemReadWrite1,
    /// Machine function: move memory address position backward.
    MemAddressBackward,
    /// Machine function: memory address read.
    MemAddressRead,
    /// Machine function: memory address read and write 0.
    MemAddressReadWrite0,
    /// Machine function: memory address read and write 1.
    MemAddressReadWrite1,
    /// Machine function: temp buffer read and move temp buffer position forward.
    TempBufferReadForward,
    /// Machine function: temp buffer read.
    TempBufferRead,
    /// Machine function: temp buffer read and write 0.
    TempBufferReadWrite0,
    /// Machine function: temp buffer read and write 1.
    TempBufferReadWrite1,
    /// Machine function: move temp buffer position backward.
    TempBufferBackward,
    /// Machine function: Stop 3.
    Stop3,
    /// Machine function: Stop 2.
    Stop2,
    /// Machine function: Stop.
    Stop,
}

/// Machine function: memory address read and move memory address position forward.
pub const MINF_MARF: MinInfFunc = MinInfFunc::MemAddressReadForward;
/// Machine function: memory read.
pub const MINF_MR: MinInfFunc = MinInfFunc::MemRead;
/// Machine function: memory read and write 0.
pub const MINF_MRW0: MinInfFunc = MinInfFunc::MemReadWrite0;
/// Machine function: memory read and write 1.
pub const MINF_MRW1: MinInfFunc = MinInfFunc::MemReadWrite1;
/// Machine function: move memory address position backward.
pub const MINF_MAB: MinInfFunc = MinInfFunc::MemAddressBackward;
/// Machine function: memory address read.
pub const MINF_MAR: MinInfFunc = MinInfFunc::MemAddressRead;
/// Machine function: memory address read and write 0.
pub const MINF_MARW0: MinInfFunc = MinInfFunc::MemAddressReadWrite0;
/// Machine function: memory address read and write 1.
pub const MINF_MARW1: MinInfFunc = MinInfFunc::MemAddressReadWrite1;
/// Machine function: temp buffer read and move temp buffer position forward.
pub const MINF_TBRF: MinInfFunc = MinInfFunc::TempBufferReadForward;
/// Machine function: temp buffer read.
pub const MINF_TBR: MinInfFunc = MinInfFunc::TempBufferRead;
/// Machine function: temp buffer read and write 0.
pub const MINF_TBRW0: MinInfFunc = MinInfFunc::TempBufferReadWrite0;
/// Machine function: temp buffer read and write 1.
pub const MINF_TBRW1: MinInfFunc = MinInfFunc::TempBufferReadWrite1;
/// Machine function: move temp buffer position backward.
pub const MINF_TBB: MinInfFunc = MinInfFunc::TempBufferBackward;
/// Machine function: Stop 3.
pub const MINF_STOP3: MinInfFunc = MinInfFunc::Stop3;
/// Machine function: Stop 3.
pub const MINF_S3: MinInfFunc = MinInfFunc::Stop3;
/// Machine function: Stop 2.
pub const MINF_STOP2: MinInfFunc = MinInfFunc::Stop2;
/// Machine function: Stop 2.
pub const MINF_S2: MinInfFunc = MinInfFunc::Stop2;
/// Machine function: Stop.
pub const MINF_STOP: MinInfFunc = MinInfFunc::Stop;
/// Machine function: Stop.
pub const MINF_S: MinInfFunc = MinInfFunc::Stop;

/// Gets machine function: memory read and write value. `bit` is value.
#[inline]
pub fn minf_mrw(bit: bool) -> MinInfFunc {
    if bit { MINF_MRW1 } else { MINF_MRW0 }
}

/// Gets machine function: memory address read and write value. `bit` is value.
#[inline]
pub fn minf_marw(bit: bool) -> MinInfFunc {
    if bit { MINF_MARW1 } else { MINF_MARW0 }
}

/// Gets machine function: temp buffer read and write value. `bit` is value.
#[inline]
pub fn minf_tbrw(bit: bool) -> MinInfFunc {
    if bit { MINF_TBRW1 } else { MINF_TBRW0 }
}

/// Conversion error for MinInfFunc.
#[derive(Clone, Copy, Debug, thiserror::Error)]
pub enum MinInfFuncConvertError {
    /// Function value out of range.
    #[error("Value {0} Out of range")]
    OutOfRange(u8),
}

/// Gets machine function: move sequential data position backward.
///
/// If `temp_buffer` is true then choose move temp_buffer position backward, otherwise
/// move memory address position backward.
#[inline]
pub fn minf_db(temp_buffer: bool) -> MinInfFunc {
    if temp_buffer { MINF_TBB } else { MINF_MAB }
}

/// Gets machine function: sequential data read and move it position forward.
///
/// If `temp_buffer` is true then choose temp buffer read and move it position forward, otherwise
/// memory address read and move it position forward.
#[inline]
pub fn minf_drf(temp_buffer: bool) -> MinInfFunc {
    if temp_buffer { MINF_TBRF } else { MINF_MARF }
}

/// Gets machine function: move sequential data read.
///
/// If `temp_buffer` is true then choose temp_buffer read, otherwise memory address read.
#[inline]
pub fn minf_dr(temp_buffer: bool) -> MinInfFunc {
    if temp_buffer { MINF_TBR } else { MINF_MAR }
}

/// Gets machine function: move sequential data read and write 0.
///
/// If `temp_buffer` is true then choose temp_buffer read and write 0, otherwise
/// memory address read and write 0.
#[inline]
pub fn minf_drw0(temp_buffer: bool) -> MinInfFunc {
    if temp_buffer { MINF_TBRW0 } else { MINF_MARW0 }
}

/// Gets machine function: move sequential data read and write 1.
///
/// If `temp_buffer` is true then choose temp_buffer read and write 1, otherwise
/// memory address read and write 1.
#[inline]
pub fn minf_drw1(temp_buffer: bool) -> MinInfFunc {
    if temp_buffer { MINF_TBRW1 } else { MINF_MARW1 }
}

/// Gets machine function: move sequential data read and write bit value.
///
/// If `temp_buffer` is true then choose temp_buffer read and write bit value, otherwise
/// memory address read and write bit value.
#[inline]
pub fn minf_drw(temp_buffer: bool, bit: bool) -> MinInfFunc {
    if temp_buffer {
        if bit { MINF_TBRW1 } else { MINF_TBRW0 }
    } else {
        if bit { MINF_MARW1 } else { MINF_MARW0 }
    }
}

impl MinInfFunc {
    /// Returns true if self function is stop.
    #[inline]
    pub fn is_stop(self) -> bool {
        self == MinInfFunc::Stop || self == MinInfFunc::Stop2 || self == MinInfFunc::Stop3
    }
}

impl Display for MinInfFunc {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let name = match self {
            MinInfFunc::MemAddressReadForward => "MINF_MARF",
            MinInfFunc::MemRead => "MINF_MR",
            MinInfFunc::MemReadWrite0 => "MINF_MRW0",
            MinInfFunc::MemReadWrite1 => "MINF_MRW1",
            MinInfFunc::MemAddressBackward => "MINF_MAB",
            MinInfFunc::MemAddressRead => "MINF_MAR",
            MinInfFunc::MemAddressReadWrite0 => "MINF_MARW0",
            MinInfFunc::MemAddressReadWrite1 => "MINF_MARW1",
            MinInfFunc::TempBufferReadForward => "MINF_TBRF",
            MinInfFunc::TempBufferRead => "MINF_TBR",
            MinInfFunc::TempBufferReadWrite0 => "MINF_TBRW0",
            MinInfFunc::TempBufferReadWrite1 => "MINF_TBRW1",
            MinInfFunc::TempBufferBackward => "MINF_TBB",
            MinInfFunc::Stop3 => "MINF_STOP3",
            MinInfFunc::Stop2 => "MINF_STOP2",
            MinInfFunc::Stop => "MINF_STOP",
        };
        write!(f, "{}", name)
    }
}

impl TryFrom<u8> for MinInfFunc {
    type Error = MinInfFuncConvertError;
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        use MinInfFunc::*;
        match value {
            MACH_MEM_ADDRESS_READ_FORWARD => Ok(MemAddressReadForward),
            MACH_MEM_READ => Ok(MemRead),
            MACH_MEM_READ_WRITE_0 => Ok(MemReadWrite0),
            MACH_MEM_READ_WRITE_1 => Ok(MemReadWrite1),
            MACH_MEM_ADDRESS_BACKWARD => Ok(MemAddressBackward),
            MACH_MEM_ADDRESS_READ => Ok(MemAddressRead),
            MACH_MEM_ADDRESS_READ_WRITE_0 => Ok(MemAddressReadWrite0),
            MACH_MEM_ADDRESS_READ_WRITE_1 => Ok(MemAddressReadWrite1),
            MACH_TEMP_BUFFER_READ_FORWARD => Ok(TempBufferReadForward),
            MACH_TEMP_BUFFER_READ => Ok(TempBufferRead),
            MACH_TEMP_BUFFER_READ_WRITE_0 => Ok(TempBufferReadWrite0),
            MACH_TEMP_BUFFER_READ_WRITE_1 => Ok(TempBufferReadWrite1),
            MACH_TEMP_BUFFER_BACKWARD => Ok(TempBufferBackward),
            MACH_STOP_3 => Ok(Stop3),
            MACH_STOP_2 => Ok(Stop2),
            MACH_STOP => Ok(Stop),
            _ => Err(MinInfFuncConvertError::OutOfRange(value)),
        }
    }
}

impl From<MinInfFunc> for u8 {
    fn from(f: MinInfFunc) -> u8 {
        use MinInfFunc::*;
        match f {
            MemAddressReadForward => MACH_MEM_ADDRESS_READ_FORWARD,
            MemRead => MACH_MEM_READ,
            MemReadWrite0 => MACH_MEM_READ_WRITE_0,
            MemReadWrite1 => MACH_MEM_READ_WRITE_1,
            MemAddressBackward => MACH_MEM_ADDRESS_BACKWARD,
            MemAddressRead => MACH_MEM_ADDRESS_READ,
            MemAddressReadWrite0 => MACH_MEM_ADDRESS_READ_WRITE_0,
            MemAddressReadWrite1 => MACH_MEM_ADDRESS_READ_WRITE_1,
            TempBufferReadForward => MACH_TEMP_BUFFER_READ_FORWARD,
            TempBufferRead => MACH_TEMP_BUFFER_READ,
            TempBufferReadWrite0 => MACH_TEMP_BUFFER_READ_WRITE_0,
            TempBufferReadWrite1 => MACH_TEMP_BUFFER_READ_WRITE_1,
            TempBufferBackward => MACH_TEMP_BUFFER_BACKWARD,
            Stop3 => MACH_STOP_3,
            Stop2 => MACH_STOP_2,
            Stop => MACH_STOP,
        }
    }
}

/// MinInfInstr conversion error.
#[derive(Debug, thiserror::Error)]
pub enum MinInfInstrConvertError<U64TError, TU64Error> {
    /// Next function return 0 overflow.
    #[error("NextFr0 overflow: {0}")]
    NextFr0Overflow(u64),
    /// Next function return 1 overflow.
    #[error("NextFr1 overflow: {0}")]
    NextFr1Overflow(u64),
    /// Integer (u64 from T) conversion error.
    #[error("U64 from T error: {0}")]
    U64FromTConversion(U64TError),
    /// Integer (T from u64) conversion error.
    #[error("T from U64 error: {0}")]
    TFromU64Conversion(TU64Error),
    /// Integer (u64 from usize) conversion error.
    #[error("U64 from Usize error: {0}")]
    U64FromUsizeConversion(TryFromIntError),
    /// Integer (usize from u64) conversion error.
    #[error("Usize from U64 error: {0}")]
    UsizeFromU64Conversion(TryFromIntError),
    /// MinInfFunc conversion error.
    #[error("U8 from MinInfFunc error: {0}")]
    MinInfFuncConversion(#[from] MinInfFuncConvertError),
    /// Integer (u64from u8) conversion error.
    #[error("U64 from U8 error: {0}")]
    U64FromU8Conversion(TryFromIntError),
    /// State length is too big.
    #[error("State length is too big: {0}")]
    StateLenTooBig(u32),
    /// Overflow while addition.
    #[error("Add overflow: {0} {1}")]
    AddOverflow(u64, u64),
}

/// Machine single instruction (table entry).
///
/// It defines function and next (internal) state for function return 0 and 1.
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct MinInfInstr {
    /// Function for function return 0.
    pub func_fr0: MinInfFunc,
    /// Function for function return 1.
    pub func_fr1: MinInfFunc,
    /// Next state for function 0.
    pub next_fr0: usize,
    /// Next state for function 1.
    pub next_fr1: usize,
}

impl MinInfInstr {
    /// Creates single instruction. `func0` and `func1` defines function for
    /// function return 0 and 1 respectively. `next0` and `next1` defines next state for
    /// function return 0 and 1 respectively.
    pub fn new(func0: MinInfFunc, func1: MinInfFunc, next0: usize, next1: usize) -> Self {
        Self {
            func_fr0: func0,
            func_fr1: func1,
            next_fr0: next0,
            next_fr1: next1,
        }
    }
    /// Creates single instruction. `func0` defines function for function return 0 and 1.
    /// `next` defines next state for function return 0 and 1.
    pub fn new_01(func: MinInfFunc, next: usize) -> Self {
        Self {
            func_fr0: func,
            func_fr1: func,
            next_fr0: next,
            next_fr1: next,
        }
    }
    /// Creates single instruction. `func0` and `func1` defines function for
    /// function return 0 and 1 respectively. `next` defines next state for
    /// function return 0 and 1.
    pub fn new_next01(func0: MinInfFunc, func1: MinInfFunc, next: usize) -> Self {
        Self {
            func_fr0: func0,
            func_fr1: func1,
            next_fr0: next,
            next_fr1: next,
        }
    }
    /// Creates single instruction. `func` defines function for function return 0 and 1.
    /// `next0` and `next1` defines next state for function return 0 and 1 respectively.
    pub fn new_func01(func: MinInfFunc, next0: usize, next1: usize) -> Self {
        Self {
            func_fr0: func,
            func_fr1: func,
            next_fr0: next0,
            next_fr1: next1,
        }
    }

    /// Tries to convert into pair of values of table entry. First returned value is
    /// for function return 0 and second returned value is for function return 1.
    pub fn try_into_pair<T>(
        &self,
        state_len: u32,
    ) -> Result<
        (T, T),
        MinInfInstrConvertError<<u64 as TryFrom<T>>::Error, <T as TryFrom<u64>>::Error>,
    >
    where
        T: TryFrom<u64>,
        u64: TryFrom<T>,
        <u64 as TryFrom<T>>::Error: Debug,
        <T as TryFrom<u64>>::Error: Debug,
    {
        if state_len > u64::BITS - 4 {
            return Err(MinInfInstrConvertError::StateLenTooBig(state_len));
        }
        let func_fr0 = u64::from(u8::from(self.func_fr0));
        let func_fr1 = u64::from(u8::from(self.func_fr1));
        let next_fr0 = <u64 as TryFrom<usize>>::try_from(self.next_fr0)
            .map_err(|e| MinInfInstrConvertError::U64FromUsizeConversion(e))?;
        let next_fr1 = <u64 as TryFrom<usize>>::try_from(self.next_fr1)
            .map_err(|e| MinInfInstrConvertError::U64FromUsizeConversion(e))?;
        let state_num = 1u64 << state_len;
        if next_fr0 >= state_num {
            return Err(MinInfInstrConvertError::NextFr0Overflow(next_fr0));
        }
        if next_fr1 >= state_num {
            return Err(MinInfInstrConvertError::NextFr1Overflow(next_fr1));
        }
        // checked addition
        let add0 = next_fr0.checked_add(func_fr0 << state_len).ok_or(
            MinInfInstrConvertError::AddOverflow(next_fr0, func_fr0 << state_len),
        )?;
        let add1 = next_fr1.checked_add(func_fr1 << state_len).ok_or(
            MinInfInstrConvertError::AddOverflow(next_fr1, func_fr1 << state_len),
        )?;
        Ok((
            T::try_from(add0).map_err(|e| MinInfInstrConvertError::TFromU64Conversion(e))?,
            T::try_from(add1).map_err(|e| MinInfInstrConvertError::TFromU64Conversion(e))?,
        ))
    }

    /// Tries to convert from table entry value pair. `state_len` defines internal state length
    /// in bits. `fr0` is value for function return 0 and `fr1` is value for function return 1.
    pub fn try_from_pair<T>(
        (fr0, fr1): (T, T),
        state_len: u32,
    ) -> Result<Self, MinInfInstrConvertError<<u64 as TryFrom<T>>::Error, <T as TryFrom<u64>>::Error>>
    where
        T: TryFrom<u64>,
        u64: TryFrom<T>,
        <u64 as TryFrom<T>>::Error: Debug,
        <T as TryFrom<u64>>::Error: Debug,
    {
        let fr0 = u64::try_from(fr0).map_err(|e| MinInfInstrConvertError::U64FromTConversion(e))?;
        let fr1 = u64::try_from(fr1).map_err(|e| MinInfInstrConvertError::U64FromTConversion(e))?;
        let mask = (1u64 << state_len) - 1;
        Ok(Self {
            func_fr0: u8::try_from(fr0 >> state_len)
                .map_err(|e| MinInfInstrConvertError::U64FromU8Conversion(e))?
                .try_into()?,
            func_fr1: u8::try_from(fr1 >> state_len)
                .map_err(|e| MinInfInstrConvertError::U64FromU8Conversion(e))?
                .try_into()?,
            next_fr0: usize::try_from(fr0 & mask)
                .map_err(|e| MinInfInstrConvertError::UsizeFromU64Conversion(e))?,
            next_fr1: usize::try_from(fr1 & mask)
                .map_err(|e| MinInfInstrConvertError::UsizeFromU64Conversion(e))?,
        })
    }

    /// Check equality for inner states (it used internally).
    pub fn equal_by_inner_states(&self, b: &MinInfInstr) -> bool {
        self.func_fr0 == b.func_fr0
            && self.func_fr1 == b.func_fr1
            && ((self.next_fr0 >= DFS_EXT_ADD && b.next_fr0 >= DFS_EXT_ADD)
                || self.next_fr0 == b.next_fr0)
            && ((self.next_fr1 >= DFS_EXT_ADD && b.next_fr1 >= DFS_EXT_ADD)
                || self.next_fr1 == b.next_fr1)
    }
}

impl Display for MinInfInstr {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "({}, {}, {}, {})",
            self.func_fr0, self.func_fr1, self.next_fr0, self.next_fr1
        )
    }
}

impl From<(MinInfFunc, usize)> for MinInfInstr {
    fn from(f: (MinInfFunc, usize)) -> Self {
        Self::new_01(f.0, f.1)
    }
}

impl From<(MinInfFunc, usize, usize)> for MinInfInstr {
    fn from(f: (MinInfFunc, usize, usize)) -> Self {
        Self::new_func01(f.0, f.1, f.2)
    }
}

impl From<(MinInfFunc, MinInfFunc, usize)> for MinInfInstr {
    fn from(f: (MinInfFunc, MinInfFunc, usize)) -> Self {
        Self::new_next01(f.0, f.1, f.2)
    }
}

impl From<(MinInfFunc, MinInfFunc, usize, usize)> for MinInfInstr {
    fn from(f: (MinInfFunc, MinInfFunc, usize, usize)) -> Self {
        Self::new(f.0, f.1, f.2, f.3)
    }
}

/// Tries to convert code (list of MinInfInstrs) into MinInfMachine transition table.
pub fn try_to_table<T>(
    code: Vec<MinInfInstr>,
) -> Result<Vec<T>, MinInfInstrConvertError<<u64 as TryFrom<T>>::Error, <T as TryFrom<u64>>::Error>>
where
    T: Clone + Default + TryFrom<u64>,
    u64: TryFrom<T>,
    <u64 as TryFrom<T>>::Error: Debug,
    <T as TryFrom<u64>>::Error: Debug,
{
    let state_num = code.len();
    let state_len = calc_log_bits(state_num) as u32;
    let inter = code
        .into_iter()
        .map(|x| x.try_into_pair(state_len))
        .collect::<Result<Vec<_>, _>>()?;
    let mut out = vec![T::default(); 1 << (state_len + 1)];
    for (i, (fr0, fr1)) in inter.into_iter().enumerate() {
        out[i] = fr0;
        out[i + (1 << state_len)] = fr1;
    }
    Ok(out)
}

/// Convert code (list of instructions) into MinInfMachine transition table. Panics if failed.
pub fn to_table<T>(code: Vec<MinInfInstr>) -> Vec<T>
where
    T: Clone + Default + TryFrom<u64>,
    u64: TryFrom<T>,
    <u64 as TryFrom<T>>::Error: Debug,
    <T as TryFrom<u64>>::Error: Debug,
{
    try_to_table(code).unwrap_or_else(|e| {
        panic!("While conversion to table: {:?}", e);
    })
}

/// Conversion from table error.
#[derive(Debug, thiserror::Error)]
pub enum FromTableError<ConvError> {
    /// Bad table length (is not power of 2).
    #[error("Bad table length")]
    BadTableLength,
    /// Conversion error.
    #[error("Conversion: {0}")]
    Conversion(#[from] ConvError),
}

/// Tries to convert from table into code (list of instructions).
pub fn try_from_table<T>(
    table: Vec<T>,
) -> Result<
    Vec<MinInfInstr>,
    FromTableError<MinInfInstrConvertError<<u64 as TryFrom<T>>::Error, <T as TryFrom<u64>>::Error>>,
>
where
    T: Clone + TryFrom<u64>,
    u64: TryFrom<T>,
    <u64 as TryFrom<T>>::Error: Debug,
    <T as TryFrom<u64>>::Error: Debug,
{
    if (table.len() & 1) != 0 {
        // if table length not even
        return Err(FromTableError::BadTableLength);
    }
    let state_num = table.len() >> 1;
    let state_len = calc_log_bits(state_num) as u32;
    Ok(table[0..state_num]
        .iter()
        .zip(table[state_num..state_num << 1].iter())
        .map(|(fr0, fr1)| MinInfInstr::try_from_pair((fr0.clone(), fr1.clone()), state_len))
        .collect::<Result<Vec<_>, _>>()?)
}

/// Type of position of function (it include state and function return).
///
/// This is type of position to locate machine function (single state has two functions).
/// While operating on code only state is position.
pub type MinInfPos = (usize, bool);

/// Returns true if position is function return 0.
#[inline]
pub fn is_fr0(p: MinInfPos) -> bool {
    !p.1
}

/// Returns true if position is function return 1.
#[inline]
pub fn is_fr1(p: MinInfPos) -> bool {
    p.1
}

/// Convert from table into code (list of instructions). Panics if failed.
pub fn from_table<T>(table: Vec<T>) -> Vec<MinInfInstr>
where
    T: Clone + TryFrom<u64>,
    u64: TryFrom<T>,
    <u64 as TryFrom<T>>::Error: Debug,
    <T as TryFrom<u64>>::Error: Debug,
{
    try_from_table(table).unwrap_or_else(|e| {
        panic!("While conversion from table: {:?}", e);
    })
}

/// The builder module.
pub mod builder;
/// The handlers module. It provides helpers to generate structutal code.
pub mod handler;
/// Integrates builder and handlers together.
pub mod handler_builder;
/// Provides transition table optimization.
pub mod table_opt;