warp-server: Move handlers into proper functions

This is easier to follow, and makes it more obvious what the types are.

warp-server: Proper websocket error reporting

warp-server: Add logging

warp-server: Add echo websocket route

warp-server: Add User-Agent header filter

warp-server: Initial hello world

gtk4-hello-world: Drop unnecessary move

hyper-server: Initial version

tokio-tutorial-mini-redis: Add proper error handling

Keep unwrapping accept() and Mutex failures, these are early/unlikely enough
to be okay to crash.

tokio-tutorial-mini-redis: Add logging

tokio-tutorial-mini-redis: Show return value in client

Use an oneshot message sender to deliver the result.

tokio-tutorial-mini-redis: Add first client version

Uses message passing instead of mutexes. Does not yet send back values
from the manager.

tokio-tutorial-mini-redis: Rename to server binary

Invoke with

    cargo run --bin server

tokio-tutorial-mini-redis: Shared global state

tokio-tutorial-mini-redis: Initial protocol

Implement GET/SET, without shared state yet.

Move the original API demo as an example. Run it with

    cargo run --example hello-redis

tokio-tutorial-mini-redis: Initial demo

https://tokio.rs/tokio/tutorial/

tokio-tutorial-jbarszczewski: Implement actual balance data handling

tokio-tutorial-jbarszczewski: Add GET/POST parsing

tokio-tutorial-jbarszczewski: Handle each connection in separate task

tokio-tutorial-jbarszczewski: Initial savings balance API

tokio-tutorial-jbarszczewski: Hello world

Demonstrating async fn and inline async block

https://jbarszczewski.com/basics-of-asynchronous-rust-with-tokio

async-http: Unit test for handle_connection()

async-http: Serve requests in parallel in threads

Use async_std::task::spawn to launch a request in a thread.

Now even synchronous sleep does not block other requests, as long as
they don't exceed the thread pool capacity.

async-http: Serve requests concurrently

Move to asyncstd TCPListener and futures Stream, so that the incoming
loop does not serialize/block requests any more.

This is still single-threaded. That can be demonstrated with replacing
the async sleep with a sync one (commented out). Then /sleep will block
other requests again.

async-http: Move to async main and handler function

This does not yet handle requests concurrently. Demonstrate with adding
a /sleep path.

async-http: Fix unhandled warning

async-http: Add logging

async-http: Initial sync version

Add GTK 3 hello world

Add GTK 4 hello world

https://gtk-rs.org/gtk4-rs/stable/latest/book/introduction.html

serde: Show ≥ info logs by default

serde: Use log framework

Run with `RUST_LOG=debug` to see the serialized message.

serde: Read back from file and deserialize

serde: Use error propagation

serde: Write JSON to file

serde: Data types and initial serialization

simple-http: Implement ThreadPool cleanup

Introduce Terminate message. Test this by only accepting two requests
and then letting `pool` go out of scope.

simple-http: Implement ThreadPool messaging

simple-http: Add scaffolding for thread pool implementation

Turn into library crate. Add ThreadPool stub to src/lib.

simple-http: Naïve unlimited threads

This introduces a DoS with too many parallel requests.

simple-http: Introduce a slow path

simple-http: Parse path from request

simple-http: Check hardcoded root path, add 404 page

simple-http: Initial skeleton

concepts: Add alternative Post implementation with states as types

concepts: require two Post approvals

concepts: Add Post.reject() transition

concepts: Rewrite Post without Option

This gets rid of a lot of extra Option handling code, at the price of
having to rebuild instead of pass through non-changing states.

concepts: Dynamic trait objects

concepts: Shared memory and mutex between threads

concepts: Threads and message passing

concepts: Rewrite Cacher tests using RefCell

Avoids an external crate.

Move top-level files into concepts/

As this now contains multiple projects, it was too messy.

Call Rust function from C: Complex cases

Add three functions which take/return strings and string arrays. This
creates some interesting problems how to combine the C semantics of
returning a char** with the Rust semantics of freeing objects once they
go out of scope.

This now also relies on the Rust standard library, which needs a few
system libraries. Link them.

Call Rust function from C: Skeleton

Implement the rest of c-mounts.c in Rust

Use errno crate for human-readable error formatting.

Initial libmount function call from Rust

Follow "A little C with your Rust" [1].

Set up cargo and main.rs skeleton and call one of the simplest possible
functions from libmount: mnt_get_fstab_path().

Use bindgen [1] to translate libmount's header file into a Rust
interface. This requires a few hacks:

 - bindgen does not accept the original header right away, as it can't
   find stdarg.h. Avoid this by dropping the (unnecessary) stdio.h
   include.
 - bindgen does not know about `size_t`. Hack around that with a typedef
   for now.
 - Suppress warnings about constant/identifier naming.

[1] https://rust-lang.github.io/rust-bindgen/command-line-usage.html
[2] https://docs.rust-embedded.org/book/interoperability/c-with-rust.html

C from Rust: Reference C programs

Add .gitignore

Iterators

Consistently use into_iter() with collect()

Replace unsafe test code with global_counter

https://docs.rs/crate/global_counter

Closures and Cacher object

Add integration test

Move helper functions into src/lib.rs

This enables writing integration tests. Pure binary crates can't have
them:

https://doc.rust-lang.org/stable/book/ch11-03-test-organization.html#integration-tests-for-binary-crates

Generics and Traits

Return style fix

File reading with standard fs API

File reading and error handling using ?

File reading and simple error handling

Split into functions

HashMap

test word_utils

Vector iteration

Move word_utils to separate file

Put functions into module

References, slices, Option