fn foo_mut<'a>(_: &'a mut &'a String) {
// This function signature means take an exclusive reference for the entire rest of it's validity
}
fn foo<'a>(_: &'a &'a String) {}
fn main() {
let x = String::new();
let y: &String = &x;
foo(&y);
foo(&y); // It's passes something like &'smol &'big and &T is covariant so it can downgrade(?) 'big to 'smol, and with that you can call it as many times as you want
drop(x);
let i = String::new();
let mut j: &String = &i;
foo_mut(&mut i);
// Reference is eaten and still in use, so it's not possible to use `y`
// Something about &mut T being invariant over T but covariant over 'a
drop(y);
} foo_mut(&mut j);? then I get an error for the drop(y); but that one has nothing to do with lifetimes. it's simply that x has been dropped and thus y is no longer valid
foo_mut(&mut j);? then I get an error for the drop(y); but that one has nothing to do with lifetimes. it's simply that x has been dropped and thus y is no longer valid fn foo_mut<'a>(_: &'a mut &'a String) {
// This function signature means take an exclusive reference for the entire rest of it's validity
}
fn foo<'a>(_: &'a &'a String) {}
fn main() {
let x = String::new();
let mut y: &String = &x;
foo(&y);
foo(&y); // It's passes something like &'smol &'big and &T is covariant so it can downgrade(?) 'big to 'smol, and with that you can call it as many times as you want
foo_mut(&mut y);
// Reference is eaten and still in use, so it's not possible to use `y`
// Something about &mut T being invariant over T but covariant over 'a
drop(y);
} 
Client()->State() can be one of those STATE_OFFLINE, STATE_CONNECTING, STATE_LOADING, STATE_ONLINE, STATE_DEMOPLAYBACK, STATE_QUITTING, STATE_RESTARTING 
fn foo_mut<'a>(_: &'a mut &'a String) {
// This function signature means take an exclusive reference for the entire rest of it's validity
}
fn foo<'a>(_: &'a &'a String) {}
fn main() {
let x = String::new();
let mut y: &String = &x;
foo(&y);
foo(&y); // It's passes something like &'smol &'big and &T is covariant so it can downgrade(?) 'big to 'smol, and with that you can call it as many times as you want
foo_mut(&mut y);
// Reference is eaten and still in use, so it's not possible to use `y`
// Something about &mut T being invariant over T but covariant over 'a
drop(y);
} let y must be let mut y. do you even compile your examples? you should! the compiler gives better errors than the language server
let y must be let mut y. do you even compile your examples? you should! the compiler gives better errors than the language server let y must be let mut y. do you even compile your examples? you should! the compiler gives better errors than the language server a.ret() return? 
pub(crate) fn add_instr(&mut self, mut instruction: Instruction) -> Result<(), IcedError> {
if !self.current_label.is_empty() && self.defined_anon_label {
return Err(IcedError::new("You can't create both an anonymous label and a normal label"));
}
if !self.current_label.is_empty() {
instruction.set_ip(self.current_label.id());
} else if self.defined_anon_label {
instruction.set_ip(self.current_anon_label.id());
}
if self.prefix_flags != 0 {
if (self.prefix_flags & PrefixFlags::LOCK) != 0 {
instruction.set_has_lock_prefix(true);
}
if (self.prefix_flags & PrefixFlags::REPE) != 0 {
instruction.set_has_repe_prefix(true);
} else if (self.prefix_flags & PrefixFlags::REPNE) != 0 {
instruction.set_has_repne_prefix(true);
}
if (self.prefix_flags & PrefixFlags::NOTRACK) != 0 {
instruction.set_segment_prefix(Register::DS);
}
}
self.instructions.push(instruction);
self.current_label = CodeLabel::default();
self.defined_anon_label = false;
self.prefix_flags = PrefixFlags::NONE;
Ok(())
}
1fn foo_mut<'a>(_: &'a mut &'a String) {
// This function signature means take an exclusive reference for the entire rest of it's validity
}
fn foo<'a>(_: &'a &'a String) {}
fn main() {
let x = String::new();
let mut y: &String = &x;
foo(&y);
foo(&y); // It's passes something like &'smol &'big and &T is covariant so it can downgrade(?) 'big to 'smol, and with that you can call it as many times as you want
foo_mut(&mut y);
// Reference is eaten and still in use, so it's not possible to use `y`
// Something about &mut T being invariant over T but covariant over 'a
drop(y);
} foo_mut, but foo_mut constarains how long the inner reference y is valid, I think. but I'm not entirely sure about thisfoo_mut, but foo_mut constarains how long the inner reference y is valid, I think. but I'm not entirely sure about this x but it is :\&'a mut T<'a> or you are a bad person 
sv_no_weak_hook 1
https://ddnet.org/settingscommands/ 1fn foo_mut<'a>(_: &'a mut &'a String) {
// This function signature means take an exclusive reference for the entire rest of it's validity
}
fn foo<'a>(_: &'a &'a String) {}
fn main() {
let x = String::new();
let mut y: &String = &x;
foo(&y);
foo(&y); // It's passes something like &'smol &'big and &T is covariant so it can downgrade(?) 'big to 'smol, and with that you can call it as many times as you want
foo_mut(&mut y);
// Reference is eaten and still in use, so it's not possible to use `y`
// Something about &mut T being invariant over T but covariant over 'a
drop(y);
} x instead of y, will it be the place where y will not be valid anymore
)
std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()Console()->ExecuteLine("say /pause"); 
1
std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() 
1
&'a T<'a> and still didn't check repo's code of what I wanted to check at the first place
1&'a T<'a> and still didn't check repo's code of what I wanted to check at the first place 
cargo clean 1
1
