resolves #91

Added basic github action to generate a PDF and create a release. We could do some fine tuning now, for example on the generated PDF.

Current status includes:

• Dockerfile (+ build script)
• gh action to
  • build and run docker image
  • create release and upload pdf

Example of action run. Example of generated release PDF 2020-10-21-213802.

Running the actions takes between 60s - 70s.

While great overall, there are some aspects i think could be made more clearer https://cheats.rs/#custom-types

• [ ] What is the T: !Sized example with the arrow trying to show?
• [ ] Does the grey border take up space? In other word: has struct S; a size? If not: is it big?

Maybe the space within the struct (especially the padding) could be made more clearer using grey boxes within those grey borders?

I think this way we could make more clear whether the tuple (A, B, C) and the struct S { a: A, b: B, c: C} have the same size or not.

I'm not sure if this is worthy of inclusion but I've had multiple times where I forgot and had to look up if I should or shouldn't commit Cargo.lock for bins and libs.

It might be worth adding a note somewhere that mentions that Cargo.lock should be version controlled for bins and not for libs so that people can easily find the rule when they forget it. cargo new --lib adds it to the .gitignore file by default, so this may be an issue most people don't worry about, I'll leave it up to you to determine if it should be included.

In these RFCs, great details and example are given about the right way to do documentation. I’m not sure if this is worth being detailed on cheats.rs, but a link is a way as good as another to find these documents.

In particular, these RFC are way more detailed than the Reference book.

See Rust-lang Contributing.md for a proof that RFC1574 is used for std.

https://stackoverflow.com/questions/34733811/what-is-the-difference-between-iter-and-into-iter

An "Iteration" section could give an overview over:

Tasks:

• iterate over references: as_ref()
• iterate over mutable references
• iterate and consume

Traits/methods:

• trait Iterator
• trait IterMut
• producing an iterator:
  • trait IntoIterator: into_iter():
    • consumes Self
      • use reference as in for x in &y if this is not desired
    • used by for loop
  • iter() does not consume Self: defined for HashMap, Vec
• consuming an iterator:
  • trait FromIterator
  • resuming vs non-resuming iterators

I can't seem to find any information about proc macros in cheats.rs. I feel like this is a relatively important part of the rust ecosystem and it deserves a section. Particularly with syn and quote just hitting their 1.0.0 releases, it seems like a good time to bring in some documentation for them.

I'd be happy to add one myself as a PR but I don't know proc macros well yet so it will have to wait until after I take the time to properly learn them.

From Reddit:

Next to the “invisible sugar” perhaps also provide ”hardcoded magic” for traits and other stuff that “seems” like a normal library item, but cannot be reimplemented by the user in terms of other items. For example, the traits “Copy”, “Clone”, “Deref”, etc.

I've noticed that the site redesign has caused serious breakages in both the print and cached PDF output.

• The noprint class on the "Fork Me on GitHub ribbon" has no effect.
• Entire sections of the reference which I'd want to print are hidden inside <noprint> elements.
• Tab widgets which do print are not unrolled, denying access to all but their default tabs.
• Expandable explanations in the memory diagrams print collapsed.
• If I turn off noprint to access the stuff I want, bits of your diagrams show up in the top-left of page 1 in print mode. (Honestly, I'd suggest using inline SVG for those rather than abusing things like position: absolute and <table> to do illustration.)
• If I uncollapse the tab widgets the most obvious way, they overdraw the next section down.

This is how far I got to make a userscript to turn it into desired printable output before I got fed up with how seemingly ordinary tweaks caused strange breakages in the print preview, where the DOM Inspector is very crippled:

/* Stuff that got applied to things I want printed */
noprint, .noprint {
    display: block !important;
}
tabs > tab > panel {
    display: inline !important;
}
explanation { 
    display: inherit !important;
}

/* Hacks to fix 'diagram is shoved to the top-left corner of page 1' bugs 
   revealed by turning off noprint. */

#custom-types + p + datum { position: relative !important; }
#custom-types + p + datum > .hidden { position: relative !important; }

datum[style='margin-right:70px'] { position: relative !important; }
datum[style='margin-right:70px'] code { white-space: nowrap !important; }

datum.spaced[style='padding-bottom:165px'] memory-entry { 
    position: relative !important; 
}
datum.spaced[style='padding-bottom:165px'] visual { 
    margin-right: 10em;
}

/* Stuff that shouldn't be printed but is (or would be after my tweaks) */
body > div:first-child > a.noprint:first-child { 
    /* Hide the GitHub ribbon that isn't hiding properly */
    display: none !important;
}
page-controls, #helloctrl, subtext::after, tabs.lifetimes + footnotes {
    display: none !important;
}

Overall, with the bits like the diagrams and the tab widget unrolling, it feels like I'm reverse-engineering your attempts to fight the CSS layout model instead of working with it.

In the "Strength" section of the "Hello Rust" it says:

can avoid 70% of all (memory-related) safety issues present in C / C++

This sounds like Rust can avoid 70% of memory-related issues, and can not handle 30% of memory-related issues. Maybe it should be reworded. Here is a suggestion (I'm not a native speaker): "can avoid memory-related safety issues (memory-related issues are 70% of all safety issues)"

If you look at how other sites or apps implement dark / nightly mode, you will almost never find full black backgrounds (except in "OLED dark" themes bc. OLED screens can just completely turn off pixels that are showing full black).

When toggling the dark mode on cheat.rs the background immediately caught my eye as uncommonly dark. Would you consider switching to a dark grey instead?

See also Never use Black.

As discussed in #90, it would be nice if a (Docker) PDF action ran automatically and updated the releases. The ideal solution:

• Builds the page Docker-locally via Zola (preferred), or just grabs the latest released one
• Generates a portrait(?) PDF preserving background colors but w/o user visible "corner" metadata as some browsers do
• Publishes the PDF as a new release
• Generally works without modifying the repository

I'm a bit new to rust and I encountered the symbol << which I wanted to know what does it mean and I didn't found it on the website. It'd be great if it was added in a proper location, with a link to here:

https://doc.rust-lang.org/stable/std/ops/trait.Shr.html

Thanks a lot for maintaining this website.

I think it would be useful to create a ePUB version of the Rust cheat sheet? That would be more readable in small screens, as in a smartphone, or tablets.

Suggested via mail:

• C-FFI chapter (e.g., Rust MVP to / from C)
• Maybe even examples showing other languages (C#, Python, Java, ...)
• repr(C), no_mangle, ...
• Rust string conversion to / from char*
• ...