pub fn new<I, F>(

        initial_state: StateIndex,

        num_of_states: Option<usize>,

        transition_iter: F,

        mut labels: Vec<String>,

        hidden_labels: Vec<String>,

    ) -> LabelledTransitionSystem 

    where F: Fn() -> I,

          I:Iterator<Item = (StateIndex, LabelIndex, StateIndex)> {

        let mut states = Vec::new();

        if let Some(num_of_states) = num_of_states {

            states.resize_with(num_of_states, Default::default);

        }

        let mut num_of_transitions = 0;

        for (from, _, to) in transition_iter() {

            while states.len() <= from.max(to) {

                states.push(State::default());

            }

            states[from].outgoing_end += 1;

            num_of_transitions += 1;

        states.iter_mut().fold(0, |count, state| {

            let result = count + state.outgoing_end;

            state.outgoing_start = count;

            state.outgoing_end = count;

            result

        });

        // Place the transitions, and increment the end for every state.

        let mut transitions = vec![(0, 0); num_of_transitions];

        for (from, label, to) in transition_iter() {

            transitions[states[from].outgoing_end] = (label, to);

            states[from].outgoing_end += 1;

        }

        let mut hidden_indices: Vec<usize> = Vec::new();

        for label in &hidden_labels {

            if let Some(index) = labels.iter().position(|other| other == label) {

                hidden_indices.push(index);

            }

        hidden_indices.sort();

        let introduced_tau = if hidden_indices.contains(&0) {

            labels[0] = "tau".to_string();

            false

            labels.insert(0, "tau".to_string());

            true

        for state in &mut states {

            for (label, _) in &mut transitions[state.outgoing_start..state.outgoing_end] {

                if hidden_indices.binary_search(label).is_ok() {

                    *label = 0;

                } 

                else if introduced_tau

                {

                    // Remap the zero action to the original first hidden index.

                    *label += 1;

                }

        LabelledTransitionSystem {

            initial_state,

            labels,

            hidden_labels,

            states,

            num_of_transitions: transitions.len(),

            transitions,

        }

    }

    pub fn initial_state_index(&self) -> StateIndex {

        self.initial_state

    }

    pub fn outgoing_transitions(&self, state_index: usize) -> impl Iterator<Item = &(LabelIndex, StateIndex)> {

        let state = &self.states[state_index];

        self.transitions[state.outgoing_start..state.outgoing_end].iter()

    }

    pub fn iter_states(&self) -> impl Iterator<Item = StateIndex> {

        0..self.states.len()

    }

    pub fn num_of_states(&self) -> StateIndex {

        self.states.len()

    }

    pub fn num_of_labels(&self) -> LabelIndex {

        self.labels.len()

    }

    pub fn num_of_transitions(&self) -> usize {

        self.num_of_transitions

    }

    pub fn labels(&self) -> &[String] {

        &self.labels[0..]

    }

    pub fn hidden_labels(&self) -> &[String] {

        &self.hidden_labels[0..]

    }

    pub fn is_hidden_label(&self, label_index: LabelIndex) -> bool {

        label_index == 0

    }

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        // Print some information about the LTS.

        writeln!(f, "Number of states: {}", self.states.len())?;

        writeln!(f, "Number of action labels: {}", self.labels.len())?;

        write!(f, "Number of transitions: {}", self.num_of_transitions)

    }