[racket] Splicing a variable to serve as let declarations

Hmm, perhaps this would be easier to define the problem if I were to share
the code for where this has to go.

Currently, my struct system looks like this:
https://github.com/jarcane/heresy/blob/master/lib/things.rkt

Now, as it stands this works quite well as an opaque data structure, but
they can in theory be extended into a full blown object system if we store
lambdas in one of our Things. This is at the moment kind of a useless
gesture though, it's not clear they can self-reflect from within the same
scope.

But! If we can wrap a second let around the first there, that expands our
alist into defining each field as an individual local variable, then any
function called with our regular syntax would be able to refer to the
variables of the parent function. I've tested this in toy form, and the
scoping does appear to support it.

But we need the expanding let to do it, and so far I've failed to come up
with a way, and the solutions thus far require manual operations, not
something general. The last two posts have the same 'out of context'
problem if they attempt to operate on the argument of the Thing function,
because it's not an explicit value being declared manually, but using an
existing variable in the function that we need.

Perhaps Things need to start from scratch as a full macro, but the problem
I ran into was the recursive call used for returning a Thing copy just
creates an infinite loop if done as a macro. It's fine as a function.


On Thu, Dec 11, 2014 at 10:10 PM, Alexander D. Knauth <alexander at knauth.org>
wrote:
>
> Or you don’t even need a syntax-parameter:
> #lang racket
> (require (for-syntax syntax/parse))
> (define-syntax letexpand
>  (syntax-parser
>    [(_ alst body ...)
>     (with-syntax ([alst (syntax-local-introduce #`#,(syntax-local-value
> #'alst))])
>       #'(let alst body ...))]))
> (define (foo)
>   (define-syntax dave '((is 5) (fat 6)))
>   (letexpand dave is fat))
> (foo)
>
> On Dec 11, 2014, at 6:52 AM, Roman Klochkov <kalimehtar at mail.ru> wrote:
>
> #lang racket
> (require (for-syntax syntax/parse) racket/stxparam)
>
> (define-syntax letexpand
>   (syntax-parser
>   [(_ alst body ...)
>     (with-syntax ([alst (syntax-local-introduce
> #`#,(syntax-parameter-value #'alst))])
>         #'(let alst body ...))]))
>
> (define (foo)
>     (define-syntax-parameter dave '((is 4) (fat 6)))
>     (letexpand dave is fat))
>
> (foo)
>
>
>
> Tue, 9 Dec 2014 06:33:14 +0200 от J Arcane <jarcane at gmail.com>:
>
> Hmm. That does appear to work at a global level, but then when you attempt
> to use it inside of a function it returns "identifier used out of context".
> Trying to define-for-syntax in a local context also causes problems;
> "begin-for-syntax: not in a definition context in: (begin-for-syntax
> (define-values (z) lst))"
>
> On Mon, Dec 8, 2014 at 10:17 PM, Alexander D. Knauth <alexander at knauth.org
> > wrote:
>
> Would something like this work for what you want?
>
> #lang racket
> (require (for-syntax syntax/parse))
> (define-for-syntax dave '((is 5) (fat 6)))
> (define-syntax letexpand
>   (syntax-parser
>     [(_ alst body ...)
>      (with-syntax ([alst (syntax-local-introduce #`#,(eval-syntax
> #'alst))])
>        #'(let alst body ...))]))
> (letexpand dave is fat)
>
> On Dec 8, 2014, at 2:46 AM, J Arcane <jarcane at gmail.com> wrote:
>
> > I've been experimenting with a new feature for Heresy, and I find myself
> in need of a macro that can insert the contents of an a-list into a let
> syntax to serve as its definitions. I am utterly failing to accomplish
> this. It seems like it should be simple enough to splice a variable's
> contents into the syntax, and in a sense it is, but not if I want it to
> actually then evaluate.
> >
> > For example, I can do this:
> >
> > (define dave '((is 5) (fat 6)))
> >
> > (define-syntax letexpand
> >   (syntax-rules ()
> >     [(_ alst body ...)
> >      #`(let #,alst body ...)]))
> >
> > (letexpand dave is fat)
> >
> > Which returns a syntax object which looks like what I want:
> >
> > #<syntax:...:8:7 (let ((is 5) (fat 6)) is fat)>
> >
> > But doesn't actually the evaluate that object. But doing that with
> merely (let alst body ...) creates an error because rather than splicing
> alst's contents itself, it merely inserts the variable name given, and then
> fails because let doesn't recognize it. It will work with a handwritten
> unquoted alist in that space, but this is largely useless because of course
> that's what let already basically does anyway.
> >
> > Am I starting in the wrong place here, and if not, how do I turn that
> syntax object into something that actually evaluates?
> > ____________________
> >  Racket Users list:
> >  http://lists.racket-lang.org/users
>
>
> ____________________
>   Racket Users list:
>   http://lists.racket-lang.org/users
>
>
>
> --
> Roman Klochkov
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20141212/fa8fb676/attachment.html>