vec | A single-header C library all about generic vectors

A similar question was asked over on the Rust forum. To summarize, the full signature for Iterator::for_each is

Update: Since GitHub pull request #93755 has been merged, comparison between Vecs with different allocators is now possible.

Original answer:

Vec uses the std::alloc::Global allocator by default, so Vec is in fact Vec. Since Vec and Vec are indeed distinct types, they cannot directly be compared because the PartialEq implementation is not generic for the allocator type. As @PitaJ commented, you can compare the slices instead using assert_eq!(&a[..], &b[..]) (which is also what the author of the allocator API recommends).

As you discovered the meaning of {100}, changes for T == int.

To answer your question briefly:

The 100 in vector{100} cannot be interpreted as a Value and therefore the size constructor takes precedence.

If you insist, {100} can be interpreted as Value, so you may need an extra curly braces, vector{ {100} }.

See the illustration here: https://godbolt.org/z/xcMT1oc5z

My advice, avoiding further discussion on legalities, is the following:

To keep the meaning across types, initialize consistently parenthesis for size-initialization and brackets for element(s), which forces you to do this:

No, not until closure HRTB inference is fixed. Current workarounds include using function pointers instead or implementing a helper trait on custom structs -- the helper trait is needed regardless of approach until higher-kinded types are introduced in Rust.

Playground

To avoid returning a Box, you would need the type parameter I to be generic over the lifetime 'a, so that you can use it with any lifetime (in a for<'a> bound, for example). Unfortunately, as discussed in a similar question, Rust does not yet support higher-kinded types (type parameters that are themselves generic over other type parameters), so we must use a helper trait:

The code as given almost works. The limitation to bases < 36 is only there because the original author wanted to express the values with the symbols [0-9A-Z]. Removing that limitation and extending the algorithm to allow extra digits 'after the decimal point' (or 'after the sexagesimal point' in the case of base 60 :-) ) we get something that almost works (function definition below):

In Haskell, you can use existential types to express "some unknown type of this typeclass". (In older versions of GHC, you will need a few standard extensions on.)

The issue you're going to have to confront is how to deal with function calls. I can't really give you any concrete advice based on your question, because the grammar you provide lacks any indication of the intended syntax of functions calls, but the hint that print(5) is a valid statement makes it clear that there are two distinct situations, which need to be handled separately.

Consider:

Apparently this is a long time know bug with a combination of MSVC STL implementation choices and Standard specifications...

The issue I found when I was going to submit a bug report, from 2018: https://developercommunity.visualstudio.com/t/C2280-when-modifying-a-vector-containing/377449

• This error is present in MSVC 2017 and after.
• It seems like not going to be fixed. (see @Alex Guteniev's comment)

The explanation given: https://www.reddit.com/r/cpp/comments/6q94ai/chromium_windows_builds_now_use_clangcl_by_default/dkwdd8l/

• There is a workaround: vector>>, where the Wrapper is also a non-copyable type.

Let's go step by step to see how <[_]>::into_vec(box [$($x),+]) produces a Vec:

1. [$($x),+] expands to an array of input elements: [1, 2, 3]
2. box ... puts that into a Box. box expressions are nightly-only syntax sugar for Box::new: box 5 is syntax sugar for Box::new(5) (actually it's the other way around: internally Box::new uses box, which is implemented in the compiler)
3. <[_]>::into_vec(...) calls the to_vec method on a slice containing elements that have an inferred type ([_]). Wrapping the [_] in angled brackets is needed for syntactic reasons to call an method on a slice type. And into_vec is a function that takes a boxed slice and produces a Vec: