If I have a structure, pass an instance of it to a function, is there a macro to destructure it into its named elements with a series of let assignments? For example, (struct abc (a b c)). An instance of that passed to a function, gets destructured so I can access let local names a, b and c? I’ve got very long names and that would help the readability of the code rather than the usual structure element dereferencing way.

Use match or match-define to destructure (match (abc 1 2 3) [(abc a b c) (list a b c)])

So to automatically do that where I could take any structure, not have to name the individual elements to assign to, that’s a macro I would have to write. In other words, automatic introspection of the structure passed in, macro generates the let local names and I just use them.

@steveh2009 Maybe you’d like: https://docs.racket-lang.org/struct-define/index.html

That’s it. Thanks!

So, having done http://pasterack.org/pastes/31923 yesterday, I can now convert a data structure in the source code into a srcloc-annotated version of that structure. I’ve played with it a bit, and it’s nice to get good errors, but the data structure is also hard to use when you’re trying to manipulate the expr. Destructuring binds all over the place to pull the structs apart, match patterns are cluttered…

Is there a Racket facility I don’t know of that would help with this? If I could have a pony, I’d have expressions that look and feel like plain old strings, lists, numbers… But with an additional magic accessor that lets me pull out the source location I stashed away. Is there… something shaped like that?

or am I stuck with a choice between good errors or easy data manipulation, pick one?

(or go deeper into the language rabbit hole and reimplement all the basic toolkit of map/fold/etc. but on this whacky datatype)

This destructuring - is this during parsing? Or afterwards when you need to use the annotated version?

Afterwards. When you’re writing this code, you’re defining some structured data, and then manipulating it in various ways. Ideally, basic manipulation tools like map or fold would keep working, in addition to custom functions I’m writing.

And they kinda do - except the altered shape of data means you have to add a bunch of boilerplate everywhere to get back to “that expr that was in the source code”

Nothing comes to mind. Except for writing some helper functions to manipulate the source locations.

yeah, barring language features I don’t know about, my only idea was to add a few macros to make the constant destructuring/restructuring a bit easier on the eyes

Maybe what SteveH was looking for? https://docs.racket-lang.org/struct-define/index.html

yeah, quite possibly that’s good enough. I’ll write some code and see how it comes out. Thanks!

@dave Sounds like a lens-y problem

ooh, another thing I know nothing about! Awesome, I’m off to do some reading.

@dave Disclaimer: I wrote a lens library, so my suggestion might be biased :p https://github.com/jackfirth/lens

hah. Reading the intro now. I can see the potential, although possibly a catch is that the setters might be tricky. A lens getter for “give me just the expression” makes a lot of sense, but when setting or updating, you really want to be able to provide a new srcloc as well. I’m not quite sure how I’d set that up elegantly yet.

but, I still have a bunch of reading to do.

Good luck :)