[racket-users] current racket dynamic web performance in production?

[Neil Van Dyke]

I'm now leading engineering at a startup with an established Python & 
Flask infrastructure, and happen to urgently need an additional dynamic 
Web&database service backend that's separate from the rest of our 
infrastructure...  While I could do it in Flask, I was thinking that 
this might also be an opportunity for a Scheme (Racket) pilot project 
for the company,[1] looking ahead to tech stack selection for some much 
larger infrastructure expected next year (if the startup survives the 
virus).


The problem with this as a pilot project is that this server will see 
only very light duty, and therefore not good for evaluating real world 
viability for the expected future high-traffic needs.


So I was wondering whether anyone (other than HN, and the bespoke 
framework stuff I worked on atop the `scgi` package) is currently using 
Racket for dynamic HTTP/S backend in a *high traffic* setup? And if you 
are handling high traffic, what kinds of performance are you seeing 
(e.g., request volume, simultaneous requests, latency, GC 
characteristics), and how have you built it (e.g., which HTTP libraries, 
what kind of server infrastructure)?



[1] A similar urgent new server in Racket has happened before. 
https://lists.racket-lang.org/users/archive/2009-October/036244.html


--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/432ed847-1de9-3c89-8c77-d756ad376eff%40neilvandyke.org.

Re: [racket-users] Poor documentation of List*

[Ryan Culpepper]

`(List* T)` is the same as `T`, just as `(list* x)` is the same as `x`
(whether `x` is a list or not).

  > (require typed/racket)
  > (list* 4 5 6)
  - : (List* Positive-Byte Positive-Byte Positive-Byte)
  '(4 5 . 6)
  > (list* 6)
  - : Integer [more precisely: Positive-Byte]
  6
  > (:type (List* String))
  String

Ryan


On Wed, Jun 3, 2020 at 9:49 PM Hendrik Boom  wrote:

> On Wed, Jun 03, 2020 at 04:22:41PM +0100, Stephen De Gabrielle wrote:
> > Hi Hendrik,
> >
> > I can't see the example you mention in
> >
> https://docs.racket-lang.org/ts-reference/type-ref.html#%28form._%28%28lib._typed-racket%2Fbase-env%2Fbase-types-extra..rkt%29._.List%2A%29%29
> >
> > i'm assuming (List* c) is shorthand for (Pair c null)? I don't know typed
> > racket so I've probably got that terribly wrong.
>
> It might be.  But that's normally said as (List c), not List* c)
> With your interpretation, List* qould be equivalent to List.
>
> >
> > So while I can't help you with this - I wanted to encourage you to make a
> > PR to the documentation if you come up with a fix.
>
> My problem is that I don't know what the documentation is supposed to say.
>
> -- hendrik
>
> > It *used* to be hard to find the file that needs the fix, good steps have
> > been made recently to make it easier to identify the documentation source
> > file so it is easier to find and make the corrections or additions.
> >
> > If you have any trouble let me know and I'll try help - I think I'm
> > getting the hang of it.
> >
> > Hope you are well
> >
> > Kind regards
> >
> > Stephen
> >
> > ps i use
> >
> https://blog.racket-lang.org/2017/09/tutorial-contributing-to-racket.html
> &
> > lots of kind guidance from other racketeers :0
> > pps: if you make a successful pr you get credit in the frankly wonderful
> > racket news https://racket-news.com/2020/06/racket-news-issue-32.html
> >
> > On Tue, Jun 2, 2020 at 3:13 PM Hendrik Boom 
> wrote:
> >
> > > In the Typed Racket Reference, List* is defined as follows:
> > >
> > > (List* t t1 ... s)
> > >
> > > is equivalent to (Pairof t (List* t1 ... s)).
> > >
> > > Following this definition down, we get
> > >
> > > (List* a b c)
> > >  -> (Pairof a (List* b c))
> > >  -> (Pairof a (Pairof b (List* c)))
> > >
> > > But what's (List* c) ?
> > >
> > > I see no explanatory examples.
> > >
> > > -- hendrik
> > >
> > > P.S.  I'm also unsure what 'bound' is supposed to do in
> > >
> > > (List t ... trest ... bound)
> > >
> > > It says "where bound must be an identifier denoting a type variable
> > > bound with ..." but I don't undestand what this is referring to.
> > >
> > > There are no examples of this in the document, just as there are no
> > > examples of List*.
> > >
> > > -- hendrik
> > >
> > > --
> > > You received this message because you are subscribed to the Google
> Groups
> > > "Racket Users" group.
> > > To unsubscribe from this group and stop receiving emails from it, send
> an
> > > email to racket-users+unsubscr...@googlegroups.com.
> > > To view this discussion on the web visit
> > >
> https://groups.google.com/d/msgid/racket-users/20200602141347.3z7igvzbjyikhfn4%40topoi.pooq.com
> > > .
> > >
> >
> > --
> > You received this message because you are subscribed to the Google
> Groups "Racket Users" group.
> > To unsubscribe from this group and stop receiving emails from it, send
> an email to racket-users+unsubscr...@googlegroups.com.
> > To view this discussion on the web visit
> https://groups.google.com/d/msgid/racket-users/CAGHj7-LsML%2BeOnt_BUBWmRM5vU6GtovyaNr-JHOQPzoMCL2NTQ%40mail.gmail.com
> .
>
> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users+unsubscr...@googlegroups.com.
> To view this discussion on the web visit
> https://groups.google.com/d/msgid/racket-users/20200603194902.27zjystdhecumoup%40topoi.pooq.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CANy33qkhzs-fEkORpdQ3dH3qcu%2BoXRrOpAxM5%3DffLn6kwpXTFQ%40mail.gmail.com.

Re: [racket-users] Poor documentation of List*

[Sam Tobin-Hochstadt]

`(List* T)` is just `T`. This follows the behavior of the `list*`
function, where `(list* 5)` produces 5.

You can explore this using the `:type` form at the REPL. For example,

```
> (:type (List* String))
String
> (:type (List* String String))
(Pairof String String)
> (:type (List* String (List String)))
(List String String)
```

I've pushed a clarification to the documentation.

On Wed, Jun 3, 2020 at 3:49 PM Hendrik Boom  wrote:
>
> On Wed, Jun 03, 2020 at 04:22:41PM +0100, Stephen De Gabrielle wrote:
> > Hi Hendrik,
> >
> > I can't see the example you mention in
> > https://docs.racket-lang.org/ts-reference/type-ref.html#%28form._%28%28lib._typed-racket%2Fbase-env%2Fbase-types-extra..rkt%29._.List%2A%29%29
> >
> > i'm assuming (List* c) is shorthand for (Pair c null)? I don't know typed
> > racket so I've probably got that terribly wrong.
>
> It might be.  But that's normally said as (List c), not List* c)
> With your interpretation, List* qould be equivalent to List.
>
> >
> > So while I can't help you with this - I wanted to encourage you to make a
> > PR to the documentation if you come up with a fix.
>
> My problem is that I don't know what the documentation is supposed to say.
>
> -- hendrik
>
> > It *used* to be hard to find the file that needs the fix, good steps have
> > been made recently to make it easier to identify the documentation source
> > file so it is easier to find and make the corrections or additions.
> >
> > If you have any trouble let me know and I'll try help - I think I'm
> > getting the hang of it.
> >
> > Hope you are well
> >
> > Kind regards
> >
> > Stephen
> >
> > ps i use
> > https://blog.racket-lang.org/2017/09/tutorial-contributing-to-racket.html &
> > lots of kind guidance from other racketeers :0
> > pps: if you make a successful pr you get credit in the frankly wonderful
> > racket news https://racket-news.com/2020/06/racket-news-issue-32.html
> >
> > On Tue, Jun 2, 2020 at 3:13 PM Hendrik Boom  wrote:
> >
> > > In the Typed Racket Reference, List* is defined as follows:
> > >
> > > (List* t t1 ... s)
> > >
> > > is equivalent to (Pairof t (List* t1 ... s)).
> > >
> > > Following this definition down, we get
> > >
> > > (List* a b c)
> > >  -> (Pairof a (List* b c))
> > >  -> (Pairof a (Pairof b (List* c)))
> > >
> > > But what's (List* c) ?
> > >
> > > I see no explanatory examples.
> > >
> > > -- hendrik
> > >
> > > P.S.  I'm also unsure what 'bound' is supposed to do in
> > >
> > > (List t ... trest ... bound)
> > >
> > > It says "where bound must be an identifier denoting a type variable
> > > bound with ..." but I don't undestand what this is referring to.
> > >
> > > There are no examples of this in the document, just as there are no
> > > examples of List*.
> > >
> > > -- hendrik
> > >
> > > --
> > > You received this message because you are subscribed to the Google Groups
> > > "Racket Users" group.
> > > To unsubscribe from this group and stop receiving emails from it, send an
> > > email to racket-users+unsubscr...@googlegroups.com.
> > > To view this discussion on the web visit
> > > https://groups.google.com/d/msgid/racket-users/20200602141347.3z7igvzbjyikhfn4%40topoi.pooq.com
> > > .
> > >
> >
> > --
> > You received this message because you are subscribed to the Google Groups 
> > "Racket Users" group.
> > To unsubscribe from this group and stop receiving emails from it, send an 
> > email to racket-users+unsubscr...@googlegroups.com.
> > To view this discussion on the web visit 
> > https://groups.google.com/d/msgid/racket-users/CAGHj7-LsML%2BeOnt_BUBWmRM5vU6GtovyaNr-JHOQPzoMCL2NTQ%40mail.gmail.com.
>
> --
> You received this message because you are subscribed to the Google Groups 
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to racket-users+unsubscr...@googlegroups.com.
> To view this discussion on the web visit 
> https://groups.google.com/d/msgid/racket-users/20200603194902.27zjystdhecumoup%40topoi.pooq.com.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAK%3DHD%2BaadfxxY%2Bv1gngVPzegOCSU2qR_EPTavj3E9hutTJXJ3Q%40mail.gmail.com.

Re: [racket-users] Poor documentation of List*

[Hendrik Boom]

On Wed, Jun 03, 2020 at 04:22:41PM +0100, Stephen De Gabrielle wrote:
> Hi Hendrik,
> 
> I can't see the example you mention in
> https://docs.racket-lang.org/ts-reference/type-ref.html#%28form._%28%28lib._typed-racket%2Fbase-env%2Fbase-types-extra..rkt%29._.List%2A%29%29
> 
> i'm assuming (List* c) is shorthand for (Pair c null)? I don't know typed
> racket so I've probably got that terribly wrong.

It might be.  But that's normally said as (List c), not List* c)
With your interpretation, List* qould be equivalent to List.

> 
> So while I can't help you with this - I wanted to encourage you to make a
> PR to the documentation if you come up with a fix.

My problem is that I don't know what the documentation is supposed to say.

-- hendrik

> It *used* to be hard to find the file that needs the fix, good steps have
> been made recently to make it easier to identify the documentation source
> file so it is easier to find and make the corrections or additions.
> 
> If you have any trouble let me know and I'll try help - I think I'm
> getting the hang of it.
> 
> Hope you are well
> 
> Kind regards
> 
> Stephen
> 
> ps i use
> https://blog.racket-lang.org/2017/09/tutorial-contributing-to-racket.html &
> lots of kind guidance from other racketeers :0
> pps: if you make a successful pr you get credit in the frankly wonderful
> racket news https://racket-news.com/2020/06/racket-news-issue-32.html
> 
> On Tue, Jun 2, 2020 at 3:13 PM Hendrik Boom  wrote:
> 
> > In the Typed Racket Reference, List* is defined as follows:
> >
> > (List* t t1 ... s)
> >
> > is equivalent to (Pairof t (List* t1 ... s)).
> >
> > Following this definition down, we get
> >
> > (List* a b c)
> >  -> (Pairof a (List* b c))
> >  -> (Pairof a (Pairof b (List* c)))
> >
> > But what's (List* c) ?
> >
> > I see no explanatory examples.
> >
> > -- hendrik
> >
> > P.S.  I'm also unsure what 'bound' is supposed to do in
> >
> > (List t ... trest ... bound)
> >
> > It says "where bound must be an identifier denoting a type variable
> > bound with ..." but I don't undestand what this is referring to.
> >
> > There are no examples of this in the document, just as there are no
> > examples of List*.
> >
> > -- hendrik
> >
> > --
> > You received this message because you are subscribed to the Google Groups
> > "Racket Users" group.
> > To unsubscribe from this group and stop receiving emails from it, send an
> > email to racket-users+unsubscr...@googlegroups.com.
> > To view this discussion on the web visit
> > https://groups.google.com/d/msgid/racket-users/20200602141347.3z7igvzbjyikhfn4%40topoi.pooq.com
> > .
> >
> 
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to racket-users+unsubscr...@googlegroups.com.
> To view this discussion on the web visit 
> https://groups.google.com/d/msgid/racket-users/CAGHj7-LsML%2BeOnt_BUBWmRM5vU6GtovyaNr-JHOQPzoMCL2NTQ%40mail.gmail.com.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/20200603194902.27zjystdhecumoup%40topoi.pooq.com.

Re: [racket-users] Re: How to make DrRacket interactions window use the same reader as the definitions window?

[Matthew Flatt]

At Fri, 29 May 2020 09:25:58 -0700 (PDT), Thomas Dickerson wrote:
> On Friday, May 29, 2020 at 11:29:38 AM UTC-4, Matthew Flatt wrote:
> > DrRacket uses `pretty-print`, which will print numbers using 
> > `number->string`, and so (I think) won't go through your parameter. 
> 
> This sounds like a good lead - curious if this also applies to
> `write` and `display` as well? I was having trouble with all three.

The pretty print hooks apply only to `pretty-print`, `pretty-write`,
and `pretty-display`. They may be most useful when implementing a
printer by calling `pretty-print`, etc., instead of setting the hooks
globally and expecting that pretty-print` is used.

> > I think there may be problems with parametering the core printer, 
> > partly because printing is is sometimes used where `read` is supposed 
> > to work on the result, but I think there may be other issues and I 
> > haven't thought through them enough. 
> >
> 
> The intended use is in a setting where `read` has already been extended 
> (cf. my original question in this thread, which is that the DrRacket 
> interactions window appears to ignore any `read` extensions provided by a 
> #lang)

It's possible to globally extend `read` via a readtable, but there's
also `call-with-default-reading-parameterization`, which various
libraries use to make sure they have the default reader settings (e.g.,
when reading a preferences file). There's not currently anything that
libraries can use like `call-with-default-writing-parameterization`,
which means that globally changing `write` could break libraries.

Meanwhile, it's possible to change the `print` function more globally
through `global-port-print-handler`.

Finally, there's `display`. I think `display` in principle should be
more configurable, because it's meant to about how things are displayed
for humans to read. 

These different approaches, with a relatively flexible reader and and a
relatively inflexible writer, evolved as a result of various pressures.
I think the write side is a little closer to right idea with its
distinction between `write` for serialization, `print` for displaying
values, and `display` for showing things for humans. (On the read,
side, we could have done better by making a cleaner separation between
`read` and `read-syntax`. Still, it's complicated.)

I think a variant of your PR that just affects `display` may be ok, and
it would be worth exploring if that solves a problem. Given that
`print` and `display` seem safely configurable, the question is whether
you want to modify `write` just because that's a third printing
function or because it's important in your target use.

If, for example, your language wants to provide a `write` that isn't
the Racket serialization write, it can always provide a different
function as `write`. That won't affect other libraries that may be
called by programs in your language, but my point is that it generally
shouldn't; those libraries should be using `write` for
serialization-type purposes.

At Fri, 29 May 2020 13:24:17 -0700 (PDT), Thomas Dickerson wrote:
> Quick follow-up: 
> It looks like I may somehow be able to change DrRacket's printing and 
> reading behavior on a per-language basis somehow using the classes here 

I don't think you want that layer of tools. At the DrRacket layer, you
want to stay in the `#lang` world --- so, don't do anything
DrRacket-specific.

At the level of the `#lang`/module system, a language can parameterize
run-time functionality, such as the reader and printer, through a
`configure-runtime` submodule. See

https://docs.racket-lang.org/guide/module-runtime-config.html

and

https://docs.racket-lang.org/reference/running-sa.html#%28part._configure-runtime%29

So, that's the place where you'd update the reader, printer, and
displayer.

> One question - to what extent are pretty-print-print-hooks expected to 
> cooperate with the current value of that parameter when printing compound 
> or recursive values?
> It would be great to install a hook that delegates to the existing hook for 
> everything but numbers, but that approach not working with 
> port-print-handler et al. is what led me to parameterizing over all of 
> print et al.

>From a language implementation perspective where you're setting the
global print handler to use `pretty-print`, your language gets to set
the starting point, and libraries as used by programs in your language
can cooperate with it by extending (instead of replacing) the printer.

So, I think you'd want to make the language use `pretty-print` and
recur as needed (which is not at all for just changing numbers) to
allow library-based extensions.

At Fri, 29 May 2020 17:06:14 -0400, Thomas Dickerson wrote:
> Interesting - does the default #%top-interaction behave differently from
> #%module-begin w.r.t. to a #lang's read?
> Right now my main.rkt is providing the standard #%module-begin,
> #%top-interaction, #%app, #%datum, and #%top, in addition to my language's
> functions + macros.

Re: [racket-users] Poor documentation of List*

[Stephen De Gabrielle]

Hi Hendrik,

I can't see the example you mention in
https://docs.racket-lang.org/ts-reference/type-ref.html#%28form._%28%28lib._typed-racket%2Fbase-env%2Fbase-types-extra..rkt%29._.List%2A%29%29

i'm assuming (List* c) is shorthand for (Pair c null)? I don't know typed
racket so I've probably got that terribly wrong.

So while I can't help you with this - I wanted to encourage you to make a
PR to the documentation if you come up with a fix.
It *used* to be hard to find the file that needs the fix, good steps have
been made recently to make it easier to identify the documentation source
file so it is easier to find and make the corrections or additions.

If you have any trouble let me know and I'll try help - I think I'm
getting the hang of it.

Hope you are well

Kind regards

Stephen

ps i use
https://blog.racket-lang.org/2017/09/tutorial-contributing-to-racket.html &
lots of kind guidance from other racketeers :0
pps: if you make a successful pr you get credit in the frankly wonderful
racket news https://racket-news.com/2020/06/racket-news-issue-32.html

On Tue, Jun 2, 2020 at 3:13 PM Hendrik Boom  wrote:

> In the Typed Racket Reference, List* is defined as follows:
>
> (List* t t1 ... s)
>
> is equivalent to (Pairof t (List* t1 ... s)).
>
> Following this definition down, we get
>
> (List* a b c)
>  -> (Pairof a (List* b c))
>  -> (Pairof a (Pairof b (List* c)))
>
> But what's (List* c) ?
>
> I see no explanatory examples.
>
> -- hendrik
>
> P.S.  I'm also unsure what 'bound' is supposed to do in
>
> (List t ... trest ... bound)
>
> It says "where bound must be an identifier denoting a type variable
> bound with ..." but I don't undestand what this is referring to.
>
> There are no examples of this in the document, just as there are no
> examples of List*.
>
> -- hendrik
>
> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users+unsubscr...@googlegroups.com.
> To view this discussion on the web visit
> https://groups.google.com/d/msgid/racket-users/20200602141347.3z7igvzbjyikhfn4%40topoi.pooq.com
> .
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAGHj7-LsML%2BeOnt_BUBWmRM5vU6GtovyaNr-JHOQPzoMCL2NTQ%40mail.gmail.com.

[racket-users] Re: Some stuff about "case".

[Jack Firth]

Isn't that just match with the == pattern?

(let ([x 'foo])
  (match 'foo
[(== x) 'got-foo]
['x 'got-quote-x])) ; => 'got-foo

On Monday, June 1, 2020 at 11:54:01 AM UTC-7, cwebber wrote:
>
> As I started typing this email and looking into the definition of case, 
> I realized my assumptions are wrong. 
>
> What I needed: something like case which dispatches on symbols, except 
> not auto-quoting the arguments... I needed to evaluate them from the 
> lexical environment.  So: 
>
>   (let ([x 'foo]) 
> (caseish 'foo 
>   [(x) 'got-foo] 
>   [('x) 'got-quote-x]))  ; => 'got-foo 
>
> I figured: case is fast, and I'm pretty sure semi-magical... my 
> intuitive sense was that it did some smart things on a compiler level 
> that would probably be anything I'd hand-code (which would either use an 
> alist or an immutable hashtable).  So I started writing up an email 
> asking if such a thing worked... then I remembered, this is a ~lisp, 
> jumping straight to definition is part of the scene... so I did that. 
> 
> I... was wrong!  From the case macro: 
>
> ;; Symbol and "other" dispatch is either sequential or 
> ;; hash-table-based, depending on how many constants we 
> ;; have. Assume that `alist' does not map anything to `#f'. 
> (define (dispatch-hashable tmp-stx alist make-hashX else-exp) 
>   (if (< (length alist) *hash-threshold*) 
>   #`(case/sequential #,tmp-stx 
>  #,@(map (λ (x) 
>#`[(#,(car x)) #,(cdr x)]) 
>  alist) 
>  [else #,else-exp]) 
>   (let ([tbl (make-hashX alist)]) 
> (if (literal-expression? else-exp) 
> #`(hash-ref #,tbl #,tmp-stx (lambda () #,else-exp)) 
> #`(or (hash-ref #,tbl #,tmp-stx (lambda () #f)) 
>   #,else-exp) 
>
> Am I reading that right?  Here I was assuming writing something like 
> case was for cool kids and I'd never pull such a thing off right. 
>
> But... now it looks like, oh, it's actually just using an alist or an 
> immutable hashtable... same as I would. 
>
> So I almost trashed this email, but thought I'd send it anyway because 
> a) either maybe it's interesting to someone or b) actually maybe I'm 
> misreading and case really is smarter / more performant and I'm just 
> missing it...! 
>
>  - Chris 
>
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/31189b98-2711-448f-90d1-962f2f0bda0a%40googlegroups.com.

[racket-users] Re: foldts-test-suite

[Jack Firth]

Nope. A well-designed replacement for those APIs is sorely needed.

On Tuesday, June 2, 2020 at 6:37:17 PM UTC-7, Alex Harsanyi wrote:
>
>
> Are there alternatives to the `folds-test-suite` and `fold-test-results` 
> functions, for people who want to write their own test running and 
> reporting for Rackunit tests?
>
> Alex.
>
> On Wednesday, June 3, 2020 at 2:00:02 AM UTC+8, Jack Firth wrote:
>>
>> The test case folding stuff in RackUnit should mostly be ignored, instead 
>> of extended.
>>
>> On Saturday, May 23, 2020 at 7:52:21 AM UTC-7, Shriram Krishnamurthi 
>> wrote:
>>>
>>> The documentation
>>>
>>>
>>> https://docs.racket-lang.org/rackunit/internals.html?q=run-test-case#%28def._%28%28lib._rackunit%2Fmain..rkt%29._foldts-test-suite%29%29
>>>
>>> says that `folds-test-suite` can be implemented in terms of 
>>> `fold-test-results` as follows:
>>>
>>> (define 
>>> 
>>>  (fold-test-results 
>>> 
>>>  suite-fn case-fn seed test)
>>>   (foldts-test-suite 
>>> 
>>>(lambda 
>>> 
>>>  (suite name before 
>>> 
>>>  after 
>>> 
>>>  seed)
>>>  (before 
>>> 
>>> )
>>>  (suite-fn name seed))
>>>(lambda 
>>> 
>>>  (suite name before 
>>> 
>>>  after 
>>> 
>>>  seed kid-seed)
>>>  (after 
>>> 
>>> )
>>>  kid-seed)
>>>(lambda 
>>> 
>>>  (case 
>>> 
>>>  name action seed)
>>>  (case-fn
>>>(run-test-case 
>>> 
>>>  name action)
>>>seed))
>>>seed
>>>test))
>>>
>>> I'm curious why the value of `seed` in the second argument (the fup 
>>> position) — highlighted — is ignored. I was guessing that, since this is a 
>>> tree-fold, there are values "from across" and "from down", and we don't 
>>> want to throw either one away. Wouldn't we want to take a combinator that 
>>> combines the two?
>>>
>>> Shriram
>>>
>>>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/8902b15a-d3e7-4e27-8d65-4ba4dc7243bc%40googlegroups.com.