Hello! I’ve been doing quite a bit of 3D work with Racket + pict3d, but since upgrading to Racket 6.7 I’m seeing the following ~error~ warning:

cpointer?: contract violation any-wrap/c: Unable to protect opaque value passed as `Any` value: #<cpointer> This warning will become an error in a future release.

Looking around on google/mailing lists, it seems that there isn’t a single “nice” fix for such things. Is anyone well-versed enough in Typed Racket to help me figure out what the interpreter is unhappy about?

@alexeld this issue will be fixed for that library in the upcoming release

If you want to try, you could use one of the nightly snapshots

Also, note that it isn’t a bug in your code

@samth Yeah, apologies for that — I should’ve said it was coming from the pict3d lib.

I’m glad to hear that it’s a candidate for being fixed in the next release, though!

I rolled back to 6.5 because things “just worked”, but I’ll give a snapshot a try and see how it works. Cheers!

@leif apparently, the textcomp woes come from scribble using \renewcommand{\rmdefault}{ptm} though I’m not sure which part of the code do that. git grep rmdefault shows nothing in acmart and not relevant things in the main plt repo. This is also bad because it undoes a crucial element of the acmart class file.

The culprit seems to be pkgs/scribble-lib/scribble/scribble-load.tex and pkgs/scribble-lib/scribble/scribble.tex

@fahree sigh….yay latex. :confused:

Really needs hygeen

Out of curiosity, what does textcomp do?

it allows things like \textrightarrow, a \rightarrow usable outside $$

We need to override somehow the scribble.tex file…

oey…hmmmph…okay

:disappointed:

I have a library of database functions (generic_db.rkt) that was built for my current project, but a lot of the functions are generic things that I’ll want to use in the future. I’d like to lift those functions out into a new library but require / provide them from generic_db.rkt so that the change is transparent to existing code. The problem is that most of these functions have a signature like this: (define (foo … [db (dbh)]) so that you can call them without having to explicitly pass a database handle and they will generate one if needed. I would like to do something like an interface, but not OO — “hey Racket, these functions are intended only for being imported into another library which will provide the dbh function, so don’t worry about that” Is there a way to do that?

Again, the goal is to be transparent to existing code.

In other topics, is there anything equivalent to C / Perl / etc’s <stat> function, that will return multiple pieces of information about a file in one call? I’m writing a file-monitoring system that needs to walk down a potentially enormous file hierarchy (millions / tens of millions of files) and record the path, modified date, and size of everything it finds. I’m using (fold-files) and I’d rather not have to do two extra calls / check the file system twice per entry to get modified date and size.

I guess one solution to your first question is to have dbh as a Racket parameter of a function. Then the other modules can parameterize at their will.

That would require all the other functions to change though, right?

Let’s say I factor all this into “new_db.rkt” and I declare a stub, (define (dbh) #t). Could I then (require “new_db.rkt”) into generic_db.rkt and redefined the dbh function?

Ah, woot! I can do that with (set! dbh (lambda…)) Cool, problem solved.

Damn. Nope. Not if I required it in from another module. Argh.

@dstorrs you can use a parameter and then set the parameter from the other module

a parameter sounds like the right thing here, yes

If dbh is a parameter, you can set it with parameterize or by calling dbh like a function with the new value ((dbh (lambda …).

Note that the latter has a global effect on the program, so multiple modules might step on each other.

I just tried this:

;; in test.rkt (define dbh (make-parameter (lambda () 7))) dbh (dbh)

Running it gives me this: #<procedure:parameter-procedure> #<procedure:y_>

I’m expecting (dbh) to yield 7. What am I not understanding?

The result of make-parameter is a function which returns the parameter value. Thus, (dbh) is (lambda () 7). What you want is ((dbh)).

In that case, I’m not sure how this solves my problem. Here’s what I’m trying to achieve: ;; module: dstorrs/db (define (dbh) …stub…) (insert-row arg1 arg2 [db (dbh)]) …)

;; module: generic_db (require dstorrs/db) (define (dbh) …generates a DB connection…) (provide (all-defined-out) (all-from-out dstorrs/db))

;; module: foo (require generic_db) (insert-row “foo” “bar”) ;; uses the dbh from generic_db

How do I use parameters to make this happen?

you don’t want to change a single line of code from your library? that seems like an unreasonable requirement

Actually, I think I need an except-out around the all-from-out dstorrs/db, but that’s a quibble.

> you don’t want to change a single line of code from your library? that seems like an unreasonable requirement

I’m fine to change anything in the new dstorrs/db or previously-existing generic_db modules. I’m not fine to change anything that uses generic_db.

then you’re probably stuck. it sounds like you currently have two things that are tightly coupled, and you want to make them loosely coupled, but you can’t really change that without at least a minor change in your consumer.

that’s not really a big deal, though, is it? you’d only have to change one thing (the thing that defines dbh), so you could extract your library, then update your consumer in the one place.

Suppose I have dstorrs/db offer a mutator for dbh and generic_db uses that mutator to redefine dbh to something workable?

well, that’s precisely what using a parameter would get you

> that’s not really a big deal, though, is it? you’d only have to change one thing (the thing that defines dbh), so you could extract your library, then update your consumer in the one place.

I think perhaps I’m confused. Are you defining ‘consumer’ to mean the generic_db module which will use dstorrs/db, or are you defining it to mean absolutely everything that uses the generic_db module?

Because, like I said, I’m fine to change generic_db. I’m not fine to change every file that uses generic_db.

ah, ok. generic_db is part of the client code, from a library/consumer POV

but you could define dbh as a parameter, then change dstorrs/db to use the default value ((dbh)) instead of (dbh).

Yes, that would be fine.

generic_db is the existing module. It is used by basically every file in our project. I want to move most of its contents into a new library, dstorrs/db. I need this change to be invisible to all consumers of generic_db, but I’m fine to change anything in dstorrs/db or generic_db

that sounds like it would be feasible then, yes

Note that most consumers of generic_db will call the dbh function as (dbh) and will expect to get back a working connection.

@dstorrs: If I understand you correctly, what you’re trying to do is have generic_db change the meaning of the binding dbh from dstorrs/db. By design, the module system prevents that. For a good reason, too, otherwise the writer of dstorrs/db wouldn’t be able to reason about the module in isolation. Modules wouldn’t compose well.

Yes?

you could name the parameter something more descriptive, like current-get-db-connection, then define dbh as (define (dbh) ((current-get-db-connection))).

that would keep the interface identical to your code

Cool, that sounds perfect.

And note that using parameters—and the façade proposed by @lexi.lambda—is relying on mutating what’s under the parameter, but the meaning of current-get-db-connection remains unchanged: it’s always a parameter of a function.

That’s why the module system is happy. Because when defining dbh like @lexi.lambda proposed, you’re acknowledging that you don’t know exactly what the current-get-db-connection is going to look like.

You just trust the users to parameterize it with suitable functions.

If I understand correctly, this is how it would work?:

;; dstorrs/db (define current-get-db-connection (make-parameter thunk)) (define (dbh) ((current-get-db-connection)))

(insert-row arg1 arg2 (db [(dbh)] …stuff…) (provide (all-defined-out))

;; generic_db (require dstorrs/db) (define (dbh) (parameterize current-get-db-connection (thunk …make a real connection) ((current-get-db-connection))) (provide (all-defined-out) (except-out (all-from-out dstorrs/db) dbh))

;; foo (require generic_db) (insert-row “foo” bar")

Or should I not be exporting dbh from dstorrs/db ?

Not quite. Think of something more like: (module dstorrs/db racket (provide (all-defined-out)) (define current-get-db-connection (make-parameter (lambda () (error "...")))) (define (dbh) ((current-get-db-connection))) (define (insert-row arg1 arg2 [db (dbh)]) "...")) (module generic_db racket (require (submod ".." dstorrs/db)) (provide (all-from-out (submod ".." dstorrs/db))) (current-get-db-connection (lambda () "make a real connection"))) (module foo racket (require (submod ".." generic_db)) (insert-row "foo" "bar"))

Please note that requiring generic_db has a global effect on the program. I.e., there can only be a single default database connection in the program at a time. But that makes sense, right? Otherwise, how would we know which connection to use when db hasn’t been explicitly set when calling insert-row?

lang racket is the same as "(module foo racket", right?

yes

Okay, good. What is the difference between (require foo) and (require (submod ".." foo)) ? I’m looking at the Reference article on submodules and it makes it sound like they are used when both modules are defined in the same file.

(require foo) is equivalent to (require (lib "foo")), which requires the external library, so it has nothing to do with submodules. however, you might be thinking of (require 'foo), which is equivalent to (require (submod "." foo)).

The docs say: “Although a submodule is lexically nested within a module, ” I’m reading this to mean that the submodule is in the same file as the module of which it is a submodule. Is that correct?

yes

The reason I wrote the code this way was to show you the concept in a single runnable file :slightly_smiling_face:

Ah. That makes a little more sense. I’ve been reading and re-reading the docs on submodules trying to figure out why the heck you’d done it that way, since it seems exactly counter to the goal. :stuck_out_tongue:

:+1:

I’m also finding the submodule docs to be clear as mud.

Particularly thick mud at that.

Which documentation are you reading, specifically?

https://docs.racket-lang.org/reference/require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._submod%29%29

The reference is for the initiated. Try the Guide, instead: http://docs.racket-lang.org/guide/modules.html

https://docs.racket-lang.org/guide/Module_Syntax.html#%28part._submodules%29 in particular

Yep, that makes much more sense. Thanks.

> “The reference is for the initiated.”

This is a fact with which I have become painfully familiar. I find myself terribly ~smug~ pleased every time I’m able to use the reference and grok what it says.

I’m not surprised to read that. I went through the same process when I started to learn Racket myself, a couple of months ago :slightly_smiling_face: I believe that the reference is useful when you already know what you’re doing, and just need to check the details while in the middle of a coding section. When learning new concepts, the Guide is best. I did a deep dive and read the Guide from cover to cover when first getting into the language.

It’s important to know which documentation to read, but I think that’s what makes Racket’s documentation so amazing. Most software only has one level of documentation, either tutorials or inscrutable man pages. Racket’s documentation caters to all needs.

It is definitely the most attractive documentation I’ve ever read, the Reference is very thorough, and for the most part the Guide is very strong. I think their failing, however, is the way in which they are rendered. They are in the repository as tiny chunks of Scribble without obvious connection to how they exist in the final output. There are some pieces that I have wanted to suggest changes to, but the literate-programming way in which the docs are assembled makes that extremely difficult. The first time this came up I spent 5–10 minutes thrashing around the repo trying to find the relevant piece so I could submit a pull request, then gave up. Since then I haven’t bothered, which itches at me.

Do you remember what it was? Or, at least, in which project it was?

@dstorrs would you find it easier to contribute if the whole reference was in one source file?

> Do you remember what it was? Or, at least, in which project it was?

I don’t, sorry. There have been two or three such instances, though. One of them was a trivial grammar error, but the others were minor yet substantive.

> @dstorrs would you find it easier to contribute if the whole reference was in one source file?

I would. Or, at the very least, if there was a single file with clear directions on how to locate the thing that I needed to update.

I have no problem working with Scribble snippets as long as I don’t have to search around for them. If the correspondence between “where it is on page X” to “which repos and where in that repos” were obvious then I would be much more willing to take the time.

thanks, that’s helpful

Maybe once I understand the current system it would be obvious, but it is very much NOT obvious to a newcomer.

I ask that because maybe you hit a project that was particularly odd in structure. But, for most projects, a simple “Search in project” on GitHub suffices. Even that might not be necessary, since most documentation lives in the “scribblings/” folder of the particular project.

But I guess the best solution would be to have a “edit on GitHub” link in the documentation. Do you think that would help?

> But I guess the best solution would be to have a “edit on GitHub” link in the documentation. Do you think that would help?

That would be ideal.

> Even [searching] might not be necessary, since most documentation lives in the “scribblings/” folder of the particular project.

There are about a dozen different Racket repos on Github. If I wanted to edit the docs on ‘local-require’ (I don’t, but it’s open in front of me and therefore makes a good example), where would I look? https://docs.racket-lang.org/reference/require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._local-require%29%29

1. figure out what package exports local-require
2. find that package on github
3. search on github, or clone the package & search

there’s “almost” an algorithm … but yeah I’ve been thinking about how to add an “edit on github” button

I think an @github-button["github-url"] function would be easiest to implement

Asking people to submit doc changes is a big ask. Given that they are willing, asking them to open Github in their browser is probably fine. Asking them to “figure out” ANYTHING from there is a huge ask.

here’s a somewhat different algorithm

If you want contributions from the general community, it needs to be dead simple.

1. go to the local-require docs page

http://docs.racket-lang.org/reference/require.html?q=local-require#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._local-require%29%29

1. go to the top of the page

1. click on the title

that will show something like “Link to this section with @secref["require" #:doc '(lib "scribblings/reference/reference.scrbl")]”

1. Open DrRacket

Here’s how I do it: 1. Go to the top of the documentation page, find which part it talks about. In this case, Racket the language. 2. Go to racket/racket. 3. Seach 4. Find.

Hit Ctrl-Shift-O and type in “scribblings/reference/reference.scrbl”

Coming to think of it, I agree, it’s not ideal :slightly_smiling_face:

A) How would I know that? B) I don’t use Dr Racket and am not willing to open another application just to contribute a small bit of docs.

that’s the top of the reference, and unfortunately you have to find which part of it wrote that

B: if you use racket-mode, I think it’s the same keystroke

C) How would I know that it’s in racket/racket?

https://github.com/racket

I suppose my algorithm only works for things you’ve cloned locally

sardonic look Yes, well, I haven’t done that and I suspect that the majority of users have not either.

The link you sent is part of the “The Racket Reference”, thus racket/racket. But that’s because I invested the time to learn this. Of course, you’re completely right, passing-by contributors wouldn’t go into the trouble :slightly_smiling_face:

sure, but just making it easy to contribute to docs for the things you’ve checked out (which are probably the things you know best) would be already valuable

I wonder if there’s already ongoing work on a “Edit on GitHub” button?

@leafac I don’t know of any

Given that this is https://docs.racket-lang.org/reference/require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._local-require%29%29 I would have expected it to be in either: Repos: scribble [first choice] Dir: reference/require/local-require.scbl

Or something similar.

Or: Repos: Racket Dir: reference/require/local-require.scrbl

@samth: Would you say that this is the correct place to start moving in that direction? Or should I target somewhere else?

the scribble code is certainly the right place

(Hang on a second, Slack’s Markdown doesn’t support links? :disappointed: )

you’d probably need to use the pkg system to figure out where a given file came from

and then figure out (using the same mechanism as raco pkg update --clone) what the relevant github repo is

and maybe add a similar drop down when you click the title

@dstorrs it’s actually here: https://github.com/racket/racket/blob/master/pkgs/racket-doc/scribblings/reference/syntax.scrbl#L889

all of section 2 of the reference is in that file

Hmmm, I’m kind of inclined in going on a different direction and following @ben’s idea: adding a @edit-link[”http://…”] instead of automagically generating the links. Yes, it adds the burden on the authors, but is explicit and correct.

> @dstorrs it’s actually here: https://github.com/racket/racket/blob/master/pkgs/racket-doc/scribblings/reference/syntax.scrbl#L889

Without wanting to sound TOO snarky, I will suggest that perhaps that is not the most obvious place that a newcomer would look.

Point taken :slightly_smiling_face:

I think the reality of the size of the code base makes it hard to have as simple a path as a newcomer might expect

Furthermore, having a link subsumes the need of having a predictable path for the file.

One cheap solution: Have a form somewhere with two big text boxes. People drop the existing text into the top one and the suggested text into the bottom. The form submits to a queue that community members with time and experience monitor. It’s their job to sort out whether the change should be accepted and, if so, to where.

https://github.com/racket/scribble/issues/76

It would (a) capture most of the value very quickly and (b) provide significant incentive for a better system to be created.

@ben: You beat me to it. I almost opened a duplicate issue :slightly_smiling_face:

@dstorrs can we use the mailing list instead of a form? (I realize that’s one more barrier to entry)

I think automated posting to a mailing list would be not so good

oh, I didn’t mean automated

You can, but it will decrease participation. How about a form that sends email to the list?

Put a button in the docs sidebar that pops up the form, you’re good to go.

Definitely not ideal, but it’s cheap.

Matthew Butterick had a nice comment form on http://beautifulracket.com/, but it seems to be gone

Not gone, just more subtle. Click on the flag on the left of the paragraph.

I used that form a lot when first reading the book. It’s even more effective than a GitHub link. More noisy, too.

You mean the flag that does not exist until I point my mouse, not at the thing I’m interested in, but to the left of the thing I’m interested in?

Yes, that one :slightly_smiling_face:

And doesn’t exist at all if I’m using NoScript?

You got it. Exactly that! :slightly_smiling_face:

A thing which I grant you relatively few people will be using, but the ones who are will disproportionately be programmers — the exact audience of this material.

Previously, the form appeared just by clicking on the paragraph. I have to say I prefer it like it’s now. It was always getting in my way before :stuck_out_tongue:

On the subject of UI, why does http://pkgs.racket-lang.org\|pkgs.racket-lang.org have such a non-standard system for account creation / password update / reset?

And package upload, for that matter?

twas an act of god. Try http://pkgn.racket-lang.org\|pkgn.racket-lang.org

Are you referring to how it sends a token on your email before it asks for a password?

Standard UX for uploading something is: form appears, fill in fields on form, browse to file, click ‘submit’. Not “things magically update in the background and the package appears on the live listing with no notice to the user at some point during the updating process that I am not actually certain of.”

> Are you referring to how it sends a token on your email before it asks for a password?

I hadn’t even noticed that one but yes, let’s go with it. Also, standard UX would be:

1) Click: Login 2) IF you have an account, fill in fields + click Submit ELSIF want-an-account, click “Don’t have an account? Register!” ELSIF need-reset, click “Forgot password?”

Pull requests are welcomed. But my guess is that Racket does not have many UX designers contributing to the project.

@ben’s link is better, though.

That’s my point, though — this isn’t the standard.

Basically every single site in existence does it the way I’ve described. Someone had to actually sit down and think this up. It feels like the person who wrote the page had just discovered async JS and wanted to use it for everything.

Right? Can you name another site that handles login/register/reset the way pkgs does?

My main UX problem with http://pkgX.racket-lang.org\|pkgX.racket-lang.org is one you didn’t mention: the page forgets that I was logged in, and I have to click on Login. But then it remember without me having to type in my password :stuck_out_tongue:

@dstorrs http://pkgs.racket-lang.org\|pkgs.racket-lang.org was indeed developed by someone who prefers that style of interaction

but most other people don’t

which is part of why a new UI was built, which will become the main one soon

Racket does a lot of things differently from other programming languages. Can you name another language with the same macro system? (I agree with you, fwiw, but the site is open source.)

But, regarding the signup process (I signed up two days ago) my thought was “hey, this is different; and it’s also cool! Prevents someone from signing up with my email on a service that I’ll someday want to sign up myself.” Admittedly, that never happened. But it’s cool anyway :slightly_smiling_face:

@leafac I haven’t seen the behavior you describe on http://pkgn.racket-lang.org\|pkgn.racket-lang.org, but if you do you can report a bug here: https://github.com/tonyg/racket-pkg-website/

I guess I should, shouldn’t I? https://github.com/tonyg/racket-pkg-website/issues/37 :slightly_smiling_face:

@mflatt Hi! It looks like racket/pkgs/scribble-lib/scribble/scribble-load.tex defines \newcommand{\renewrmdefault}{\renewcommand{\rmdefault}{ptm}} which defeats the settings of acmart. What is the recommended way to override this setting? (trying to get it working with @leif)

OK, looks like I can put \renewcommand{\renewrmdefault}{\relax} in my acmart/style.tex and that takes care of it.

But that gets evaluated too late. So instead I re-redefine \rmdefault to restore libertine with \renewcommand{\rmdefault}{LinuxLibertineT-OsF}