.gimme()

[killercup]

As it has been prophesied before

[timglabisch]

after thinking a while about this issue,
from my point of view it sounds reasonable.

the alternative would be a separate crate (gimme?) that makes use of the awesome yolo crate to implement the awesome gimme crate? this would also allow similar implementation_s_ for fuckit without breaking the open-closed principle.

as - you know - this project is too important to rush this decision, we should vote about this topic using meme's. ping @mre

[timglabisch]

[mre]

Come to think of it, there should also be

• whatever()
• fml()
• justdoit()
• harmless()
• lol()

[slde-flash]

we should also consider implementing:

• please()
• make_it_happen()

from my point of view it think the smartest way to implement the gimme function would be a crate that use the please crate that use the make_it_happen crate that use the whatever crate that use the fml crate that use the justdoit crate that use the harmless crate that use the lol create that use the fuckit crate that use the yolo crate.

what do you think @killercup ?

[killercup]

Come to think of it, there should also be […]

we should also consider implementing: […]

Sounds good. Obviously, all these methods need to have their own, customised panic messages.

from my point of view [yada yada yada] use the yolo crate.

That sounds about right. Here's a small chart to better visualise the dependencies:

[slde-flash]

just to make sure that i understand the graph correctly

circles = unsafe code
yellow = panics
orange = other panics

here is a good read about all the gc stuff i need for the implementation: http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/

[killercup]

that i understand the graph correctly

Yes, that's basically it. Also, for performance purposes, the length of the connecting lines shows which bit flip operations are necessary in x86 assembler and the degree of rotation between the connection ends (the tilt of the arrows and small circles) depicts the order in which to apply them to non-ECC memory.

We are doing systems programming, after all.