with_context in Odoo is a powerful tool that you use to modify function behavior dynamically. In this tutorial, you learn how to implement with_context in Odoo to control translations, default values, multi-company behavior, and other settings. You also discover how the Odoo context, maintained as a dictionary, can transform your recordsets without permanently altering them. You will actively follow our step-by-step code examples and explanations as you master context management in Odoo.

After some more messing around I did find a way to limit the type annotations to `HookCtx<_>`, which would make the constructor look like let hook = Hook::with_context(cc::C, |ctx: HookCtx<_>| move |arg: u32| -> u32 { ctx.call_original((arg,)) }); The trick lies in avoiding the dot operator, as you mentioned. If we instead call a generic method on `HookCtx`, the type inference algorithm only needs to know that `ctx` is a `HookCtx`, and is able to infer the generic parameters that make the call valid. Doing this will require some changes to the API -- in particular, a trait like this will be needed: unsafe trait FnPtr: Clone + Copy { type Args<'a, ..., 'max>; type Ret<'a, ..., 'max>; unsafe fn call<'a, ..., 'max>(self, args: Self::Args<'a, ..., 'max>) -> Self::Ret<'a, ..., 'max>; } where `'a, ..., 'max` is a fixed number of distinct lifetimes (3 would be a good choice I think). Making the associated types GATs should make retaining (partial) higher-kinded bare function support possible.

I wanted to add some kind of `adorn` (or `with_context` as in `anyhow`) extension trait method that users can use to add exactly this kind of information, but this would require them using it for almost every single place `Result` is used, of which there are a lot.

You can collect into a `Result`: type Gizmo = Result<Vec<String>>; fn slurp(path: impl AsRef<Path> + Display) -> Gizmo { let file = File::open(&path) .with_context(|| format!("Failed to open `{path}` at {}", Location::caller()))?; let buffer = BufReader::new(file); let lines: io::Result<Vec<String>> = buffer.lines().collect(); Ok(lines?) } fn main() -> Result<()> { let path = "test.dat"; if let Ok(lines) = slurp(&path) { for line in lines { println!("{} ", line); } } Ok(()) }

Please consider this: #1 with `collect()` use anyhow::{Context, Result}; #[allow(unused_imports)] use std::{ fmt::Display, fs::File, io::{self, BufRead, BufReader}, panic::Location, path::Path, }; type Gizmo = Result<io::Result<Vec<String>>>; fn slurp(path: impl AsRef<Path> + Display) -> Gizmo { let file = File::open(&path) .with_context(|| format!("Failed to open `{path}` at {}", Location::caller()))?; let buffer = BufReader::new(file); let lines = buffer.lines().collect(); Ok(lines) } fn main() -> Result<()> { let path = "test.dat"; if let Ok(lines) = slurp(&path)? { for line in lines { println!("{} ", line); } } Ok(()) } #2 with `push()` type Gizmo = Result<Vec<String>>; fn slurp(path: impl AsRef<Path> + Display) -> Gizmo { let file = File::open(&path) .with_context(|| format!("Failed to open `{path}` at {}", Location::caller()))?; let buffer = BufReader::new(file); let mut lines = Vec::new(); for line in buffer.lines(){ lines.push(line?); } Ok(lines) } fn main() -> Result<()> { let path = "test.dat"; if let Ok(lines) = slurp(&path) { for line in lines { println!("{} ", line); } } Ok(()) } How can i avoid to return a result of a result (like in version #2) using `collect()`(and therefore `slurp(&path)?` in `main`) in version #1?