::ext-trait

Annotation to easily define ad-hoc / one-shot extension traits.

Examples

• Also

  #[macro_use]
  extern crate ext_trait;
  
  #[extension(trait Also)]
  impl 
       T {
      
       fn 
       also (
       mut 
       self, f: 
       impl 
       FnOnce(
       &
       mut 
       Self))
        -> 
       Self
      {
          
       f(
       &
       mut 
       self);
          
       self
      }
  }
  
  
       fn 
       main ()
  {
      
       use 
       ::std
       ::{collections
       ::HashMap, ops
       ::Not};
  
      
       let 
       /* immut */ map 
       = HashMap
       ::
       with_capacity(
       2).
       also(
       |m
       | {
          m.
       insert(
       "foo", 
       42);
          m.
       insert(
       "bar", 
       27);
      });
      
       assert!(map.
       contains_key(
       "foo"));
      
       assert!(map.
       contains_key(
       "bar"));
      
       assert!(map.
       contains_key(
       "baz").
       not());
  }
      

• WithPath

  #[macro_use]
  extern crate ext_trait;
  
  use ::std::{error::Error, path::{Path, PathBuf}};
  
  #[extension(trait WithPath)]
  impl PathBuf {
      fn with (mut self, segment: impl AsRef<Path>)
        -> PathBuf
      {
          self.push(segment);
          self
      }
  }
  
  fn main ()
    -> Result<(), Box<dyn Error>>
  {
      let some_dir = PathBuf::from(::std::env::var("MY_LIB_SOME_DIR")?);
      // Contrary to chaining `.join()`, this reuses the memory!
      let some_subdir = some_dir.with("some").with("sub").with("dir");
      // …
      Ok(())
  }

• Context

  Result<(), Box > { let file_contents = ::std::fs::read_to_string("some/file") .context("Error when opening some/file")? ; // … Ok(()) } ">

  #[macro_use]
  extern crate ext_trait;
  
  use ::std::{error::Error, fmt::Display};
  
  #[extension(trait Context)]
  impl 
        Result
        
          {
      
         fn 
         context (
         self, prefix: 
         impl Display)
        -> 
         Result
         
          String>
      {
          
          self.
          map_err(
          |err
          | 
          format!(
          "{}: {}", prefix, err))
      }
  }
  
  
          fn 
          main ()
    -> 
          Result<(), 
          Box<
          dyn Error>>
  {
      
          let file_contents 
          =
          
          ::std
          ::fs
          ::
          read_to_string(
          "some/file")
              .
          context(
          "Error when opening some/file")?
      ;
      
          // …
      
          Ok(())
  }
         
        
       

Similar to https://docs.rs/extension-trait, but for the following:

Features

• Supports generics (see Context)

• search/grep 'trait TraitName'-friendly!