I don't know the exact rules, but in general:
fn foo(bar: &x) -> &y
fn foo<'a>(bar: &'a x) -> &'a y fn foo(bar: &x) -> &y
fn foo<'a>(bar: &'a x) -> &'a yThis pretty much sums it up for me. You need to know so many rules... you need to know what those symbols mean... when people refer to Perl's syntax that they frown upon, they are referring to this: heavy use of symbols whose meanings must be memorized. I cannot just look at the code and understand it as I can with say, Ada. Pretty frustrating. I do not have to learn Ada to know what the code does. Funny that. :D At times Rust code looks very similar to Perl and Haskell. Especially Perl.
Forget the rules and don't write a lifetime where you needed one? You get this:
error[E0106]: missing lifetime specifier
--> src/lib.rs:1:29
|
1 | fn foo(x: &i32, y: &i32) -> &i32 {
| ---- ---- ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
|
1 | fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
| ^^^^ ^^^^^^^ ^^^^^^^ ^^^
Now, it's not an AI; this may not be the signature you wanted, exactly, but the point is, you don't need to memorize the elision rules. You just don't write any lifetimes until the compiler makes you deal with it, and then you deal with your problem, and move on with life.
"There comes a time when words are more appropriate than symbols."
I find Ada very hard to read. ... come to think of it, doesn’t it also have unbalanced apostrophes? It’s been a while.
> unbalanced apostrophes?
What are you referring to exactly? Can you give me an example? Do you mean something like Integer'Last, which is the largest value of type Integer?
> The concept of attributes is pretty unique to Ada. Attributes allow you to get - and sometimes set - information about objects or other language entities such as types. A good example is the Size attribute. It describes the size of an object or a type in bits:
type Byte is range -128 .. 127; -- The range fits into 8 bits but the compiler is still free to choose.
for Byte'Size use 8; -- Forces the compiler to use 8 bits.
Of course one of the best things I love about Ada is pre- and post-conditions or contract-based programming (that are actually checked, unless in languages like Kotlin that just bolted on some contracts that are just there for the reader, i.e. pretty useless, to be honest). Ranged types are awesome, too, as you tell the compiler the range you want and the compiler chooses an appropriate sized integer to suit the range, which is the important bit. For example, instead of asking for "16-bit signed integer", you say: "I want a type which can store values between -1 and 1000", and maybe even a hint for the compiler where you can ask the compiler to pick you a faster type or a smaller type, so you say:
type Index is range -1 .. 1000;
See more at https://learn.adacore.com/courses/intro-to-ada/chapters/stro....
---
https://www.adaic.org/learn/materials/intro/part1/
https://www.adaic.org/resources/add_content/docs/craft/html/...
https://www.adaic.org/advantages/features-benefits/
https://www.radford.edu/nokie/classes/320/designGoals.html
https://hackaday.com/2019/09/10/why-ada-is-the-language-you-...
Those links might give you some idea about the language and its goals, if you really are interested. Of course there are much more, up-to-date sources, but I think these got most of it right.
index = num(-1->1000);
I dunno how attributes would work, but man, they really are handy. It is very, very difficult to shoot yourself in the foot.
I see what you did there (but maybe you don't see it yourself :-)
PS: at least MY parentheses are balanced.
That seems unlikely, or anyone - even if they hadn't learned to program ever - would be able to read Ada. More likely that a) you've already learned enough to cover Ada by learning other programming languages or b) you assume you know what the Ada code does but are incorrect.
Let's charitably go with a) then what you're implicitly supporting is that "all languages must look and behave the same, and there's no possible benefit in a language being different enough that it requires me to learn something new".
And therefore that the lowest-common-denominator intersection of all popular languages combined is also the pinnacle of language design.
Something which seems unlikely.
Perhaps you could compare some Ada code (something from AdaCore (GNAT, GNATColl)) with the Rust equivalent.
If you don't know Ada then you don't /know/ that you understand it, you're assuming you do - and if you do that's because it looks like languages you already know. And if that's what you're saying is good about it, then what you're saying is "things I know are good". You're seeing "Ada looks familiar" and saying "Ada has good design" as if those are the same thing. You only need to look at some beginner programming discussions to see that block-structured, scoped, procedural, looped, branched, etc. features are not things people are born understanding - that you know them already and Ada has them is convenient for you.
> "What the code does is not hidden behind symbols, for example."
I looked at the Wikipedia page, it has equals, colon-equals, slash-equals, greater-than, less-than, apostrophe, parentheses, ampersand, double-quotes, equals-greater-than which seems to be an arrow not a comparison, double-dots, and of course "when" "is" "protected" etc. they're as much symbols as they are words.
> "Ada and Rust, Ada is way much easier to understand"
I'll quote Erik Naggum from an old comp.lang.lisp(?) comment: "When I work at this system up to 12 hours a day, I'm profoundly uninterested in what user interface a novice user would prefer.".