Extension traits

This Rust RFC
presents a accurate, instant definition of extension traits:

Extension traits are a programming sample that makes it seemingly so that you just can add
straightforward methods to an present form originate air of the crate defining that form.

As an illustration, it is a trait with a single formula:

trait Magic {
    fn magic_num(&self) -> usize;
}

We can now implement the Magic trait for our types:

struct Foobar {
    title: String,
}

impl Magic for Foobar {
    fn magic_num(&self) -> usize {
        return if self.title.len() == 0 { 2 } else { 33 };
    }
}

Now a FooBar would be passed wherever a Magic is anticipated. FooBar is a
custom form, however what’s basically attention-grabbing is that we are able to additionally implement
Magic for any diversified form, including types that we did no longer inform. Let’s
implement it for bool:

impl Magic for bool {
    fn magic_num(&self) -> usize {
        return if *self { 3 } else { 54 };
    }
}

We can now write code like unprejudiced correct.magic_num() and this will work! Now we gain added
a trend to a built-in Rust form. Clearly, we are able to additionally implement this trait
for types in the customary library; e.g.:

impl<T> Magic for Vec<T> {
    fn magic_num(&self) -> usize {
        return if self.len() == 0 { 10 } else { 5 };
    }
}

Extension traits in the wild

Extension traits are now not exact a fringe characteristic; they’re widely archaic in the Rust
ecosystem.

One instance is the everyday serde crate, which entails code that serializes
and deserializes recordsdata structures in a pair of formats. Undoubtedly one of many traits
serde presents is serde::Serialize; after we import this trait and indubitably one of
the concrete serializers serde presents, we are able to realize stuff like [1]:

let mut serializer = serde_json:: Serializer:: unique(std:: io:: stdout());
185.serialize(&mut serializer).unwrap();

Importing serde::Serialize is excessive for this code to work, even supposing we
don’t consult with Serialize wherever in our code explicitly. Rust requires
traits to be explicitly imported to imbue their methods onto present types;
otherwise it’s arduous to stay a ways from naming collisions in case a pair of traits from
diversified crates present the identical methods.

Every other instance is the byteorder crate, which helps encode numbers into
buffers with declare measurement and endianness. To write some numbers into a vector
byte-by-byte, we must import the linked trait and enum first, after which
we are able to call the newly-added methods at once on a vector:

use byteorder:: {LittleEndian, WriteBytesExt};

// ...

let mut wv = vec![];
wv.write_u16:: <LittleEndian>(259).unwrap();
wv.write_u16:: <LittleEndian>(517).unwrap();

The write_u16 formula is segment of the WriteBytesExt trait, and it’s
implemented on a Vec by the byteorder crate. To be extra exact, it’s
robotically implemented on any form that implements the Write trait.

At final, let’s take a study rayon – a library for simplified recordsdata-parallelism. It
presents magical iterators that gain the identical functionality as iter however
compute their ends up in parallel, leveraging a pair of CPU cores. The rayon
documentation recommends to import the traits the crate injects as follows:

It is a ways strongly suggested that you just import all of these traits right now by including
use rayon::prelude::* at the tip of every module that uses Rayon methods.

Having imported it thus, we are able to proceed to utilize Rayon as follows:

let exps = vec![2, 4, 6, 12, 24];
let pows_of_two: Vec<_> = exps.par_iter().plan(|n| 2_u64.pow(*n)).engage();

Demonstrate the par_iter, which replaces a daily iter. Or no longer it’s been magically
implemented on a vector, moreover to a bunch of diversified types that strengthen
iteration.

On greppability and code readability

All these uses of extension traits are gleaming chilly and precious, no question. However
that’s no longer the main point of my post. What I truly are looking out to chat about is how the
total formula pertains to code readability, which is in my mind indubitably one of many
most essential parts of programming we must all be interested by.

This Rust strategy fails the greppability test; it’s no longer a phrase I made up –
google it! If it’s no longer at once apparent, greppability formula the power to
detect a code noxious using textual search tools like grep, git grep,
ripgrep, pss or what gain you ever.

Bid you bump into this portion of code in a project it’s seemingly you’ll be exploring:

let mut wv = vec![];
wv.write_u16:: <LittleEndian>(259).unwrap();

“Curious”, you deem, “I did now not know that Vec has a write_u16
formula”. You mercurial test the documentation – certainly, it would now not! So where is
it coming from? You grep the project… nothing. Or no longer it’s nowhere in the
imports. You perceive the imports one after the opposite, and survey the:

use byteorder:: {LittleEndian, WriteBytesExt};

“Aha!”, you suppose, “this imports LittleEndian, so maybe this has to realize with
the byteorder crate”. You test the documentation of that crate and certainly,
you ranking the write_u16 formula there; phew.

With par_iter it’s seemingly you’ll be less lucky. Nothing in imports will obtain your spy,
except it’s seemingly you’ll be already conversant in the rayon crate. While it’s seemingly you’ll be no longer, then
use rayon::prelude::* acquired’t ring grand of a bell in relation to par_iter.

Needless to suppose, you’ll be ready to exact google this symbol like this and moreover you will ranking it. Or maybe
you don’t even realize what the misfortune is, because your IDE is completely
conversant in these symbols and can gladly pop up their documentation in the event you
waft over them.

IDEs and language servers

This present day we gain free, great and snappy IDEs that plan all of this a
non-remark (having a detect at Visual Studio Code, after all). Coupled with gleaming
language servers, these IDEs are as acquainted along with your code because the compiler;
the language servers in total speed a tubby entrance-stop sequence on the code, ending
up with form-checked ASTs unfriendly-referenced with symbol tables that allow them
realize where every symbol is coming from, its form etc. For Rust the
language server is RLS, for Trudge its gopls; all standard languages gain them these
days [2].

Or no longer it’s fully seemingly that using a language like Rust with out a stylish
IDE is madness, and I am a little bit of stuck in the previous. However I basically must suppose, I attain
lament the loss of greppability. There’s one thing very universal about being
ready to hold a project using most fine grep and the righteous documentation.

Truly, for some languages it’s likely that this has been the case for a protracted
whereas already. Who of their agreeable mind has the courage to kind out a Java project
with out an IDE? Or no longer it’s exact that this wasn’t continually the case for systems
programming languages, and Rust going this formula makes me a little bit of unhappy. Or maybe
I am exact too indoctrinated in Trudge at this point, where all symbol salvage admission to occurs
as bundle.Image, applications are imported explicitly and there may perhaps be rarely a magic
title injection wherever (nearly indubitably by construct).

I can no longer precisely build my finger on why this is bothering me; maybe I am exact
yelling at clouds
right here. While I am at it, I must in the damage write that post about printf-basically based
debugging…