Attribute macro for implementing methods on both Foo and ArchivedFoo.

Last update: Aug 6, 2023

Related tags

Overview

rkyv_impl

Implement methods for Foo and ArchivedFoo in a single impl block.

use rkyv::Archive;
use rkyv_impl::*;
use std::iter::Sum;

#[derive(Archive)]
struct Foo<T> {
    elements: Vec<T>
}

#[archive_impl(transform_bounds(T))]
impl<T> Foo<T> {
    #[archive_method(transform_bounds(T))]
    fn sum<S>(&self) -> S
    where
        T: Clone,
        S: Sum<T>
    {
        self.elements.iter().cloned().sum()
    }
}

// Notice that the trait bounds are transformed so that
// `T` is replaced with `T::Archived`.
fn call_generated_method<T, S>(foo: &ArchivedFoo<T>)
where
    T: Archive,
    T::Archived: Clone,
    S: Sum<T::Archived>
{
    let _ = foo.sum::<S>();
}

License: MIT/Apache-2.0

Comments

Explicit `T: Archive` bounds
Right now, the user must provide T: Archive bounds for generics, but this unnecessarily constrains the non-archived impl, for example:

#[archive_impl] impl<T> Foo<T> where T: Archive<Archived = T>, { fn get_slice(&self) -> &[T] { &self.field } }

This leaves the bound on T within the impl<T> Foo<T> ... { ... } item, but the bound is really only required for the impl<T> ArchivedFoo<T> item.

We should find a way to limit the placement of these bounds, either with another macro annotations or by placing them automatically. But automatic placement may go too far in the opposite direction; we don't always need T: Archive bounds, for example:

struct Foo<T> { marker: PhantomData<T> }
opened by bonsairobo 3
Make inheritance of original `impl` and method trait bounds opt-in
When trait bounds are always inherited, this may over-constrain the generated methods, causing superfluous bounds to propagate through all generic code.

We could have an opt-in syntax like:

#[archive_impl(inherit, bounds(...))] impl<T> Foo<T> { #[archive_method(inherit, bounds(...))] fn method(...) { ... } }
opened by bonsairobo 2
"Conditional compilation" blocks
Sometimes you get into tricky situations where you just need to specialize the archived implementation of a method. We might be able to support something like:

#[archive_impl] impl Foo { fn do_it_up(&self) { #[if_archived] { // some archived-specific logic, like deserializing } #[else] { // the alternative } } }

I don't know if that's good syntax. We might need to experiment.
opened by bonsairobo 1
Generalizing to generic traits
The motivating use case for this issue is:

#[archive_impl(Foo)] impl From<&Foo> for Bar { ... }

So in this case, Foo: Archived and we want to generate the equivalent impl From<&ArchivedFoo> for Bar { ... }
opened by bonsairobo 0
Original-only bounds

I haven't thought of a convincing use case for omitting bounds from the original impl or fn items, but I suspect such a use case exists. Implementing this feature would not be very challenging, so this could be a good first issue for new contributors. I will leave open until I encounter the need for this.

opened by bonsairobo 5

Supporting other `Self` types

There are several variants of syn::Type that we ignore in the macro, and some of these might actually have valid use cases:

        /// A raw pointer type: `*const T` or `*mut T`.
        Ptr(TypePtr),

        /// A reference type: `&'a T` or `&'a mut T`.
        Reference(TypeReference),

        /// A dynamically sized slice type: `[T]`.
        Slice(TypeSlice),

        /// A trait object type `dyn Bound1 + Bound2 + Bound3` where `Bound` is a
        /// trait or a lifetime.
        TraitObject(TypeTraitObject),

        /// A tuple type: `(A, B, C, String)`.
        Tuple(TypeTuple),

opened by bonsairobo 0

Owner

Duncan

GitHub

Advent of Code 2015, done entirely in Rust both for the challenge and as a way to learn

Advent of Code 2015 In preparation for Advent of Code 2021, I wanted to go back and try some of the older challenges. I figured it made the most sense

1 Dec 9, 2021

The most primitive and the fastest implementation of a fixed-size last-in-first-out stack on stack in Rust, for Copy-implementing types

This is the simplest and the fastest (faster than Vec!) implementation of a last-in-first-out stack data structure, on stack, when stack elements are

10 Jun 18, 2023

A copypastable guide to implementing simple derive macros in Rust.

A copypastable guide to implementing simple derive macros in Rust. The goal Let's say we have a trait with a getter trait MyTrait {

131 Dec 27, 2022

Might have a go at implementing Pulumi for Rust 🤷‍♂️

Might have a go at implementing Pulumi for Rust ??‍♂️

11 Nov 1, 2022

Inverse kinematics plugin for Bevy implementing the FABRIK algorithm.

11 Dec 31, 2022

A Rust proc-macro crate which derives functions to compile and parse back enums and structs to and from a bytecode representation

Bytecode A simple way to derive bytecode for you Enums and Structs. What is this This is a crate that provides a proc macro which will derive bytecode

4 Sep 3, 2022

A stupid macro that compiles and executes Rust and spits the output directly into your Rust code

inline-rust This is a stupid macro inspired by inline-python that compiles and executes Rust and spits the output directly into your Rust code. There

19 Nov 29, 2022

This crate provides a convenient macro that allows you to generate type wrappers that promise to always uphold arbitrary invariants that you specified.

prae This crate provides a convenient macro that allows you to generate type wrappers that promise to always uphold arbitrary invariants that you spec

96 Dec 4, 2022

The nightly_crimes!{} macro commits horrible crimes to allow you to enable nightly features on the stable compiler.

151 Dec 16, 2022

This crate defines a single macro that is a brainfunct compile-time interpreter.

Compile Protection This crate defines a single macro that is a brainfunct compile-time interpreter. One example is as follows #![recursion_limit = "18

7 Nov 29, 2021

Example of structuring a proc macro crate for testability

testing-proc-macros Example of structuring a proc macro crate for testability. See accompanying blog post for details. License Licensed under either o

12 Dec 11, 2022

Macros to make writing proc-macro crates easy

proc-easy Macros to make writing proc-macro crates easy. This crate provides mainly macros and supporting types and traits to reduce amount of boilerp

7 Jan 1, 2023

Rust macro to use a match-like syntax as a elegant alternative to nesting if-else statement

cond Rust macro to use a match-like syntax as an elegant alternative to many if-else statements. I got the idea from empty Go switch statements. I tho

3 Nov 23, 2023

A library and tool for automata and formal languages, inspired by JFLAP

Sugarcubes is a library and application for automata and formal languages. It is inspired by JFLAP, and is intended to eventually to be an alternative to JFLAP.

22 Nov 2, 2022

This is a Discord bot written in Rust to translate to and from the Bottom Encoding Standard using bottom-rs and Serenity.

bottom-bot This is a Discord bot written in Rust to translate to and from the Bottom Encoding Standard using bottom-rs and Serenity. Ever had this pro

11 Dec 10, 2022

An implementation of Code Generation and Factoring for Fast Evaluation of Low-order Spherical Harmonic Products and Squares

sh_product An implementation of Code Generation and Factoring for Fast Evaluation of Low-order Spherical Harmonic Products and Squares (paper by John

7 Dec 2, 2022