I am new to scheme and I am trying to trace a function. I have to load the "trace" function. According to the racket documentation, I have to execute a:
(require racket/trace)
But the response I am getting back is
require: undefined;
cannot reference undefined identifier
I am baffled. I am using language "R5RS" if that makes a difference. can't find anything online or on stack overflow on this.
Try this:
(#%require racket/trace)
Chris Jester-Young's comment is correct: don't use R5RS. In the standard R5RS language, there's no such thing as a module. Go look at http://www.schemers.org/Documents/Standards/R5RS/; not a word about a module, right?
Racket takes the standard more seriously than you'd expect: if you tell it to work in R5RS mode, it will turn off language features that the standard does not describe.
If you're using the Racket toolchain, don't use the R5RS language unless you really want to work in a restrictive language. Use standard #lang racket instead. See: http://docs.racket-lang.org/guide/intro.html which shows how to use it in that mode.
Related
I am using Drracket for my project. I am using the language SICP(#lang sicp) for my project. For one of my implementations i require the use of scheme package called (require (planet dyoo/simply-scheme)). Scheme is not recognising require keyword. But if i change my language to #lang racket "require" is recognised as an keyword. My project makes use of set-car! and set-cdr! which is available in sicp language and not in racket. Is there any work around.
Below is some excerpts of my code:
#lang sicp
(require (planet dyoo/simply-scheme))
(define crosscuts 0)
and
(define (move-north steps_to_move)
(set-cdr! current_position ( + (y_coord current_position) steps_to_move)))
First of all, here are things that I want to note:
It's generally better to use #lang racket because #lang sicp is very limited. You can still access set-car! (though it's named set-mcar!). See the documentation at https://docs.racket-lang.org/reference/mpairs.html.
In case you decide to use #lang racket, do you actually need to use mutable data structure? Avoiding mutation is a defining trait of functional programming. And if you really do need mutable data structure, can you use struct with #:mutable instead? It's more Racket-y. See the documentation at https://docs.racket-lang.org/reference/define-struct.html.
This might not be possible, but generally I would avoid using Planet package. Planet is an old package system that is no longer recommended. It looks like there's no simply-scheme in the new package system, however, so you might really need to use Planet here.
If you really want to use #lang sicp, note the margin note at https://docs.racket-lang.org/sicp-manual/SICP_Language.html
R5RS has no require to avoid breaking programs that use the name require. #%require is therefore used instead.
#%require is a much more primitive operation, however. Depending on your require spec, it might or might not be easy to switch from require to #%require.
So first, try to replace require with #%require and see if it works. If it is, great, you are done.
But if it errors, then it means your require spec can't be processed by #%require. One possible solution is to use #%require to get require from Racket, so that you can use require to do more complex things.
(#%require (only racket require))
(require ....)
I'm trying to use the racket CLI to run a file but I need a specific language (pretty-big) features to be available and I'm struggling with that.
As far as I know, if I run $ racket <file_name> then it requires the file as a module. In order to do that, I need to add #lang <some_lang> at the top of my file, but I just can't find any equiv to #lang pretty-big. Any idea how to ask for pretty-big this way?
The other option, is to run the code in load-mode (from the racket CLI manual) but on this case I'm getting no results back which obviously isn't good.
Any suggestions?
I know the solution to this will be super easy, just can't find it.
A search of the Racket docs for "pretty big" turned up this result, which says that the module lang/plt-pretty-big corresponds to DrRacket's "Pretty Big" legacy language.
Unfortunately, putting
#lang lang/plt-pretty-big
at the top of your file won't work, because that module doesn't specify a reader. But you can tell it to use the usual S-expression reader by using the s-exp "meta-language" as follows:
#lang s-exp lang/plt-pretty-big
If you want Racket to print out the results of top-level expressions in your file, it looks like the lang/plt-pretty-big language still won't do it, and I don't think there's an easy fix. Consider porting the program to #lang racket, which has that behavior. Or add println around the things you want printed.
A 4-year-old old post suggests that one might be able access the current-seconds and related functions in the r5rs language.
Here's why I ask: I'm a high school teacher new to Racket and we are using the r5rs language. I would like to introduce students to functions by starting with a function that needs no arguments to make sense. The example that occurs to me is minutes-past-the-hour. But I am ignorant of how to make those functions recognized in an r5rs program.
Thanks for any helpful advice.
First of all, why not use #lang racket instead of r5rs? Racket is very much built with education in mind. It even has various teaching languages for use with the How to Design Programs textbook (or its second edition, which is still being worked on).
Racket's implementation of R5RS is intentionally limited—it's not usually intended to be used for anything practical, since Racket itself has outgrown its Scheme roots. It can be useful as a teaching tool, but as you've seen, it doesn't include any special extensions (beyond a small set of internal forms).
If you're really interested in using R5RS Scheme, there exists an implementation of SRFI 19: Time Data Types and Procedures bundled with Racket. R5RS does not have a module system, so there is no formally-specified way of loading external libraries in pure Scheme. You'll need to use the Racket #%require extension to load the SRFI implementation:
(#%require srfi/19)
This will give you access to all the SRFI 19 functions and values.
You could also just include the functionality you want from Racket itself, since the languages are actually interoperable. To include current-seconds, you'd want to do something like this:
(#%require (only racket/base
current-seconds))
If you're going to do that, though, it seems almost pointless to use the r5rs language. Just use racket or racket/base instead.
I've got a bunch of "legacy" Guile Scheme code that I want to get running in the Racket Scheme IDE. There appear to be enough differences to make this a non-trivial exercise. (My level of Scheme knowledge is the level to complete the The Little Schemer).
My question is:
What are the differences between Guile Scheme and Standard Scheme (in the Racket IDE)?
In light of these differences, in general, what are the steps I'll need to take to convert some Guile Scheme Code to standard Scheme?
Additional: (happy with divergence between Racket Scheme and R5RS/R6RS) - what I want is to get 'something' to run in the Racket IDE - rather than the Racket language.
If by "Standard Scheme (in the Racket IDE)," you mean the Racket language, i.e., what you get when you prefix your code with #lang racket, then the top four differences to look out for are:
a different module system
a different macro system (depending on how old your code is)
immutable cons-cells (unless you import mutable ones)
no one-armed ifs in Racket (use when)
To port code from Guile to Racket, find out which files are "at the bottom" of your dependencies, i.e., find the files that do not depend on other files.
Open such a file in Racket, add the line #lang racket at the top, and try to run it.
You will most likely encounter some "unbound identifier" errors.
If you are lucky, the function is present in Racket, but not included in the "racket" language. Search for the name in the Racket documentation, and if you find it, then use (require ...) to import the name into your program.
Then run the program again to find the next error.
Some function are named differently in Guile and Racket, so look up the name in the Guile documentation and see what it does. Then open the Racket documentation on the same subject, and see what it is called in Racket.
In some cases you may have to make bigger changes. If you can't find some piece of functionality in the Racket documentation, then try asking the mailing list. It could be that it simply has a different name, or that somebody implemented it and put it on PLaneT (thus it will no appear in the documentation until you have installed the package).
Example of importing srfi/1 into the R5RS language.
#lang r5rs
(#%require srfi/1)
(xcons 1 2)
Differences from R4RS code to modern Scheme?
One thing to look out for is that in R4RS the empty list '() counted as false, not it is interpreted as true.
See this question for more things to look out for:
Running SICP Pattern Matching Rule Based Substitution Code
See also this list of changes from the R5RS standard:
List of changes from R4RS to R5RS
Background: I am new to scheme, and am using DrScheme to write my programs.
The following program outputs 12345 when I run the program as r5rs:
12345
However the following program outputs nothing (it's an r6rs program):
#!r6rs
(import (rnrs))
12345
That being said, I can get it to output 12345 by doing this:
#!r6rs
(import (rnrs))
(display 1235)
Is that something new with r6rs, where output only occurs when specifically specified using display? Or am I just doing something else wrong
This is a subtle issue that you're seeing here. In PLT, the preferred mode of operation is to write code in a module, where each module has a specification of the language it is written it. Usually, the default language is #lang scheme (and #! is short for #lang). In this language, the behavior is for all toplevel non-definition expressions to display their values (unless they're void -- as in the result of most side-effects). But the #lang r5rs and #lang r6rs don't do the same -- so these toplevel expressions are evaluated but never displayed.
The reason you did see some output with the R5RS language is that you didn't use it as a "module" (as in #lang r5rs), but instead used the specific R5RS "language level". This language level is more compatible to the R5RS, but for various subtle reasons this is not a good idea in general. Using #lang is therefore generally better, and if you want to save yourself some additional redundant headaches, it'll be easier if you stick with #lang scheme for now, and worry about standards later. (But YMMV, of course.)