destructuring records in defs · beginners

Finally, destructuring can be used in defs too:

{ x, y } = { x: 5, y: 10 }

Brendan Hansknecht (Feb 25 2022 at 16:26):

record = { x: 5, y: 10}
x = record.x
y = record.y

Emi (Feb 25 2022 at 16:28):

disclaimer: i'm inexperienced with roc, so i'm explaining this as it works in other languages, unaware of nuance that Roc might have

some_rec = { x: 5, y: 10}
x = some_rec.x
y = some_rec.y

normally you wouldn't use it with a record you just created, because you already know what the values of all the fields are, but you might use it with, for example, an argument from a function. for example:

Person : { first_name : Str, last_name : Str, honorific : Str }

greet : Person -> Str
greet = \person ->
    let {first_name, last_name, honorific} = person
    "Hello \(honorific) \(last_name)"

Loric Brevet (Feb 25 2022 at 16:28):

Oh that means it brings x and y in scope? Or maybe the root scope is a record behind the scenes, and this adds x and y to this "root" record?

Emi (Feb 25 2022 at 16:28):

im pretty sure i brutalized the roc syntax there, but hopefully you get what i mean

Emi (Feb 25 2022 at 16:28):

Brendan Hansknecht (Feb 25 2022 at 16:30):

Person : { first_name : Str, last_name : Str, honorific : Str }

greet : Person -> Str
greet = \{first_name, last_name, honorific} ->
    "Hello \(honorific) \(last_name)"

Emi (Feb 25 2022 at 16:30):

if i understand what you're saying, i think it's much simpler than that. it declares a completely new x and y variables in the local scope and copies the values from the struct into them.

Loric Brevet (Feb 25 2022 at 16:32):

Ok, what bothered me was the syntax being similar to a record. It is weird in this example that something that looks like a record: {x , y} end up in two local variables x and y. At least it is not really intuitive! Thanks for the explanation. I think this would be a great addon to the tutorial.

Loric Brevet (Feb 25 2022 at 16:34):

If I rephrase what it does: it extracts fields from a record into dedicated variables

Brendan Hansknecht (Feb 25 2022 at 16:36):

Yeah, definitely can look weird when directly used. I think it looks a lot more natural in function arguments or pattern matching

Loric Brevet (Feb 25 2022 at 16:38):

Yes, at the first glance, your latest example with greet seems more common effectively!

Loric Brevet (Feb 25 2022 at 16:40):

And so in that function example, does it mean that behind the scenes, the compiler also extracts from a record to local variables and brings them into scope for the function?

Brendan Hansknecht (Feb 25 2022 at 16:41):

Loric Brevet (Feb 25 2022 at 16:43):

Oliver (Jan 29 2024 at 23:15):

Hey I just came across this, and it would be nice if the tutorial included that destructuring and dbg do not work when implementet top-level, they need to be put into functions.

Brendan Hansknecht (Jan 29 2024 at 23:23):

Probably we should just have a good error message for it. Then when it is inevitably tried, users will get an explanation of why it can't compile: I see you tried to use "dbg" at the top level. dbg needs to be ...

Brendan Hansknecht (Jan 29 2024 at 23:24):

That also avoids bloating the tutorial with unnecessary detail/things that can't be done.

Richard Feldman (Jan 30 2024 at 00:01):

also in the future dbg can work at the top level, just not until we get compile-time evaluation of constants working :big_smile:

Brendan Hansknecht (Jan 30 2024 at 00:02):

hmm. How would it work though? When would it actually run? Print at compile time?

Richard Feldman (Jan 30 2024 at 00:26):

Richard Feldman (Jan 30 2024 at 00:27):

Oliver (Jan 30 2024 at 08:11):

Hey thanks for the feedback. The errors are fairly descriptive for dbg but the destructing returns a rust kernel panic.

Oliver (Jan 30 2024 at 08:13):

Brendan Hansknecht (Jan 30 2024 at 16:09):