If I have two modules `foo` and `foo/extra-thing`, and `foo` requires and
re-provides all the exports of `foo/extra-thing`, how do I correctly
document that fact with `defmodule` and `declare-exporting`? The
documentation for those two scribble forms doesn't include examples, the
grammars for
Just an interesting thing. I restarted work back at a place that I left
several years back where we still use a custom IDE written in PLT Scheme
4.25, just before it became Racket. It's about 25K lines of GUI. Out of
curiosity, I recompiled everything today on 7.2.0.6 Chez racket. I ran
At Fri, 22 Feb 2019 16:34:24 -0500, Jon Zeppieri wrote:
> On a related (but not too related) note: is there an efficient way to skip
> multiple bytes in an input stream? It looks like there are two choices:
> - You can read the bytes you want to skip, but that implies either
> allocating a
At Sat, 2 Mar 2019 12:24:22 -0500, Jon Zeppieri wrote:
> By contrast, the same file parses in roughly 160ms with the json
> module that ships with racket.
> [...]
> So I tested the existing library on the file, under racket-cs. (Actually, I
> think the version that came with this racket-cs build
A `#lang scribble/base` module just defines and provides `doc` as an
instance of `part`, and `include-section` imports and returns that
`doc`. That is,
@include-section["x.scrbl"]
is equivalent to
@(require (rename-in "x.scrbl" [doc x:doc]))
@x:doc
You could instead extract the part's flow
On 3/2/2019 12:24 PM, Jon Zeppieri wrote:
[http://www.serpentine.com/blog/2011/02/25/cps-is-great-cps-is-terrible/]
??? OpenDNS is blocking access to that site due to some unspecified
security threat.
George
--
You received this message because you are subscribed to the Google Groups
Scribble's include-section is great for splitting the document source into
multiple files. I'm looking for a way to inject content from another file
without making a numbered section.
The motivation for this is to create problem sets for my math classes in a
way that I could keep each question
After the recent discussion on json parsing performance, I spent some time
doing a quick port of enough of attoparsec and aeson (haskell libraries
providing, respectively, byte-oriented parser combinators and json parsing)
to do some testing.
The result: really slow. (This is where the puzzlement
What is a portable, correct, efficient way to check whether one path
is "under" -- a direct or indirect subdir of -- another path?
AFAICT there's no racket/path function for this. Over the years I've
done various ad hoc things that seem non-ideal. Including: 1. Use
path->string and regexp. 2. Use
9 matches
Mail list logo