Zig's dot star syntax (value.*)

https://www.openmymind.net/Zig-Dot-Star-Syntax/

by todsacerdoti • 1 year ago

113 124 1 year ago

copx• 1 year ago

Tl;dr: It is just pointer dereferencing.

I.e. C's

  *ptr

  ptr.*

in Zig.

cardanome• 1 year ago

Yeah, I kept on reading to find out if there is some Zig-specific twist but it is literally just that.

Are there really that many Zig programmers that have never seen C or know what pointers are?

spacedcowboy3• 1 year ago

And why change something like that? The world would be a better place, IMHO, if there were less different ways to write something from language to language.

Sometimes it seems like the change is just to make it different, not better.

latch• 1 year ago

Author here. I agree this is a less-than captivating piece. I write a lot about Zig and wanted something I could reference from other pieces.

But, to answer your question directly: absolutely. In addition to writing a lot about it, I maintain some popular libraries and lurk in various communities. Let me assure you, beginner memory-related questions come up _all the time_. I'd break them down into three groups:

1 - Young developers who might have a bit of experience in JavaScript or python. Not sure how they're finding their way to Zig. Maybe from HN, maybe to do game development. I think some come to Zig specifically to learn this kind of stuff (I've always believed most programmers should know C. Learning Zig gets you the same fundamentals, and has a lot of QoL stuff).

2 - Hobbyist. Often python developers, often doing embedded stuff. Might be looking to write extensions in Zig (versus having to do it in C).

3 - Old programmers who have been using higher level languages for _decades_ and need a refresher. Hey, that's me!

epolanski7• 1 year ago

I know some C but I haven't touched it in a decade, but I have started playing with Zig so this was useful to me.

You aren't always the target.

dmurray• 1 year ago

It feels a bit performative to me: the article goes out of way not to explain it by giving the C equivalent.

Perhaps some day Zig will have replaced C and beginners will come to Zig having never touched C, and in that context this approach makes sense - after all, you wouldn't litter an introductory article on C with comparisons to Algol. But today, surely the modal Zig beginner already knows enough C that the syntax would better be explained by reference to C.

amjoshuamichael4• 1 year ago

Yeah I found this article super weird. Explaining pointers & dereferencing is reasonable, but doing it in the context of Zig specifically, like Zig is the first language to feature dereferencing, is odd. Especially since pointers are such a fundamental part of low-level (really, any) programming. Also not sure why it's posted here?

Edit: Going through this author's website, it seems like a lot of their posts are about rediscovering low-level programming concepts through Zig. Like this article, where they discover you can't compare strings directly, and you have to use memcmp:

https://www.openmymind.net/Switching-On-Strings-In-Zig/

They claim that they blog because they "find that [they] retain things better when I write about them." No problem with that. Just a little odd to see on the hn front page, I suppose.

wyldfire2• 1 year ago

rediscovering

I think this is just "discovering". While you (and I) probably discovered these things with assembly or C languages, it's perfectly reasonable or even appropriate for newer generations to have these kinds of experiences with Zig or Rust.

FlyingSnake6• 1 year ago

FTA: “power.* is how we dereference a pointer“

This Is basically the gist of the article.

I’m surprised to see that so many programmers these days don’t know C and basic pointers.

dazed_confused• 1 year ago

Are you honestly surprised?

epolanski7• 1 year ago

Why would you?

Large parts of the industry does really work with low(er) level languages.

Even people who went through C/C++ in their formal education/start of their career may have not used it for a long time.

xigoi2• 1 year ago

Everyone who knows pointers had to learn them at some point.

d0mine2• 1 year ago

C is not even in the top dozen most popular languages https://www.jetbrains.com/lp/devecosystem-data-playground/

timewizard• 1 year ago

So.. is a double dereference..

    ptr.*.*

?

SpaghettiCthulu• 1 year ago

Yes

cassepipe3• 1 year ago

Yes, but unlike C's terribly confusing "declaration follows usage" style, which no tells you about btw, zig's pointer syntax doesn’t turn into a nightmarish puzzle.

In Zig, you can pretty much read the types aloud and it makes, your brain does not need to peek for parsing. For me it's too late, I got used to the C way but I still want the better thing to get adopted. No more int ((foo)(int))[5]; nonsense—just T, [N]T, or *T, making intent crystal clear.

toasterlovin• 1 year ago

Yes, but unlike C's terribly confusing "declaration follows usage" style, which no tells you about btw

I happen to be reading the K&R C book right now and they do in fact tell you this.

silisili• 1 year ago

I wonder why they went that route. At this point in my career the first notation is ingrained in my head. The bottom looks like regex.

markisus• 1 year ago

Article says it’s about stack addresses but I think it should apply more generally to dynamically allocated memory as well.

loxodrome• 1 year ago

Nice explanation of zig's dereferencing operator. Thanks!

klodolph• 1 year ago

This is the way that Pascal does it, which was always more sensible than prefix notation. Pascal uses ^

skissane4• 1 year ago

In C you can use `[0]` as a postfix dereferencing operation... ugly but it works. I use it a lot in GDB. But I agree that Pascal does it better here, the dereferencing operator should have been postfix all along.

The thing I really wish C had, and which there is no straightforward workaround for, is postfix casting. When you do `((struct foo*)(COMPLEX_EXPRESSION))->field`, I think it would read a lot better if the `(struct foo*)` cast was on the same side as `->field`. Maybe something like `(COMPLEX_EXPRESSION)@(struct foo*)->field`

lostdog• 1 year ago

That is very nice. If you treat the star as a postfix operator, then even "->" is no longer needed:

   some_pointer*.field

EPWN3D• 1 year ago

You should probably just cast to an intermediary `struct foo *`. It'd be a lot more readable.

pjmlp4• 1 year ago

In a way, Zig is Modula-2 with curly brackets for folks with C background.

Yes, I know, comptime and such.

int_19h3• 1 year ago

In Pascal, it's a distinct operator from field access, though.

What this actually reminds me of is Ada, where you write `value.all` to basically the same effect as Zig's `value.*`. It's as if everything is a struct with itself as a member.

TZubiri9• 1 year ago

Probably a nitpick but

Didn't read, got bored at having pointers explained, even if actively trying to skip it.

I get a mix of: 1- you don't know your audience or are trying to cater to too wide of an audience

2- if someone doesn't know how pointers work, is there any merit in knowing syntax of a novel programming language?

So if you want the veterans to read this, you are going to have to make it less accessible.

Edit: it seems like the whole article is OP discovering pointers but zig is like his first language. Lol.

jvanderbot3• 1 year ago

That's the impression I got too.

However, thinking long term, are we going to continue to introduce pointers via C to new students? If not, then how? C++ or Zig seem viable options, so this might be a long term proposition.

Inb4 there won't be programmers

tcfhgj2• 1 year ago

Rust would be an option as well

TZubiri9• 1 year ago

It's an interesting question.

I first don't see a problem with C being a basal part of the curriculum for centuries, we are already at half a century going strong.

Second, if this were to happen, it should happen with a mature language, and decided consciously by seasoned professionals.

Third. I think more than looking at other languges we should look into other types of pointers, like files, hyperlinks, assembly addresses, inodes.

To date C is the standard for pointer-pointer syntax, introducing new standards is fine, but it only makes sense with the standard syntax.

It's the canon of programming. Long live C

sureIy• 1 year ago

I don't understand the snark. Is it not possible to write articles for beginners? There are also a lot of developers who have never dealt with memory allocation and are interested in Zig.

TZubiri9• 1 year ago

Yes it is possible to write articles for begginners, but they should be on begginner concepts.

Writing about an advanced concept catering to begginners is a mess. It's like writing about logarithmic calculus and prefacing with an explanation on exponents.

epolanski7• 1 year ago

Hey I started using Zig after a decade of JS/Elm/Haskell/php/scala, such articles are very useful to me. Haven't used lower lever languages in a long time.

You aren't always the audience, it's fine.

barrenko• 1 year ago

This is the HN caveat.

TZubiri9• 1 year ago

Makes sense, it seems like you missed languages with pointers.

I would suggest going through C. Otherwise it's like learning C++ without learning C. Zig is similarly a successor to C, (it is phonetically named after it).

That would address your blind spots and let you appreciate Zig's identity

karmakaze• 1 year ago

This is a weird (to me) way of presenting Zig syntax and operation. I would generally assume that someone coming to Zig would be familiar with C/C++ or Rust and only need to be able to map Zig syntax to things they already know.

If the author's content is all in this 'assume no C background' style, it will be useful to those without previous manual memory management background in contrast to most articles that assume a lot of context.

nikolay2• 1 year ago

Good compiler, poor syntax. I'm waiting for the TypeScript equivalent for Zig.

epolanski7• 1 year ago

Do you find it poor just because it doesn't align with your experience and bias you hold from writing other languages?

nikolay2• 1 year ago

Sometimes they just don't want to be normal, that's it. And they created a language around an easier parser, not around great DX. Too much redundant "punctuation", etc.

alpaca128• 1 year ago

Have you looked at C3? Its goals align with Zig but it’s much closer to C in terms of syntax.

xg15• 1 year ago

Didn't know anything about Zig, but the .* syntax alone was straight-forward and easy to understand, as is regular copying from one existing memory location to another.

I think what seems weird though is more the "... = .{...}" syntax.

This makes it look as if there was some kind of anonymous object ".{...}" in memory that you're copying from, but there isn't. It's actually just a writing operation and the .{...} itself doesn't represent anything.

Maybe that was also what the author found confusing?

cassepipe3• 1 year ago

I find your comment confusing. How is that not like writing an anonymous (or more precisely inferred type) struct literal into a sized memory location ?

wren6991• 1 year ago

I like this syntax. It's like saying "give me all the members of this object". Kind of like using full-slice [:] in Python to copy a list's values instead of passing by reference.

Zig's dot star syntax (value.*)

Related Stories