Coming up!

so true

If you ever had any problems in your code with dangling pointers you don't miss 'em. I'll stay happy with the little Box and be even happier I never have to deal with that mess. What you won't use in this is the List enum because linked lists are hot garbage and there is absolutely zero use case except for some kludge-y recursive algorithms. Using Box with Vec is however the best way to use it. We all have growable Vec's that we need to pass between bits of code by reference. I think linked list information really should be included in another topic specifically on recursion where it is most likely to be used, because for the rest of the programming you ever do you just won't care about it or use it.

this comment actually made me very happy, thanks!

it's not an old school linked list. linked list consists of a accessory struct and nodes, whereas each node points to the next one. in a cons list, each list points to another or no list

@@dagoberttrump9290 a cons list points to another cons list or no list. so exactly like a classical linked list... (obviously a node points at another node, but structurally another node is just the start of another linked list). i think its just semantics at this point.

Option perhaps.

Here "to bring a type into scope" means bringing the variants of enums into main scope. i.e. you can write it like: "Variant" instead of "Enum::Variant"

@@dulanchampa Thanks!

Well you could define a little helper function like this: fn cons(i: i32, list: List) -> List { List::Cons(i, Box::new(list)) } and then construct the list like this: let list = cons(1, cons(2, cons(3, Nil)));

You could also define a helper function that adds one layer, like: fn prepend(l: List, value: i32) -> List { Cons(value, Box::new(l)) } let mut l = Nil; l = prepend(l, 5); l = prepend(l, 7);

It doesn't always need extra space. For example, if you call std::mem::size_of::() it returns 8. The compiler uses null pointer optimization and uses 0 to represent the 'None' option and any other value to represent the 'Some' option so a tag field isn't needed. It can't do this with eg. Option because all values of u64 are valid, so the size is 16 bytes (8 bytes for u64, 1 byte for tag, and 7 bytes padding for alignment). It can do it for pointer-like types (eg. &T, &mut T, Box, function pointers) and numerical types where 0 isn't a valid representation, eg. core::num::NonZeroU64. size_of::() == 8 size_of::() == 16

What's a union?

@@RenderingUser a datatype that only allocates space to hold one of its members. Example: union Foo { i32 x, i64 y, i128 z, } is 128 bits long The difference between rust enum and union is that at runtime the information which one is active is not available in a union and is often stored alongside in a separate field or manually kept track of by the developer.

If you have a program which runs for a long time and has lots of allocations, this is called a memory leak. Over time the entire system memory gets taken up by data which isn't accessed by anyone until the system no longer has any memory to hand out which is very bad.

Nope, you can't allocate new memory and save it on a reference, you need a box to do it

@@someon3 yeah, but why not? What is the reason?

​@@lizzienovigotbecause... That's... How it's made?

@@lizzienovigot You cannot transfer ownership with a normal reference.

@@flippert0 I know, but thats not exactly what I asked. As far as I understood the original comment "could a & reference be used instead of Box?", it referred to the Linked List example in the video, so the question is "could linked list be written in Rust using references, not Boxes". Its not immediately obvious that you need to keep ownership, so just brushing it off with "you cannot transfer ownership with a reference" does not answer the question. Maybe I dont need to transfer ownership. Maybe I do, but its not obvious.

If allocation fails, rust program just terminates with out of memory error. The program can't panic, because panic needs to drop all values and drops may allocate memory (which we don't have). To limit the number of items in the list, you need some struct that keeps track of the length, and you need the list to be a private field of the struct, so it can't be accessed by the user directly. The creation and modification of the list needs to happen through the methods of the struct, so it can enforce the maximum capacity with custom logic.

@@KohuGaly Box also has a try_new that allows you to gracefully catch allocation errors

It is. In fact, on a 64 bit architecture, a pointer (8 bytes) is larger than an i32 (4 bytes)

Tabnine I think It's an AI based tool

Github copilot wasnt available 2 years ago. TabNine was a really good AI-based suggestion tool

As illustrated by the example in the video, Box is useful when the size of the data cannot be known at compile time, but a fixed size structure is required by the compiler (as in recursive structures). Now, you could use regular references in these scenarios as well, making Box redundant, but there is a key difference: Box owns the data it points to, while regular references do not. So with references, you would need to specify lifetime parameters to make sure that the reference is valid throughout your program. Box is convenient as it handles heap allocation and deallocation automatically based on variable scopes and as it implements the Deref trait, can be used as value directly.

@@ChumX100 Thanks man! I got it when i checked again

@@ChumX100 ​ that makes sense, but if using smart pointers is more convenient option, what are the downsides compared to lifetimes? Is it a good idea to just use smart pointers and forget about explicit lifetime annotations? Rust could use it internally, with some syntax sugar, and not bother users with lifetimes, but it doesn’t… I guess because smart pointers are real structs and require additional memory allocation?

The title of the video series is "The Rust Lang Book", so he's basically going over whatever is in the book.