@trhawes What do you need the provides for? If you need a list of all the individual provided variables, then expansion is needed. If you want to reindent the original provide forms, you don’t.
I want to copy the provides from each file into a corresponding stub file in each directory. This is actually a repo for students wanting to learn Racket on Exercism,io. Each exercise has a unit test file, a stub file (the student recieves to get started on the exercise), and an example.rkt file with the exercise fully solved (we use this to validate the unit tests). My goal is to extract the provide line from the example.rkt for each exercise, and make sure the corresponding stub file has this provide line in it, so the student understands what functions (and their names) the unit tests expect. This would be something we could re-run for new exercises.
Looking at the docs, it is not clear how I might load each example.rkt in for expansion. I did find read-lang-file (https://docs.racket-lang.org/read-lang-file/index.html), so that lets me load the file, and return a syntax object I can expand. But when I run (syntax-property-symbol-keys ex)
it returns just '(module-body-inside-context
module-body-context-simple?
module-body-context) None of the keys you linked to.
Surely, I am missing something.
For now, I just run syntax->datum on the expanded module, and then recurse through the resulting list to find my provide line.
Here is a quick hack. Which basically do as you, but doesn’t expand anything: #lang racket
(require racket/list)
(provide get-provide-forms)
(provide (all-from-out racket/list))
(define (provide-form? f)
(match f
[(list* 'provide more) f]
[_ #f]))
(define (get-provide-forms file)
(with-input-from-file file
(λ ()
(read-line) ; skip #lang line
(filter values
(for/list ([form (in-port read)])
(provide-form? form))))))
; test it on it self - don't we all love self-reference
(get-provide-forms "get-provide-form.rkt")
This works as long as no macros in the file expand to use uses of provide.
Use the expand solution, if you need that.
Thank you!
Is it possible to access a stack trace from an exn:fail ? If so, how?
DrRacket?
no
racket-mode in Emacs?
no, while running the program. In other words, I’m using with-handlers and I catch an exn:fail - I can print the message, but I’d like to know the stack trace
exn only has message and continuation-marks, so I figure it must be somewhere in the continuation-marks
You probably need to use error-trace. I think, it stores information in continuation marks.
There is an: (print-error-trace output-port exn) which looks at point.
With Ruby, it would simply be: def self.foo
...
rescue => e
logger.error(e.message)
logger.error(e.backtrace)
end So, I was hoping something similarly easy was available.
@soegaard2 (print-error-trace …) seems to do the trick - thanks!
great!
@soegaard2 oops - spoke too soon. It works in DrRacket, but I get no output from running via the commandline.
#lang racket
(require errortrace)
(define (boom)
(/ 1 0))
(define (run)
(with-handlers ([exn:fail?
(λ (e)
(print-error-trace (current-output-port) e))])
(boom)))
(module+ main
(run))Maybe there is no current output port?
I think you need to enable error-trace when racket is invoked (I remember I was puzzled the first time I used errortrace in the terminal).
Hmm… then I’m wondering if I want to do that normally in production :disappointed:
I would get a stack trace from Racket if I wasn’t catching the exception myself, so I’m not sure why the errortrace module is necessary.
racket -l errortrace my-script.rkt
I guess I can read the code of the default exception handler, and see how it does it. Your -l example above still produced no output.
@badkins you want exn-continuation-marks and then the continuation-mark-set->context function
@badkins did you also use -m to invoke main?
No, but I’m pretty sure I don’t want to use errortrace in production. I’m trying Sam’s idea…
#lang racket
(define (boom)
(/ 1 0))
(define (run)
(with-handlers ([exn:fail?
(λ (e)
(print (continuation-mark-set->context (exn-continuation-marks e))))])
(boom)))
(module+ main
(run))Produces: (list (cons #f (srcloc #<path:/Applications/Racket v7.3/collects/racket/private/more-scheme.rkt> 261 28 9063 56)) (cons '\|[running body]\| (srcloc "(submod \"/Users/badkins/Desktop/exn-test.rkt\" main)" #f #f #f #f)) '(temp37_0 . #f) '(for-loop . #f) '(run-module-instance!125 . #f))
yes, that’s what you should get
and then deconstruct srcloc ?
If you don’t invoke main, boom isn’t called.
Doesn’t module+ main do the trick? That’s how I’ve been running all my programs.
@samth having all the good stuff as #f is kind of useless, no?
Oh - sorry. You are right.
Ran it Emacs - and boom wasn’t called.
i.e. line, column, position, span are all #f, so not very helpful
The ones that are #f are for running body, which is saying it’s just running the body of the main submodule
that’s the same info you get in the regular error message
Ah, indeed you are correct. <sigh>
Another thing you might want: (lambda (e) ((error-display-handler) (exn-message e) e)) which just prints the exception the way it normally gets printed
Perfect, I’ll try that in the production program…
Awesome - ((error-display-handler) (exn-message e) e) did exactly what I needed. Thanks @samth and @soegaard2 !
:slightly_smiling_face:
Printing a stack trace is something most newbies will want fairly soon, so making that more obvious in the docs would be super helpful. I read through a few pages in both the reference and guide before asking here.
any suggestions for which page would be good to add that to?
FWIW there is an error-display in unstable/errors.
@samth I first went to exn:fail, then looked at the parent i.e. exn, so I think regardless of the page, having a link in the description for exn would be good. I think most people would be wanting to find out what they could do with the exn object.
It’s clear that the message can be obtained, but it’s not clear how to get a stacktrace.
I think I got a little confused distinguishing between continuation-marks and continuation-mark-set
Had I clicked on the continuation-mark-set? link for exn, I would’ve seen the continuation-mark-set->context function you mentioned, but I think I went down another trail.
@samth to answer your original question, probably here: https://docs.racket-lang.org/guide/exns.html
An example printing a stack trace would do the trick I think.
Does anyone happen to have any code examples/advice on parsing nested lists without mutation? Any representation will do really. This code I found on StackOverflow uses lists of strings, along with returning values of both the result of the current level of parsing, and any input still left to be parsed: (define (parse-sequence lst)
(define (parse-seq lst)
(let loop ((lst lst) (res null))
(cond
((null? lst) (values null res))
((string=? (car lst) "[")
(let-values ([(lst2 res2) (parse-seq (cdr lst))])
(loop lst2 (append res (list res2)))))
((string=? (car lst) "]")
(values (cdr lst) res))
(else
(loop (cdr lst) (append res (list (car lst))))))))
(let-values ([(lst res) (parse-seq lst)])
res)) I planned on putting something like this together in a few minutes, but (to my dismay) I found it rather difficult. I’m usually okay with recursive functions but this one just baffled me for some reason. The great majority of examples I’ve found are in a mutating/side-effectful style, with a while loop and a shared, mutable list so there’s no concern about keeping the recursive calls “in sync” with eachother. However, I really want to know how to do this elegantly (or, as possible) in a purely functional way, and I was hoping someone could provide some examples of how to go about it. I initially thought I could just get the length of the recursive list parse and then drop that many elements from the current list; I’m still confused as to why that doesn’t work. Thanks :)
What is the input grammar?
Sorry, completely forgot to specify. Just nested lists of numbers for now, keep it easy on myself. The delimiters in the code are "[" but that was just the best example I could find on SO - any paren style will do really.
; <exp> ::= <number>
; \| ( <exp> * )Can we assume the input is correct?
We can. I was worrying a little about matching delimiters, but I think I should get a handle of parsing correct input first.
@sydney.lambda Working on an example.
thank you :)
It does give you an error if it sees an unexpected character.
If you turn line and column count for the input port, you can get the exact position from the port.
Awesome example, thanks @soegaard2. That’s practically a tutorial on how to implement a parser combinator library! I guess I should stop worrying about functional purity for now and use input ports - I’m not gaining anything from doing so at this level of experience. I’ve messed around defining individual parsers but struggled a great deal in “gluing” them together at the top level. I think I have a much better idea of how to do so now after seeing your example.
Thanks! Btw - each parse function assumes that any white space has been consumed by the caller.
That was actually one of the others things I’ve been rather uncertain about whilst messing around with parsing over the past few days — how far “up the chain” (if that makes sense) to parse whitespace, when to do it before, when after, and such.
I tended towards having the lowest-level parsers (individual operands and operators to use assembly as that’s my ultimate goal) assuming that all whitespace at the start has been pre-consumed, and not consuming any whitspace or \n afterwards. That means something may “erroneously” match a the lowest levels due to, say, matching "#$22" in "#$22foo" even though nothing should ever appear after the "#$22" except a \n, but that’s taken care of higher up the chain by the “glue” functions which tie the smaller ones together. It seems I got the whitespace-consumed-by-caller thing right, at least! :)
Sorry for the wall of text, it almost slipped my mind as I was completely focused on parsing nested lists specifically.
It’s an old reference, but the book “Brinch Hansen on Pascal Compilers” explains this sort of parsing really well. A library is needed - I can’t find it online.
Check these pages from a Scheme workshop on parsing and compilers: https://web.archive.org/web/20170502175623/http://www.cs.indiana.edu/eip/compile/scanparse.html https://web.archive.org/web/20150316044923/http://www.cs.indiana.edu/eip/compile/scan-numlist.ss
I swear, I thought I had tried every permutation of “Scheme parser guide” trying to find some examples of a nested-list parser. That link is exactly the type of thing I was looking for! Thanks a bunch.
Indiana University unfortunately removed those pages. Only way of finding them is finding an old link to them, and then using http://archive.org\|archive.org. So if you don’t know they exist …
@sydney.lambda I think one thing that could be confusing is that there are a few different “jobs” being interleaved together. A traditional way to break this up is into “lexing” and “parsing,” where lexing would turn a raw input string like " ( 1 (11 12 13) 2 3 (41 42) 5 )" into a flat stream of tokens, like '(open 1 open 11 12 13 close 2 3 open 41 42 close 5 close), then parsing would match nested 'open and 'close pairs and produce nested lists.
thanks @philip.mcgrath I’m afraid even with a lexing step, it’s the general way that solution works that confuses me. My initial solution was to (upon encountering an open paren (when already in the process of parsing a list) parse the nested list recursively, get the return result of the parse, and then just drop that many elements from the input. However, that doesn’t seem to work - you need to have the functions return a pair of (remaining-input . parse-result) and I can’t seem to get my head around why.
I thought it would be really darn cool to utilise continuations, such that when you encounter a nested list you pass a continuation argument that says “hey, when you’re finished parsing that other list and whatever else, remember to let me finish parsing the rest of my list, okay?” but alas, I couldn’t figure it out :/
There’s a great pattern matcher from the lambda papers posted here: http://blog.veitheller.de/Pattern_Matching,_A_Thing_Of_The_Past.html which enables backtracking using continuations which each consume a tiny bit more input if the current input isn’t sufficient to match. I figure there must be a way to use this in aid of parsing nested lists, but I guess I’m just not experienced enough yet.
To understand the problem with your strategy, let’s think about the input "(1 2 (3 4 (5 6)) 7)". After parsing 2, we see (, so we call ourself recursively. Let’s imagine that recursive call works and we get back '(3 4 (5 6)). The length of '(3 4 (5 6)) is three, but it’s consumed more than 3 tokens of input! You could write a helper function to walk an intermediate result list like '(3 4 (5 6)) and count how many tokens it must have consumed from the input list, but, at that point, it’s probably easier to just return the rest of the input and avoid counting explicitly.
In a sense, the “rest of the input” return value is the continuation.
I think it’s starting to register in my brain now, (5 6) consumes 5 tokens (space included) yet its length is technically one after being converted to a list. Even with the ( and ) taken into account which are not consumed, you’re still missing everything between the parens, if I’m getting this right.
Yes, that’s right
I mean, it registers as one element in a larger list… Argh, I really don’t know why I’m finding this so confusing! haha. One of those occasions when you go over it so many times you burn yourself out, instead of just taking a break. Thanks for taking the time to explain it, I really appreciate it. I’m sure when I look over it tomorrow with a fresh pair of eyes (and synapses) I’ll wonder what I was fussing about.