Hmm, I didn’t think this would be that much of an abstraction, since Racket already has been implemented in C (I wasn’t involved with the BC implementation, but I was assuming you might have been since you expressed some familiary with terms like Sheme_Object (a type used in the BC implementation))?

Either way, yeah, it makes sense that some types in Racket need to be dereferenced, and then mutated, such as ports, mutable strings, hash tables, vectors, mcons, etc, so it wouldn’t make sense if we said that no dereferencing happens either.

What I gather from all this is that the abstract “dereferencing” happens (although I wonder if this actually happens in BC?), but there are measures in place to make sure that the type information never changes, and also that functions like (define (foo x) ...) do not retain the address of whatever value was used to called it like (define (main a b c) ... (foo a) ...) , here foo does not know the location of a, but only knows the location of its own copy (by value) of a. Even though a might be a number and foo wants to set a to be another number (so, type is safe?) it cannot do so, right?

Let me know if my understanding is correct. Still not completely certain if this really is an allegory or what actually happens in BC

Sadly, I don’t think Typed Racket supports mutable sets

I think that’s right. Inside foo, (set! x 2) only changes which (racket_value *) the variable x is bound to. It doesn’t have any way to change the binding of the variable a, nor does it have any general way to read or write to the data the (racket_value *) points to. Although it has no general way, it has many specific ways to read or write certain parts of the data, using operations like mcons?, mcar, and set-mcar!.

Sorry if this metaphor suggested there were more general-purpose dereferencing operations available. I picked this hypothetical implementation technique so that the distinction you were asking about (passing by reference or not) had some plausible interpretation. If people thought about Racket variables this way, then it would form a basis of consensus for how “pass by reference” and “pass by value” features should behave if they existed in Racket… but those features don’t exist today, at least not in safe Racket code. So, since you’re trying to understand Racket in terms of this model, I should be more clear that not all the capabilities of the model show up in the capabilities of the language it implements.

I’m afraid I’ve barely even looked at the actual implementation used by Racket. This is at best a naïve approximation, and I don’t think implementations of Racket even have to resemble this technique.

Thanks for the great explanation!

PS. I like the diacritic used in “naïve” (I have no idea how to input diacritics with my US English Keyboard LOL)

lol, this time it was easier ’cause I’m on mobile and can long-press to get diacritics :-p

So I guess in the example, even though x is local to foo, if x is a mutable type (like mcons), there is actually some link maintainted to a… That is interesting indeed

I suppose so. The mutable cons cell is somewhere in memory, and the address of that memory is what’s stored in x and a . Neither variable x nor variable a carries any information about the other, but they are related by pointing to the same place. Or in Racket terms, they’re related by being two different variables that are bound to the same value.

Hello everyone! I’m looking for some help with a macro. I am stumped with all the hygienic/unhygienic distinctions and the syntax thing.

I’m trying to write a macro that creates a bunch of functions to extract the n-th item from a list, from 1 to n (just for practice). nths-1 is working fine, but it doesn’t seem right to me: I just took an Emacs Lisp macro that I would write, and added syntax->datum and datum->syntax until it worked. nths-2 is my attempt at idiomatic Racket/Scheme-style macros, but it isn’t working. The error I’m getting is: ; define: not allowed in an expression context, even though I don’t see that I’m defining anything yet, just passing the syntax. I’d be glad for any help with this! Racket macros hurt my brain! Thank you! (begin-for-syntax (define (nths-helper upto) (for/list ((n (in-range 1 (add1 upto)))) (define f (string->symbol (format "~ath" n))) `(define (,f lst) (list-ref lst ,n))))) (define-syntax (nths-1 stx) (syntax-case stx () ((_ i) (let ((fs (nths-helper (syntax->datum #'i)))) (datum->syntax #'i `(begin ,@fs)))))) (define-syntax (nths-2 stx) (syntax-case stx () ((_ i) (with-syntax ((fs (nths-helper (syntax->datum #'i)))) #'(begin fs))))) (As an aside, where can I find more macro exercises? I found <https://lexi-lambda.github.io/racket-macro-exercises/index.html|lexi-lambda’s exercises> and I’m currently stuck on part 3.)

@yuhsien77 I’m guessing you struggling with a few things (at least I did). - You mentioned hygiene. But more so, in your example: - Lisp macros work on quoted lists. Racket macros work on syntax objects. - Racket macros usually work in a pattern matching style, and you supply a template that uses some of the things you match. (You can also do a quasisyntax style, like quasiquote with Lisp macros.) When I was getting started with Racket macros I wrote this, I don’t know if you might find it helpful: https://www.greghendershott.com/fear-of-macros/all.html

Here’s how I would write it:

#lang racket (require (for-syntax racket/syntax)) (define-syntax (nths stx) (syntax-case stx () [(_ upto) #`(begin #,@(for/list ([n (in-range 1 (add1 (syntax-e #'upto)))]) (with-syntax ([the-id (format-id stx "~ath" n)]) #`(define (the-id lst) (list-ref lst #,n)))))])) (nths 10) (1th '(1 2 3))

Yeah I was going to say the quasisyntax approach might be the shortest path from Lisp macros. Although, the similarity might cause mis-assumptions? But still, that’s a great example.

@greg @sorawee Thank you for your answers! I’ve actually been going through your tutorial, Greg (thank you!), I guess it just takes time for these things to sink in.

One more thing that I want to point out is that, this is not a simple macro. It is intrinsically unhygienic (due to the use of format-id, which under the hood is datum->syntax). So the problem that you are trying to solve is fairly advanced.

I am aware of the distinction between syntax and datum, but on a theoretical level. In practical use I trip up a lot.

@sorawee Yes, as far as I understand this problem requires an unhygienic macro (since I’m creating new functions at the call site), and these are hard in Racket.

@sorawee Damn, that nested quasisyntax is so meta.

While we’re here, I have a question about syntax-case. Is it deprecated? I get the impression that syntax-parse is the way to go, and it basically provides a superset of the functionality of syntax-case.

It’s a bit dense because the one macro is trying to do two things at once, the way you’d wanted. Maybe try writing a “definer” macro that defines a single function? Then you can see that things like format-id are doing.

And when you’re comfortable, you could write a define-many-at-once macro?

@greg I did write this first:

(define-syntax (nth stx) (syntax-case stx () ((_ i) (with-syntax ((f (format-id #'i "~ath" (syntax->datum #'i)))) #'(define (f lst) (list-ref lst i))))))

Actually that’s one tip I have, when writing macros. Is be very step by step. Add one wrinkle at a time. More so than with “normal” programming. When I try to go from A to Z all at once, I often get confused.

Yeah, I definitely feel that.

My problem is, I don’t really know what macros to write. I mentioned Alexis King’s exercises above, and I’ve done the threading bits, but now I’m up to part 3 and unsure how to solve it.

I also have had zero ideas so far for macros of my own (well, one: the nths macro above). I just don’t get sudden inspirations for macros, cause I’m so used to living without them.

(Also, so many of the macro examples in various tutorials don’t even need to be macros…)

Somewhat. I personally always use syntax-parse because it’s so much nicer

But for learning, some people might find these additional features distracting

They’re optional though, aren’t they? Hidden away in kwargs.

I don’t know if this will be “too much” for you now. Also it’s particularly focused on syntax-parse, which is the most modern/shiny way of writing macros that produce good error messages among other nice things. But: https://docs.racket-lang.org/syntax-parse-example/index.html

Does the same apply to syntax-rules? I’m guessing yes

Thanks! I don’t see why I shouldn’t just jump straight into syntax-parse, if that’s what people are actually using. I already used it for the threading macro exercise, since it supports two (...)’s in one sexp, unlike syntax-case.

I don’t think it’s any more difficult to use than syntax-case, but it does appear vastly more featureful.

Oh, yes, I think good/fine to start with syntax-parse. I just didn’t know if the examples might be too esoteric or intricate, and induce mind-melt. :slightly_smiling_face:

I’m already there :slightly_smiling_face:

But you never know. Sometimes I read things I’m not quite ready for, but some of it sinks in, and later I go back.

Hehe. Can you say “monad” :wink:

I call this advanced learning technique “squinty reading”. :slightly_smiling_face:

This does remind me of learning Haskell. I know by now not to rush it, and give these things time.

I think it’s totally normal to need a lot of time for this to sink in. If someone feels they got it right away, it probably means they just don’t know what they don’t know, yet. But you can get comfortable and do some really useful/fun macrology in like, less than a decade, I promise. :slightly_smiling_face:

Haha, that’s reassuring!

Oh also, I should point out define-simple-macro. For a lot of small tasks, day-to-day boilerplate-nukers etc. that can be great. It works for things where don’t need to e.g. synthesize new identifiers using format-id, for example.

Would you recommend “On Lisp” for Racketeers? I understand it’s chock full of unhygienic macros, so might not be the best choice. It’s just that I prefer learning by doing, and I’d like to find a bunch of macro exercises to build up my understanding of them.

I only skimmed On Lisp and it was many years ago, so I don’t know. But I think things like that and Let Over Lambda are probably some mix of useful and “misleading” for Racket, both.

Ok, I’ll keep at it. Thank you @greg and @sorawee for your help!

By the way, I liked @sorawee’s example above, a lot. If you find it too twisty, one non-quasiquote way to write it could be: #lang racket/base (require (for-syntax racket/base racket/syntax) syntax/parse/define) (define-syntax-parser define-nths [(_ thru) #:with (id ...) (for/list ([n (in-range (add1 (syntax-e #'thru)))]) (format-id this-syntax "~ath" n)) #:with (n ...) (for/list ([i (in-range (add1 (syntax-e #'thru)))]) (datum->syntax this-syntax i)) #'(begin (define (id xs) (list-ref xs n)) ...)]) The #:with bits are defining some lists of pieces of syntax. (They are basically the same as using with-syntax). The ... in the template “unrolls” those. So, I mean it’s the usual trade-off with any function: Introducing some intermediate variables to name values takes more lines, but make the pieces clearer.

Having said all that I would probably write it using quasisyntax, if the future audience were mainly me, and I didn’t expect the macro to grow more complicated.

define-syntax-parser is just a way of not needing to write out (define-syntax (foo stx) (syntax-parse __). It’s an indentation remover. :slightly_smiling_face:

Let me throw in more syntax-parse features :)

#lang racket/base (require (for-syntax racket/base racket/syntax) syntax/parse/define) (define-simple-macro (define-nths thru:number) #:with (id ...) (for/list ([n (in-range (add1 (syntax-e #'thru)))]) (format-id this-syntax "~ath" n)) #:with (n ...) (for/list ([i (in-range (add1 (syntax-e #'thru)))]) (datum->syntax this-syntax i)) (begin (define (id xs) (list-ref xs n)) ...)) (define-nths 10) (1th '(1 2 3))

Oh ha ha. Now I learn that #:with works with define-simple-macro, which I never knew.

Nice! Thanks. :smile:

Initially it doesn’t work I think. Then there’s a PR to make it work.

Now I feel a little better.

Also when I’m working on Racket Mode, which is supposed to work with somewhat old Rackets, I’m often deliberately not trying to use the new shiny things.

But this may have been in there a long time and I just never noticed. Glad to know about it!

I once said (to Dan Friedman, which made it more significant) “friends don’t let friends use syntax-rules”

@greg @sorawee Very cool! I take it the #:with is from here? https://docs.racket-lang.org/syntax/stxparse-specifying.html#%28tech._pattern._directive%29

Yep

Is there a way to use ... with the quasisyntax version?

What do you mean by that? ... works inside quasisyntax, if that’s what you are asking. But if you mean something else, the answer is likely no.

This is very impressive! And more readable IMO.

I see you’re not requiring (for-syntax syntax/parse) though? If I omit it, Racket complains.

He requires syntax/parse/define instead.

syntax/parse/define automatically requires (for-syntax syntax/parse)

Oh I see!

I guess the way to write it with ... would be what @greg and yourself wrote later on. I’ll read these a few more times.