Instead of creating hola-fields which exists at run-time, you can (define-syntax hola ...) to a struct containing the field information at compile-time (it probably needs to contain other information too). The struct could have prop:procedure which in this case will be the syntax transformer that generates struct creation. Looking up the field compile-time information then can be done by using syntax-local-value or static syntax class. See section 2.1 in https://www.cs.utah.edu/plt/publications/jfp12-draft-fcdf.pdf for explanations.
What’s unclear to me are: 1) How would you deal with the following? Should it be an error? (card (foo . xs)) (card foo (bar . ys)) 2) How would you determine the number of fields (and field names) in the following? > (card (line . xs)) > (line 1 2 3 4 5 6 7 8 9) Wouldn’t it make more sense to have: > (card (line . xs)) > (line '(1 2 3 4 5 6 7 8 9)) where xs is the only field. 3) Shouldn’t the following result in (ciao 7 3)? > (card (ciao a [b 3])) > (ciao 7) On Thu, Sep 16, 2021 at 2:12 PM Dimaugh Silvestris < [email protected]> wrote: > Sorry, I haven't posted the full macro because it's long and makes use of > several other functions, but I'll try to summarize what it does: > > Short summary: I'm trying to have a macro (mymacro oldname newname (fields > ...)) that accesses oldname-foo, which contains a list of symbols, and then > define a function that takes (cons oldname-foo (fields ...)) formated as > identifiers as arguments. Or at least to get the length of oldname-foo and > name them whatever. > > Full explanation: using make-struct-type I'm building a different struct > system I call cards, where structs can be defined as a function call, which > will be their constructor, and they are printed as the constructor function > call that would generate them. So, for instance, we can do: > > (card (hola a b #:c c)) > > (hola 1 2 #:c 3) > (hola 1 2 #:c 3) > or > > (card (ciao a [b 3])) > > (ciao 7) > (ciao 7) > > (ciao 7 4) > (ciao 7 4) > > or even > > > (card (line . xs)) > > (line 1 2 3 4 5 6 7 8 9) > (line 1 2 3 4 5 6 7 8 9) > > Also the names of the fields are stored in *<name-of-the-card>-fields > (this is the abc-foo of the above example), so *hola-fields contains '(a b > #:c c). > So far this is working perfectly, but I don't have inheritance. So when I > create a card that inherits from a previous card, I need to access its > *<parent-card>-fields to define a new function containing both the parent > and the son fields. That is, I'm trying to get this behavior: > > (card (hola a #:b b)) > > (card hola (ciao c)) ;;; should expand to (define (ciao a #:b b c) > ...), among other things > > (ciao 1 #:b 2 3) > (ciao 1 #:b 2 3) > > On Thu, 16 Sept 2021 at 22:35, Sorawee Porncharoenwase < > [email protected]> wrote: > >> In general, it would be helpful to provide an example of the macro use, >> so that we know what you want to do. If it doesn't work, it would be >> helpful to provide the buggy program and an error message so that we can >> help with the issue that you are encountering. >> >> From my guess, you have a variable named abc-foo somewhere, and with >> this macro, you wish to define a function named abc that can access the >> value of abc-foo? If so, here’s an example of a working program: >> >> #lang racket >> >> (require (for-syntax racket/syntax)) >> >> (define-syntax (my-macro stx) >> (syntax-case stx () >> [(_ name other-args ...) >> (with-syntax ([varname (format-id #'name "~a-foo" #'name)]) >> #'(define name >> (λ (other-args ...) >> (println (list varname other-args ...)))))])) >> >> (define abc-foo 123) >> (my-macro abc x y) >> (abc 5 6) ;=> '(123 5 6) >> >> >> >> >> >> On Thu, Sep 16, 2021 at 1:21 PM Dimaugh Silvestris < >> [email protected]> wrote: >> >>> (sorry if I'm asking too many questions about macros lately, I'm >>> learning about them but I keep running into scenarios I can't find >>> documentation for) >>> >>> I'm trying to capture the value of a variable whose identifier I can >>> only get with format-id, inside a with-syntax. >>> Something like this pseudocode (imagine name-foo contains a list of >>> symbols): >>> (define-syntax (my-macro stx) >>> (syntax-case stx () >>> ((_ name other-args ...) >>> (with-syntax* ((varname (format-id #'name "~a-foo" #'name)) >>> (varval (cons (datum->syntax #'varname) >>> (datum->syntax #'(other-args ...))))) >>> #'(define name (λ varval (print varval))))))) >>> >>> >>> Which of course doesn't work. I understand this might have to do with >>> how macros work at an earlier phase than runtime, so is it impossible? >>> >>> -- >>> You received this message because you are subscribed to the Google >>> Groups "Racket Users" group. >>> To unsubscribe from this group and stop receiving emails from it, send >>> an email to [email protected]. >>> To view this discussion on the web visit >>> https://groups.google.com/d/msgid/racket-users/CAN4YmRF%3Do3NsXOvK2fvUDeYL_jfA9r946%3D%3DguoGb_%3DKyS%3Dm%2Bxw%40mail.gmail.com >>> <https://groups.google.com/d/msgid/racket-users/CAN4YmRF%3Do3NsXOvK2fvUDeYL_jfA9r946%3D%3DguoGb_%3DKyS%3Dm%2Bxw%40mail.gmail.com?utm_medium=email&utm_source=footer> >>> . >>> >> -- You received this message because you are subscribed to the Google Groups "Racket Users" group. To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/racket-users/CADcuegvgnUpin2sMeg%3DPHRAN4gBRDx0HpUAuz8dM3aaZ8uAGvw%40mail.gmail.com.
