Konflikt mutable/immutable reference po wprowadzeniu parametru czasu życia

fn reading<'a>(input : &mut dyn Read, tr : &'a mut TermReader<'a>) {
    let mut buff : [u8;10] = [0;10];

    while match input.read(&mut buff) {
        Ok(len) => { tr.accept(&buff[0..len]) },
        Err(e) => {
            println!("ERROR: {}", e);
            false
        }
    } {}
}

 let mut tr = TermReader::new(initial_keys, Some(KeyAction::Action(ac_elsekey)));
 reading(&mut input, &mut tr);
 println!("{}", tr.args.join(","));

error[E0499]: cannot borrow `*tr` as mutable more than once at a time
  --> src/main.rs:125:22
   |
121 | fn reading<'a>(input : &mut dyn Read, tr : &'a mut TermReader<'a>) {
   |            -- lifetime `'a` defined here
...
125 |         Ok(len) => { tr.accept(&buff[0..len]) },
   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
   |                      |
   |                      `*tr` was mutably borrowed here in the previous iteration of the loop
   |                      argument requires that `*tr` is borrowed for `'a`

error[E0502]: cannot borrow `tr.args` as immutable because it is also borrowed as mutable
  --> src/main.rs:201:20
   |
200 |     reading(&mut input, &mut tr);
   |                         ------- mutable borrow occurs here
201 |     println!("{}", tr.args.join(","));
   |                    ^^^^^^^^^^^^^^^^^
   |                    |
   |                    immutable borrow occurs here
   |                    mutable borrow later used here

struct TermReader<'a> {
    data: &'a [u8],
}

impl<'a> TermReader<'a> {
    fn accept(&mut self, data: &'a [u8]) {
        self.data = data;
    }
}

fn reading<'a>(input : &mut dyn Read, tr : &'a mut TermReader<'a>) {
    /* ... */
}

fn main() {
    let mut tr = TermReader {
        data: &[]
    };
    
    reading(&mut Cursor::new(vec![1, 2, 3]), &mut tr);

    // dokąd teraz wskazuje tr.data?
}

impl<'a> TermReader<'a> {
    //...
    
    fn accept(&'a mut self, keys : &[u8]) -> bool {
        if self.key_map.contains_key(&keys[0]) {
            let x = self.key_map[&keys[0]];
            x.run(self, keys)
        } else {
            match self.elsekey {
                Some(x) => x.run(self,keys),
                None => {
                    echo(keys);
                    self.current = self.current.clone() + str::from_utf8(keys).unwrap();
                    true
                }
            }
        }
    }

    fn accept<'b>(&'a mut self, keys : &'b [u8]) -> bool {

fn accept(&mut self, keys : &[u8]) -> bool {

struct Foo<'a> {
    val: &'a str,
}

impl<'a> Foo<'a> {
    fn foo(&mut self) {
        println!("{}", self.val);
    }
}

fn main() {
    let mut foo: Foo<'static> = Foo {
        val: "Hello!",
    };
    
    foo.foo();
}

impl<'a> Foo<'a> {
    fn foo(&'a mut self) {
        println!("{}", self.val);
    }
}

error[E0597]: `foo` does not live long enough
  --> src/main.rs:16:5
   |
12 |     let mut foo: Foo<'static> = Foo {
   |                  ------------ type annotation requires that `foo` is borrowed for `'static`
...
16 |     foo.foo();
   |     ^^^^^^^^^ borrowed value does not live long enough
17 | }
   | - `foo` dropped here while still borrowed

impl<'a> Foo<'a> {
    fn foo<'b>(&'b mut self)
    where
        'a: 'b,
    {
        println!("{}", self.val);
    }
}

struct Foo<'a> {
    val: &'a str,
}

impl<'a> Foo<'a> {
    fn foo(&'a self) {
        println!("{}", self.val);
    }
}

fn main() {
    let foo: Foo<'static> = Foo {
        val: "Hello!",
    };
    
    foo.foo();
}

struct TermReader<'a> {
    key_map : KeyBind<'a>,
    elsekey : Option<KeyAction<'a>>,
    current : String,
    hint_gen : ShCommands,
    hints : Option<ExcerptIter<'a, String>>, // <- ten iterator wymaga lifetime'a
    pub args : Vec<String>                   // Pozostałe wynikaja z tego, że prototyp handlera
}                                            // musi je uwzględnić

error[E0502]: cannot borrow `tr.args` as immutable because it is also borrowed as mutable
   --> src/main.rs:177:20
    |
176 |     reading(&mut input, &mut tr);
    |                         ------- mutable borrow occurs here
177 |     println!("{}", tr.args.join(","));
    |                    ^^^^^^^^^^^^^^^^^
    |                    |
    |                    immutable borrow occurs here
    |                    mutable borrow later used here

fn ac_elsekey<'a, 'b>(tr: &'b mut TermReader<'a>, keys: &[u8]) -> bool
        where 'a : 'b {
    if tr.args.len() > 0 {
        echo(keys);
        tr.current = tr.current.clone() + str::from_utf8(keys).unwrap();
        return true
    }

    let trial = tr.current.clone() + str::from_utf8(keys).unwrap();
    match tr.hint_gen.for_prefix(&trial) {
        Ok(mut newhints) => { 
            if newhints.len() > 0 {
                let first = newhints.get().unwrap();
                Term.echo(first.get(tr.current.len()..).unwrap().as_bytes())
                    .endline()
                    .hmove(-((first.len() - tr.current.len() - 1) as i32));
                
                tr.current = tr.current.clone() + str::from_utf8(keys).unwrap();
                tr.hints = Some(newhints);
            }
        },
        Err(_) => {}
    }

    true
}

error[E0623]: lifetime mismatch
   --> src/main.rs:152:28
    |
134 | fn ac_elsekey<'a, 'b>(tr: &'b mut TermReader<'a>, keys: &[u8]) -> bool
    |                           ----------------------
    |                           |
    |                           these two types are declared with different lifetimes...
...
152 |                 tr.hints = Some(newhints);
    |                            ^^^^^^^^^^^^^^ ...but data from `tr` flows into `tr` here

error[E0308]: mismatched types
   --> src/main.rs:201:71
    |
201 |     let mut tr = TermReader::new(initial_keys, Some(KeyAction::Action(ac_elsekey)));
    |                                                                       ^^^^^^^^^^ one type is more general than the other
    |
    = note: expected fn pointer `for<'a, 'b, 'r> fn(&'b mut TermReader<'a>, &'r [u8]) -> _`
               found fn pointer `for<'r> fn(&mut TermReader<'_>, &'r [u8]) -> _`

type KAHandler = for <'a, 'b> fn(&'b mut TermReader<'a>, &[u8]) -> bool;

#[derive(Clone,Copy)]
enum KeyAction {
    Action(KAHandler),
}

struct TermCfg {
    key_map : KeyBind,
    elsekey : Option<KeyAction>,
    hints : ShCommands,
}

// ...

struct TermReader<'a> {
    current : String,
    pub args : Vec<String>,
    chint : Option<ExcerptIter<'a, String>>
}

    pub fn accept<'b>(self, cfg : &'b TermCfg, keys : &[u8]) -> (bool, TermReader<'b>)
            where 'a : 'b {
        if cfg.key_map.contains_key(&keys[0]) {
            let x = cfg.key_map[&keys[0]];
            x.run(self, cfg, keys)
        } else {
            match cfg.elsekey {
                Some(x) => x.run(self, cfg, keys),
                None => {
                    echo(keys);
                    let nc = self.current.clone() + str::from_utf8(keys).unwrap();
                    (true, self.with_current(nc))
                }
            }
        }
    }

type KAHandler = for <'a> fn(TermReader<'a>, &'a TermCfg, &[u8]) -> (bool, TermReader<'a>);

fn reading(input : &mut dyn Read, cfg : TermCfg) -> Vec<String> {
    let mut buff : [u8;10] = [0;10];
    let mut tr = TermReader::new();

    while match input.read(&mut buff) {
        Ok(len) => { let (cont, ntr) = tr.accept(&cfg, &buff[0..len]);
                     tr = ntr;
                     cont},
        Err(e) => {
            println!("ERROR: {}", e);
            false
        }
    } {}

    tr.args
}