Bjarne Stroustrup's "A Tour of C++" (http://www.stroustrup.com/Tour.html) is close. It's a slim volume that is roughly a survey of the language as if it had begun with C++11.
You make them yourself. With Rust you might not need those things as much, because you roll these things yourself.
What are the GUI frameworks in other languages? Qt? wxWidgets? GTK? These are all so, so, so bad.
I'm saying this as I'm writing my own GPU-rendered immediate-mode GUI toolkit with multiple rendering backends. I can't do this in any other language, like...I would legit get stuck on the build systems. You are right, it would be better if there were somewhat better frameworks but I'm ok writing my own.
As an aside, my long term dream is to write a next-gen OS in Rust. GPU-first, new application paradigms, compiler comes with the OS, first-class networking support.
The languages empowers you to an insane degree.
What Windows/macOS systems programming would you want?
No I don't, I rather be productive doing what I am supposed to do in first place.
Some examples, DriverKit, COM/UWP, WinUI, Metal Shaders, CUDA, SYSCL, Treble, Unreal/Unity.
For all of those I already have a good mix of Swift, .NET, Java/Kotlin and C++, as they are the official OS SDK languages, writing in Rust would just slow me down in its present state.
Bad UI toolkits?! Best that Rust currently has is Gtk-rs and that is being nice versus what those toolkits and GUI tooling are capable of.
> Gtk-rs
GTK is terrible, Gtk-rs is putting a lipstick on a pig. I need 2D rendering but also power to touch the gpu to write a shader, to use gl_VertexID when I feel like it.
The thing about rust is that that I can legit write my own bindings for any lib written in c/c++, anything else.
Like you go from zero to dependency included, building in less than 10sec. The build process is insane.
Check out this port of nanovg https://github.com/sunli829/nvg. NanoVG is a popular project with many contributors, this port is a single person project that's better in many ways.
You go from git clone to drawing something interesting to screen in 10 seconds of human time (there might be some time spent building dependencies but whatever, I don't need to touch anything).
All those projects are toy examples, barely with any usable code on them.
As for compile speeds, I very much doubt it takes 10 seconds, given the current state of being forced to compile the world from scratch without any support for binary libraries and the continuous posts regarding compiler slowness.
If I want to draw a SVG, I just drop it into my application, no need to compile anything.
There is the Klabnik one from NoStarch and the Blandy one from O'Reilly. The first one is more towards beginners, the second one is pretty advanced, you build some relatively advanced things. I own both.
Part of the appeal of Rust is that there aren't as many bad parts as with C++.
Does anyone know anything like this, but for an indentation-based language? Writing a Python-like parser was always hard for me, ending up with a generic INDENT/DEDENT counter mess.
You need to use the "lexer trick". While lexing your input data, instead of ignoring whitespace or producing token WS or TAB or whatever, keep track of your indents and newlines. Then it's simple to decide if it's an indent (newline followed by at least 1 more space or tab than previous, add this to your indents stack) or dedent (newline followed by the previous indent (look at your indent stack)). Then produce INDENT and DEDENT seperate tokens. Once you have these tokens produced by tokenizer, it's easy to parse. Do the usual recursive descent. Source: I built my own python compiler (python->C++) as a university projects.
Pretty much this. You need a stack because an single NEWLINE might result in 2 DEDENT tokens:
if x:
if y:
f()
g()
You only need to keep track of whitespace (spaces and/or tabs) after a newline (and you can skip lines with only whitespace & comments). It's also useful to keep tracks of delimiters (like parentheses and brackets), if you want to ignore newlines/indents inside expressions (like Python).
The easiest IMO is writing a lexer using a lexer generator (Lex, Flex, ...) and outputting a NEWLINE(spaces) tokens, then have another class that keeps track of indents, parentheses, etc.
I wrote a lexer/parser combo that (1) tracks whitespace in top (file) context, (2) ignores whitespace in expressions (parentheses, [] arrays, {} records), except (3) restarts indentation-tracking in {} blocks (even if they're in parentheses themselves!) - now that's hard to code (and debug LOL).
The trick used by some parsec parsers is interesting. Instead of trying to keep track of balanced indents and unindents, they just check the intent of the first token of a statement. If it's not the "right" indent, the parse fails. When that happens, it usually ends the current block and tries again with the next indent level. It's not that inefficient because the backtracking happens on the first token of the statement.
Edward Kmett has a talk about parsing with monoids [0]. Somehow that seems an elegant way of doing layout based syntax. I have never done it myself, though.
I wrote a simple excel formula parser a while ago, and I used a counter too -- just for parentheses. Your comment made me realize I might have been going about it the hard way.
