defer and errdefer | Zig Programming Language | Page 1

midnight pollen Jul 5, 2023, 9:35 AM

#

Hello, Noob Zig user here.
I just learned about defer and errdefer, and I have some questions:
So defer means "run this in the end" and errdefer means "run this if you return an error", so my questions are, can I have both defer and errdefer in a function and, if yes, do they execute in some sort of order or what happens?

eternal basin Jul 5, 2023, 9:37 AM

#

errdefer and defer execute starting from the latest one, to the earliest one

#

so e.g., a defer at the beginning of the scope will run last, and the defer in the last bit of the scope will run first

#

it's kind of like how RAII works

#

just more general

#

and not tied to types

#

also, yes

#

you can both defer and errdefer

#

there's no restrictions on how you can use them

midnight pollen Jul 5, 2023, 9:38 AM

#

So if I do

defer stdout.print("A", .{});
defer stdout.print("B", .{});
errdefer stdout.print("C", .{});
defer stdout.print("D", .{});

and i return a error, the output would be DCBA?

#

or CDBA?

eternal basin Jul 5, 2023, 9:38 AM

#

without an error, that would be DBA, and with an error, that would be DCBA, yes

midnight pollen Jul 5, 2023, 9:39 AM

#

okay, so they weight the same

eternal basin Jul 5, 2023, 9:39 AM

#

yeah

#

you can think of errdefer as being defer if (there_is_an_error) expr;

midnight pollen Jul 5, 2023, 9:39 AM

#

I kknow this is silly, but can I do a return in a defer or errdefer?

eternal basin Jul 5, 2023, 9:40 AM

#

no

midnight pollen Jul 5, 2023, 9:40 AM

#

figured, just checking >P

eternal basin Jul 5, 2023, 9:40 AM

#

they run after the return

#

so e.g.,

var result: u32 = 0;
defer result += 1;
return result;

should return 0

#

because the deferred expression result += 1 runs after the return, not before

midnight pollen Jul 5, 2023, 9:41 AM

#

hmmmmmmm

#

but

eternal basin Jul 5, 2023, 9:41 AM

#

so it wouldn't make a lot of sense to be able to return afterwards

midnight pollen Jul 5, 2023, 9:41 AM

#

there is no stack unwind yet

#

so why wont that change the return value?

eternal basin Jul 5, 2023, 9:41 AM

#

what do you mean?

midnight pollen Jul 5, 2023, 9:41 AM

#

lets say you are in a function

#

and you make a variable in that function, assign a value to it, and then return

#

when you create the variable, it gets pushed in the stack

#

and when you return from the function, stack unwinding happens, and the stack pointer is moved

#

so effectivly the variable is no longer there

#

if you can still reference the variable in the defer, why wont it change the return value?

#

since you are returning that variable

eternal basin Jul 5, 2023, 9:43 AM

#

I imagine in terms of implementation details, it just does

const return_value = expr;
run_defers();
return return_value;

midnight pollen Jul 5, 2023, 9:43 AM

#

must be something like that yeah, but that could have weird behaviour

eternal basin Jul 5, 2023, 9:43 AM

#

not really

midnight pollen Jul 5, 2023, 9:44 AM

#

what if the thing you are returning cant be copied/moved

eternal basin Jul 5, 2023, 9:44 AM

#

I mean, if the thing you want to initialised can't be copied or moved, then initialising with a return statement is the wrong thing to do in the first place

#

even without any defers, there's not a way to directly refer to the result location of a function call through a return

#

so self-referential structs and the like have to be initialised via out-parameter

midnight pollen Jul 5, 2023, 9:45 AM

#

still is weird since you are refering the variable in the defer, so you should be able to... mess with the variable, before you return

#

I would expect the return to be 1 in your example

eternal basin Jul 5, 2023, 9:46 AM

#

I disagree

midnight pollen Jul 5, 2023, 9:46 AM

#

also, defer is sold as a "cleanup code that runs in the end of the function"

eternal basin Jul 5, 2023, 9:46 AM

#

it is

#

it is designed the way it is to accommodate the clean up patterns in zig

#

e.g.

var string = std.ArrayList(u8).init(allocator);
defer string.deinit();

// append, resize, and so on

return try string.toOwnedSlice(); // <- this moves the allocation out of the arraylist, making the `defer string.deinit()` a noop

#

if the defer string.deinit() ran before the return statement here, it would cause a UAF

#

or a double free, depending on the allocator behaviour

#

either way, it would be messy

midnight pollen Jul 5, 2023, 9:48 AM

#

hold up I think i figured it out with it wont work

eternal basin Jul 5, 2023, 9:48 AM

#

and severely worsen many APIs

midnight pollen Jul 5, 2023, 9:48 AM

#

could it be because

#

the thing you are returning isnt the actual thing you are returning

#

since its a union

eternal basin Jul 5, 2023, 9:49 AM

#

no, it's equally a copy without it being a union

midnight pollen Jul 5, 2023, 9:49 AM

#

Im guessing that the return statement copies the thing to a union or something that can either be a error type or return type

#

it would make sense why the defer foo += 1; wouldnt change the value THAT WOULD BE RETURNED because it was changing the variable, but the value in te variable would already be copied to this thing that can either be a error or a value

#

kinda like what you told above

eternal basin Jul 5, 2023, 9:51 AM

#

it doesn't have anything to do with it being a union

#

it's just copied because that's how return works

#

it doesn't return a stable memory addressed thing

midnight pollen Jul 5, 2023, 9:52 AM

#

still i think that can be weird... like what if its a very huge object

#

it cant copy

#

it must move

#

but moving means it would be UB to change the variable value

eternal basin Jul 5, 2023, 9:52 AM

#

if it's huge, you probably shouldn't have it on the stack to begin with

midnight pollen Jul 5, 2023, 9:52 AM

#

well but thats a me concern, not a language concern

eternal basin Jul 5, 2023, 9:52 AM

#

there just aren't complex move semantics in zig

#

there are already complex issues surrounding this topic

midnight pollen Jul 5, 2023, 9:53 AM

#

i come from c++ and over there you can do pretty insane move stuff

eternal basin Jul 5, 2023, 9:53 AM

#

most of that isn't to do with huge structs, and more to do with ownership semantics

#

see
https://github.com/ziglang/zig/issues/7769

midnight pollen Jul 5, 2023, 9:54 AM

#

this is why I think that, if the return does behave like you explained, it could have some issues

#

expecially since they say we can use stuff from C++ in Zig

eternal basin Jul 5, 2023, 9:54 AM

#

nobody has said that

midnight pollen Jul 5, 2023, 9:54 AM

#

the creator did, in some talk

eternal basin Jul 5, 2023, 9:55 AM

#

you've probably misunderstood

midnight pollen Jul 5, 2023, 9:55 AM

#

that we can use C includes and C++ includes in zig

eternal basin Jul 5, 2023, 9:55 AM

#

no, you can use C includes in zig with translate-c

#

and if there are C bindings for a C++ library, or your make C bindings yourself for a C++ library, then you can use the C++ library

eternal basin Jul 5, 2023, 9:56 AM

#

eternal basin see <https://github.com/ziglang/zig/issues/7769>

by the way, I actually do recommend actually reading up on the issue and broader conversation linked by it if you actually want to understand design rationale and current proposals intended to solve current design issues

midnight pollen Jul 5, 2023, 9:57 AM

#

will do

#

btw, is zig oop?

eternal basin Jul 5, 2023, 9:57 AM

#

no

midnight pollen Jul 5, 2023, 9:57 AM

#

ahh, i see

eternal basin Jul 5, 2023, 9:57 AM

#

zig is imperative, and maybe data oriented

midnight pollen Jul 5, 2023, 9:57 AM

#

so it really is just a modern C?

eternal basin Jul 5, 2023, 9:57 AM

#

that is all it is marketed as, yes

midnight pollen Jul 5, 2023, 9:57 AM

#

ok ok

eternal basin Jul 5, 2023, 9:58 AM

#

at any rate, to respond to the idea of it being problematic in the case of huge structs: if your struct is huge enough that copying it would cause stack overflow, having it on the stack in the first place is already going to cause you problems without copying it

#

so the solution to having a huge struct on the stack is to not have it on the stack in the first place

midnight pollen Jul 5, 2023, 9:58 AM

#

Yeah, I was just trying to see how that would behave with the C++ functionality

eternal basin Jul 5, 2023, 9:58 AM

#

there is no builtin C++ functionality

midnight pollen Jul 5, 2023, 9:59 AM

#

but even then

#

I maybe dont want to copy

eternal basin Jul 5, 2023, 9:59 AM

#

then don't

midnight pollen Jul 5, 2023, 9:59 AM

#

I think that Zig should consider that

eternal basin Jul 5, 2023, 9:59 AM

#

use an out pointer

midnight pollen Jul 5, 2023, 9:59 AM

#

well I mean, I might not want to copy more then the thing I rwrite in code

eternal basin Jul 5, 2023, 9:59 AM

#

midnight pollen I think that Zig should consider that

it is considering that, and there's a wealth of conversation on the topic in issues and proposals

#

and it turns out it isn't that simple

#

Like I said

#

if you really want a huge ass struct on the stack and don't want to heap allocate it

#

only refer to it by pointer, and initialise it through an output pointer

midnight pollen Jul 5, 2023, 10:00 AM

#

It could be a small struct

#

I was talking about, the code doing what I write it to do

eternal basin Jul 5, 2023, 10:00 AM

#

it does do what you write it to do

midnight pollen Jul 5, 2023, 10:01 AM

#

well, yes, but more

eternal basin Jul 5, 2023, 10:01 AM

#

it can't be "more"

#

those are just the semantics of the code, and it is what everyone currently using zig expects it to do

#

your way is less useful, and breaks common patterns already in use

midnight pollen Jul 5, 2023, 10:03 AM

#

I'm talking about the thing you told, that is, you want to return a variable, it copies that variable (at the return point) to another place, and if you reference the variable in a defer or errdefer (i assume), it will reference your original variable, and any changes made to it wont affect what is being returned)

#

meaning, if there is something you want to do on the variable before you return it, regardless of the place in code, you must have code before each return stament

#

because you wont be able to use that in the defer or errdefer

eternal basin Jul 5, 2023, 10:04 AM

#

there are no patterns in zig that really necessitate that

#

if you want the result in my example to always be at least 1, just make it equal to 1 on initialisation

#

no defer shenanigans needed that way

#

if you want to assert that the result meets certain condition, you can still do that, since that doesn't require modification at all

#

zig doesn't do things just because you want to be able to do so

#

it serves specific, useful use cases

midnight pollen Jul 5, 2023, 10:06 AM

#

okay this is silly but let's say that you wanted something like this:

fn foo(....) {
  var n: i16;
  defer n = if(n % 2) 1234 else 4321;
  // mess with n
  return n;
}

eternal basin Jul 5, 2023, 10:07 AM

#

that doesn't seem useful at all

#

and in this example, you can just but it before the single return statement

midnight pollen Jul 5, 2023, 10:07 AM

#

eternal basin and in this example, you can just but it before the single return statement

that is my point

#

if I had several return locations

#

I would need to do that in every on of them

eternal basin Jul 5, 2023, 10:07 AM

#

if you happen to have multiple return statements, you can abstract it into a function

midnight pollen Jul 5, 2023, 10:07 AM

#

and I though the point of defer was to avoid that

eternal basin Jul 5, 2023, 10:07 AM

#

the point of defer is to simplify cleanup code

#

which its current semantics do perfectly

midnight pollen Jul 5, 2023, 10:08 AM

#

So I should use it exclusivly to clean resusrces used by the function?

#

Not to run arbitrary code in the end?

eternal basin Jul 5, 2023, 10:09 AM

#

it can be used for other purposes, e.g. errdefer |err| assert(diagnostic_ptr == null or diagnostic_ptr.?.err == err);

#

but it was never designed to run arbitrary code at the end for modifying your return value

midnight pollen Jul 5, 2023, 10:10 AM

#

I see, is a compiler error generated if I do it?

eternal basin Jul 5, 2023, 10:10 AM

#

midnight pollen okay this is silly but let's say that you wanted something like this: ```c fn f...

here's a counter point: what if you only want some return sites to have this behaviour? then you have to modify all your return sites to a different approach, to be able to both do the defer behaviour, plus the behaviour of the new return site

#

refactoring that would take longer than just having used something like return transformIntoReturn(result); at every call site to begin with

eternal basin Jul 5, 2023, 10:11 AM

#

midnight pollen I see, is a compiler error generated if I do it?

no, you can still do whatever you want in defers and errdefers

#

zig doesn't have a language-level concept of resources

#

it's all encoded in the patterns we use

midnight pollen Jul 5, 2023, 10:11 AM

#

I see

eternal basin Jul 5, 2023, 10:12 AM

#

a compiler doesn't recognise if a defer is a cleanup procedure or an assertion or just a variable modification

#

and modifying variables can actually be a part of a cleanup procedure

#

e.g., hashmap.deinit() deallocates the hash map, and invalidates the value (sets it to undefined)

midnight pollen Jul 5, 2023, 10:12 AM

#

some variables, sure, but the one we return it has no effect

eternal basin Jul 5, 2023, 10:13 AM

#

the compiler doesn't know that

#

so isssuing a compile error for that would inevitably create false positives

#

anyway, this thread has gone on long enough. I highly recommend you read up on the topic

midnight pollen Jul 5, 2023, 10:14 AM

#

Okay, I will read what you shared with me so far, thank you for replying :)

#defer and errdefer