derive_more VS frunk

Is there a way to use derive_more to handle the generation of binary operators with one or both referenced operands? For example, avoiding having to do this macro dance for every combination of MyVal and &MyVal, for every operator needed:

This fails to compile. Looking at the implementation for that macro I don't see a way to use it that would work: https://github.com/JelteF/derive_more/blob/master/impl/src/from.rs

tl;dr you can put commit hashes in the place where the parent comment put tags.

The PR interface actually exposes this for force-pushes, but the UI discovery for this is horrible. It turns out that the "force-pushed" part in the little message in the github UI is actually a link. This link points to the diff between the old and the new HEAD of the branch.

As an example you can look at this PR:

It has this little message somewhere down the page:

Monadic-Cat force-pushed the add-unwrap branch from e130dbe to 25235aa 4 months ago

If you then click that link you go to the "compare" page, which shows the diff between the two commits:

https://github.com/JelteF/derive_more/compare/e130dbe6b2a429...

Disclaimer: I'm a Micrsoft employe, but don't work on Github. I'm a daily user of Github though.

So rust doesn't support variadics, but I have heard some murmurings around the topic. In the meantime, you can still do a lot with recursive tras. The frunk crate makes working with them a lot easier: In this case

I think the closest possible approach is the one used in frunk where those consecutive types are nested recursively (creating a linked list on type level basically) and special type is used as the end.

I suggest looking into frunk. You could convert the struct into an HList, map over the values to convert and convert into the target struct. README has some relevant examples.

So a while back I got interested in how rust could provide parallel/concurrent APIs that prevent deadlocking shared state. I now created a Proof-of-Concept stream processing library that attempts to do that. The library makes prodigious use of heterogeneous lists from the frunk library. The basic idea is that you can build a graph by combining source streams as source nodes and mutexes for state, then you can add nodes which subscribe to subsets of the previous nodes using various combinators. You can either

Hey, #[derive(LabelledGeneric)] from frunk does something like this, but without const generics, so it has odd representations for things like type-level strings (it's represented as a tuple of chars so (a, b, c) is the type-level representation of the string "abc")

I don't understand why you call it "trickery or "fake". Church encoding of natural numbers is the same technique used in Agda, Coq and Idris to represent the Peano numbers. It's a completely valid encoding and isomorphic to any other representation.

You don't need to use a fixed-length array either - you can used a recursive linked list at the type-level for an unbounded encoding [1]. The Scala library is an example of that; the Github page even has an example of encoding arbitrary units like sheep and wheat.

[1] https://github.com/lloydmeta/frunk

I wonder if frunk can (ab)use this kind of trick to make their crate even more powerful. IIRC they have a bunch of amazing and horrible workarounds to work with type-level lists.