Type annotations required everywhere

[95th]

The allocator generic Vec constructors ask for type annotations everywhere.

fn foo() {
    let b = Bump::new();
    let v = alloc_wg::vec::Vec::new_in(&b);
    v.push("String");
}

and I get:

error[E0283]: type annotations required: cannot resolve `_: alloc_wg::alloc::BuildAllocRef`
   --> src/lib.rs:186:13
    |
186 |     let v = alloc_wg::vec::Vec::new_in(&b);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: required by `alloc_wg::vec::Vec::<T, B>::new_in`

This applies to all constructors of Vec type (and String type I am working on).

I can get around that by specifying:

let v: Vec<_, &Bump> = alloc_wg::vec::Vec::new_in(&b);

But it's annoying to do it everywhere. Is it possible to have inferred?

[95th]

You can try it out using https://github.com/95th/bumpalo

[95th]

I think in the below code (and other places), we should accept B instead of B::Ref since we're getting that in the end anyway.

    pub fn new_in(mut a: B::Ref) -> Self {
        let capacity = if mem::size_of::<T>() == 0 { !0 } else { 0 };
        Self {
            ptr: NonNull::dangling(),
            capacity,
            build_alloc: a.get_build_alloc(),
            _owned: PhantomData,
        }
    }

[95th]

But get_build_alloc is in DeallocRef and children. :(

[95th]

More reduced example:

This doesn't work:

use alloc_wg::vec::Vec;
use alloc_wg::alloc::{Global, AbortAlloc};

fn main() {
    let mut v = Vec::new_in(AbortAlloc(Global));
    v.push("String");
}

This works:

use alloc_wg::vec::Vec;
use alloc_wg::alloc::{Global, AbortAlloc};

fn main() {
    let mut v: Vec<_, AbortAlloc<Global>> = Vec::new_in(AbortAlloc(Global));
    v.push("String");
}

But weirdly, this one works too:

use alloc_wg::vec::Vec;
use alloc_wg::alloc::{Global, AbortAlloc};

fn main() {
    let mut v: Vec<_,> = Vec::new_in(AbortAlloc(Global));
    v.push("String");
}

Probably some bug in rust. It's not. It's just same as Vec<_>

[TimDiekmann]

I'm not at home atm, so I'll only do a quick response: ``` let mut v: Vec<_,> = Vec::new_in(AbortAlloc(Global)); ``` works, as it's the same as `Vec<T>` and this defaults to `Vec<T, AbortAlloc<Global>` However I'm aware of the required Annotation as `BuildAlloc` and `AllocRef` are not the same, but both are implemented for `AbortAlloc<Global>`, and I don't like it. A better API which solves this is highly welcome :)

…

On Nov 9, 2019, 17:14, at 17:14, Gurwinder Singh ***@***.***> wrote: More reduced example: This doesn't work: ``` use alloc_wg::vec::Vec; use alloc_wg::alloc::{Global, AbortAlloc}; fn main() { let mut v = Vec::new_in(AbortAlloc(Global)); v.push("String"); } ``` This works: ``` use alloc_wg::vec::Vec; use alloc_wg::alloc::{Global, AbortAlloc}; fn main() { let mut v: Vec<_, AbortAlloc<Global>> = Vec::new_in(AbortAlloc(Global)); v.push("String"); } ``` But weirdly, this one works too: ``` use alloc_wg::vec::Vec; use alloc_wg::alloc::{Global, AbortAlloc}; fn main() { let mut v: Vec<_,> = Vec::new_in(AbortAlloc(Global)); v.push("String"); } ``` Probably some bug in rust. -- You are receiving this because you are subscribed to this thread. Reply to this email directly or view it on GitHub: #5 (comment)

[TimDiekmann]

I'm currently thinking of another new and with_capacity method: fn new_with(build_alloc: B) -> Vec<T, B> and fn with_capacity_with(capacity: usize, build_alloc: B -> Vec<T, B>.

advantages:

• Inferred allocator
• You don't have to create an AllocRef yourself

downsides:

• Two new methods (or even more if we have try_with_capacity and/or (try_)with_capacity_zeroed)

It would also be possible to change B::Ref to B in constructors, you could still access the builder with another method. What do you think?

[95th]

Inference is good but then we have two kinds of methods. Is it possible to provide getter for Self::Ref in BuildAlloc rather than get_build_alloc in DeallocRef?

[95th]

Something like:

pub trait BuildAllocRef: Sized + Clone {
    type Ref: DeallocRef<BuildAlloc = Self>;

    fn get_alloc(&mut self) -> Self::Ref;
}

pub trait DeallocRef: Sized {
    type BuildAlloc: BuildAllocRef<Ref = Self>;

    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: NonZeroLayout);
}

[95th]

Please take a look at https://github.com/95th/alloc-wg

[95th]

Then this works:

fn main() {
    let a = AbortAlloc(Global);
    let mut v = Vec::new_in(a);
    v.push(100);
}

[TimDiekmann]

I think this is the best solution possible 🙂

[95th]

Awesome. Thanks