#call #channels #ownership #send #value #reference #traits #parameterize #calling-convention #results


A trick to parameterize functions and traits by the calling convention of their arguments and results

5 releases

0.2.3 Apr 13, 2021
0.2.2 Apr 5, 2021
0.2.1 Apr 1, 2021
0.2.0 Mar 24, 2021
0.1.0 Dec 16, 2020

#898 in Rust patterns

Download history 30/week @ 2022-08-04 43/week @ 2022-08-11 18/week @ 2022-08-18 22/week @ 2022-08-25 34/week @ 2022-09-01 53/week @ 2022-09-08 15/week @ 2022-09-15 36/week @ 2022-09-22 52/week @ 2022-09-29 41/week @ 2022-10-06 13/week @ 2022-10-13 22/week @ 2022-10-20 36/week @ 2022-10-27 55/week @ 2022-11-03 38/week @ 2022-11-10 37/week @ 2022-11-17

173 downloads per month
Used in 7 crates (via dialectic)

MIT license

183 lines

Calling Convention Polymorphism in Rust

To parameterize a function by calling convention, we can specify that it takes some T: By<'a, Convention>, and say that its input is of type <T as By<'a, Convention>>::Type. This is essentially a defunctionalization of Rust's reference operators.

This trick can be used to permit the implementor of a trait to pick the calling convention for a value passed into (or out of) a function defined in that trait, rather than this being hardcoded in the trait definition.


For instance, say we wanted to define an abstraction for channels that can send values. Imagine, however, that some channels might need to take ownership of the values they send, while others might serialize values given only a reference to that value. In order to unify these two notions into one trait, we can parameterize over the calling convention for the input value:

use call_by::{By, Convention};

trait Sender<'a, T>
    T: By<'a, Self::Convention>,
    type Convention: Convention;
    fn send(&self, value: <T as By<'a, Self::Convention>>::Type);

Implementers of the Sender trait can choose whether the associated type Convention should be Val, Ref, or Mut, which toggles the result of <T as By<'a, Self::Convention>>::Type between T, &'a T, and &'a mut T, respectively. Meanwhile, callers of the send method on concretely known types don't need to specify the calling convention; the type-level function determines what type they need to pass as the argument to send, and type errors are reported in reference to that concrete type if it is known at the call site.

No runtime deps