design question: Should transform_buffer be incremental?

[tesuji]

Hi, I use vi-rs for my linux input engine with a IBUS framework.
But IBus passes a single char each time a key typed.
For every key typed, I should display the preview string (as in Vietnameses) to users.
So I couldn't cache each/a word (Vec<char>) and pass it to transform_buffer.
So transform_buffer is called for every key typed.

So I wonder if we could create a new incremental transform_buffer.

fn transform_buffer_incremental<'def, 'buf>(
    def: &'def Definition,
    output: &'buf mut String,
) -> IncrementalBuffer;

struct IncrementalBuffer<'def, 'buf> {
    def: &'def Definition,
    output: &'buf mut String,
    input: Vec<char>,
    // cache something for example a Word.
}

impl IncrementalBuffer {
    pub fn push(&mut self, ch: char) -> TransformResult {
        self.input.push(ch);
        // ...
    }
    pub fn view(&self) -> &str;
    pub fn clear(&mut self) {
        self.output.clear();
        // clear cache
    }
}

[ZeroX-DG]

Woah. Nice work with the input engine!

Just curious, what is preventing you from introducing this incremental buffer in your input engine? 🤔

[tesuji]

I'm sorry for my misleading question. I could cache typed keys. However, look at vi::transfrom_buffer code

vi-rs/src/methods.rs

Lines 182 to 196 in 6c82a29

	pub fn transform_buffer<I>(
	definition: &Definition,
	buffer: I,
	output: &mut String,
	) -> TransformResult
	where
	I: IntoIterator<Item = char>,
	{
	let mut word = Word::empty();
	let mut tone_mark_removed = false;
	let mut letter_modification_removed = false;
	let mut last_executed_action = None;
	for ch in buffer {

A for loop is called from start to end of the buffer for every new typed key, like

transform_buffer(&self.buffer, &mut self.output);
// while "chaof" is typing, equivalent to 
transform_buffer(&"c", &mut self.output);   
transform_buffer(&"ch", &mut self.output);
transform_buffer(&"cha", &mut self.output);
transform_buffer(&"chao", &mut self.output);
transform_buffer(&"chaof", &mut self.output);

If we could cache every things outside that for loop, we reduce allocations for Word, and avoid looping from the start of each word/buffer.

[ZeroX-DG]

Ah I see what you mean. That's a great idea. We should definitely add something like that.