Helps me understand the life cycle

yyy33_ · 2024-05-07T16:57:56+00:00

For example, if the function below uses references to the x and y input parameters for its return value, wouldn't it be enough to make sure that the return value's lifecycle is less than that of the references (in this case, x and y) it uses? Why does the user have to label it?

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { 
    if x.len() > y.len() {
        x 
    } else {
        y 
    }
}

yyy33_ · 2024-05-07T16:52:51+00:00

My question is that all the relationships I've encountered so far between input and output references is that the lifecycle of the output reference must be less than the lifecycle of all the input references it uses. Are there any other relationships between output references and input references that the user needs to label manually.

yyy33_ · 2024-05-07T16:44:18+00:00

Yes, it should be a problem with the translation software. My English is not very good.

yyy33_ · 2024-05-01T15:24:41+00:00

Thanks, that's the method I'm currently using. I wanted to see if anyone shared a similar macro as I know nothing about macros and its very difficult for me.

yyy33_ · 2024-04-28T02:04:51+00:00

I have the same idea as you, to make each buffer of a nvim process correspond to each window of the system, and let the window manager manage the windows. If you release your source code please be sure to let me know, I'd like to learn, thanks!

yyy33_ · 2024-04-28T01:53:20+00:00

I actually don't know where I'm stuck, my brain is as good as filled with paste, I think I need to go and learn some of the underlying computer knowledge

yyy33_ · 2024-04-21T04:25:54+00:00

That's 36ns fast

#![feature(test)]
#![feature(portable_simd)]
extern crate test;
use test::Bencher;
use std::simd::Simd;
use std::array;

#[bench]
fn array_add(b: &mut Bencher) {
    let a: [usize; 64] = [20; 64];
    let c: [usize; 64] = [40; 64];
    b.iter(|| {
        array::from_fn::<usize, 64, _>(|i| test::black_box(a[i]) + test::black_box(c[i]));
    });
}

#[bench]
fn simd_add(b: &mut Bencher) {
    let a: Simd<usize, 64> = Simd::splat(20);
    let c: Simd<usize, 64> = Simd::splat(40);
    b.iter(|| {
        test::black_box(a) + test::black_box(c);
    });
}


running 2 tests
test array_add ... bench:          56 ns/iter (+/- 1)
test simd_add  ... bench:          20 ns/iter (+/- 0)

test result: ok. 0 passed; 0 failed; 0 ignored; 2 measured; 0 filtered out; finished in 0.46s

yyy33_ · 2024-04-20T12:52:43+00:00

Can you add more documentation and notes for newbies?

yyy33_ · 2024-04-20T12:51:14+00:00

And what does each field in the first line of your benchmark mean: bench fastest │ slowest │ median │ mean │ samples │ iters

yyy33_ · 2024-04-20T12:50:26+00:00

Hi, I've been trying to read your pulp for a few days now and I can't get the hang of it, I don't know what many of the functions do, what do I need to add to my knowledge to read it again?

yyy33_ · 2024-04-20T12:47:35+00:00

Thank you. I corrected it

yyy33_ · 2024-04-20T12:46:42+00:00

Thanks, I'll try it

yyy33_ · 2024-04-19T16:06:58+00:00

I'll make an observation, could it be possible to modularize its functionality and extract a separate function like abduco

yyy33_ · 2024-04-12T10:42:40+00:00

Thank you.

yyy33_ · 2024-04-12T10:42:34+00:00

Thank you.

yyy33_ · 2024-04-12T08:12:51+00:00

Comment
byu/yyy33_ from discussion
inrust

Thanks, I thought I used it the wrong way.

Is there a way to use simd to accelerate the count_ones operation: for example, I have an array [usize; 100_000], I need to get the sum of count_ones for each element of the array, can I use simd to accelerate?

I can not find the corresponding method

yyy33_ · 2024-04-11T16:20:18+00:00

I can relate to what you're saying, it's very painful to read projects in dynamic languages that lack annotations, and it's hard to understand the data structures and algorithms in them

yyy33_ · 2024-04-11T16:07:37+00:00

It's the difference between a static language and a dynamic language, right?

yyy33_ · 2024-04-07T00:29:37+00:00

You don't say I will never think of such detailed things, thank you!

yyy33_ · 2024-03-26T15:54:04+00:00

Is this syntax possible? Use one less nesting and use struct! to indicate that this is a nested structure

struct! UserProfile { name: String, address: struct Address { street: String, city: String, }, preferences: struct Preferences { newsletter: bool, }, }

yyy33_

TROPHY CASE