[racket-users] Re: Looking for idiomatic way to represent very similar but different data types

[jackh...@gmail.com]

To make your vector+ operation take an arbitrary number of arguments, this 
is what I'd do:

(define (vector+ . vectors)
  (vector
(for/sum ([v (in-list vectors)]) (vector-i v))
(for/sum ([v (in-list vectors)]) (vector-j v))
(for/sum ([v (in-list vectors)]) (vector-k v

(module+ test
  (test-case "vector+"
(check-equal? (vector+) (vector 0 0 0))
(check-equal? (vector+ (vector 1 2 3)) (vector 1 2 3))
(check-equal? (vector+ (vector 1 2 3) (vector 4 5 6)) (vector 5 7 9

I can see some value in abstracting over this, if you've got a *lot* of 
structs with mathy variable-arity operations on them. I personally might 
try to do something with reducers 
. I'm not fully sure 
how I'd go about it though. Rather than experiment with that I'd probably 
just prefer to write the boring boilerplate code.
On Monday, February 1, 2021 at 6:26:20 PM UTC-8 making-a-racket wrote:

> Turns out that I don't see a way to calculate the #:auto-value using the 
> constructor fields, so I don't see how to make something like
>
> (struct test (x y z [data #:auto])
>   #:auto-value #(x y z))
>
> work.
>
> So I've decided to go with something like this:
>
> (struct color (r g b) #:transparent)
> (struct vector (i j k) #:transparent)
> (struct point (x y z) #:transparent)
>
> (define/contract (tuple-map-elementwise proc tuple)
>   (-> (-> real? real?) (or/c vector? point? color?) (or/c vector? point? 
> color?))
>   (match tuple
> [(struct vector (i j k)) (vector (proc (vector-i tuple))
>  (proc (vector-j tuple))
>  (proc (vector-k tuple)))]
> [(struct point (x y z)) (point (proc (point-x tuple))
>(proc (point-y tuple))
>(proc (point-z tuple)))]
> [(struct color (r g b)) (color (proc (color-r tuple))
>(proc (color-g tuple))
>(proc (color-b tuple)))]))
>
> (define/contract (tuple-map-pairwise proc tuple1 tuple2)
>   (-> (-> real? real? real?) (or/c vector? point? color?) (or/c vector? 
> point? color?) (or/c vector? point? color?))
>   (match (list tuple1 tuple2)
> [(list (struct vector (i1 j1 k1)) (struct vector (i2 j2 k2)))
>  (vector (proc (vector-i tuple1) (vector-i tuple2))
>  (proc (vector-j tuple1) (vector-j tuple2))
>  (proc (vector-k tuple1) (vector-k tuple2)))]
> [(list (struct point (x1 y1 z1)) (struct point (x2 y2 z2)))
>  (point (proc (point-x tuple1) (point-x tuple2))
> (proc (point-y tuple1) (point-y tuple2))
> (proc (point-z tuple1) (point-z tuple2)))]
> [(list (struct color (r1 g1 b1)) (struct color (r2 g2 b2)))
>  (color (proc (color-r tuple1) (color-r tuple2))
> (proc (color-g tuple1) (color-g tuple2))
> (proc (color-b tuple1) (color-b tuple2)))]))
>
> (define (tuple-op-by-constant op tuple c)
>   (tuple-map-elementwise (λ (e) (op e c)) tuple))
>
> (define (tuple-op-pairwise op t1 t2 . tuples)
>   (cond [(empty? tuples) (tuple-map-pairwise op t1 t2)]
> [else (apply tuple-op-pairwise op
>  (tuple-map-pairwise op t1 t2)
>  (car tuples)
>  (cdr tuples))]))
>
> (define (vector+c v c)
>   (tuple-op-by-constant + v c))
>
> (define (vector*c v c)
>   (tuple-op-by-constant * v c))
>
> (define (vector+ u v . vectors)
>   (apply tuple-op-pairwise + u v vectors))
>
> (define (vector- u v . vectors)
>   (apply tuple-op-pairwise - u v vectors))
>
> Then I'll do something similar for points and colors. This library will 
> probably be converted to Typed Racket, so the contracts are only temporary.
>
> This seems to be the cleanest solution I think, and it's actually quite 
> similar to the F# code I've written for the same project.
>
> I know this seems simple, but wanted to check on people's thoughts on 
> idiomatic ways in Racket, and to make sure I wasn't missing some secret 
> sauce of structs or something else.
>
>
> On Monday, February 1, 2021 at 4:38:37 PM UTC-6 making-a-racket wrote:
>
>> Apologies. By fourth optional argument, I meant a fourth field with the 
>> #auto field option. I'm experimenting with this now.
>>
>> On Monday, February 1, 2021 at 3:24:49 PM UTC-6 making-a-racket wrote:
>>
>>> Thanks for the suggestion and for the macro implementation. I'll have to 
>>> pour over that a bit.
>>>
>>> I wanted to do map because I wanted to make it easy to idiomatically 
>>> implement addition and other such operators on my data types such that they 
>>> accept arbitrary amounts of arguments and provide the map for other uses.
>>>
>>> So that's why the vector (in the Racket sense) is the most simple option 
>>> in that respect, since I can trivially do:
>>>
>>> (define (sum-vector v)
>>> (apply + (vector->list v)))
>>>
>>> (define (vector+ . vs)
>>>   

[racket-users] Re: How to draw an arc with module `graphics/turtles`?

[making-a-racket]

Turtles can only turn or move forward with or without drawing. To draw an 
arc, you'll need to combine these methods to do that.

I highly recommend the book *Turtle Geometry* by Abelson and diSessa 
.
 
Below you can find an excerpt of the book that talks about drawing circles 
and arcs.

[image: turtle.PNG]

Here's an implementation of a circle in Racket using the turtle library you 
referenced.

#lang racket

(require graphics/turtles)

(turtles #t)

(for ([i (in-range 360)])
  (draw 1)
  (turn 1))

On Monday, February 1, 2021 at 5:54:05 PM UTC-6 zhuo...@gmail.com wrote:

> I am imitating the Logo API to draw some shapes with `graphics/turtles`, 
> but in it I only find functions to draw lines, is there a way to draw an 
> arc?
>
>
>
> Greetings.
>
> Killian Zhuo (KDr2, https://kdr2.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/aea4ad53-162e-4924-87ed-1e7311c2aef3n%40googlegroups.com.

[racket-users] Re: Looking for idiomatic way to represent very similar but different data types

[making-a-racket]

Turns out that I don't see a way to calculate the #:auto-value using the 
constructor fields, so I don't see how to make something like

(struct test (x y z [data #:auto])
  #:auto-value #(x y z))

work.

So I've decided to go with something like this:

(struct color (r g b) #:transparent)
(struct vector (i j k) #:transparent)
(struct point (x y z) #:transparent)

(define/contract (tuple-map-elementwise proc tuple)
  (-> (-> real? real?) (or/c vector? point? color?) (or/c vector? point? 
color?))
  (match tuple
[(struct vector (i j k)) (vector (proc (vector-i tuple))
 (proc (vector-j tuple))
 (proc (vector-k tuple)))]
[(struct point (x y z)) (point (proc (point-x tuple))
   (proc (point-y tuple))
   (proc (point-z tuple)))]
[(struct color (r g b)) (color (proc (color-r tuple))
   (proc (color-g tuple))
   (proc (color-b tuple)))]))

(define/contract (tuple-map-pairwise proc tuple1 tuple2)
  (-> (-> real? real? real?) (or/c vector? point? color?) (or/c vector? 
point? color?) (or/c vector? point? color?))
  (match (list tuple1 tuple2)
[(list (struct vector (i1 j1 k1)) (struct vector (i2 j2 k2)))
 (vector (proc (vector-i tuple1) (vector-i tuple2))
 (proc (vector-j tuple1) (vector-j tuple2))
 (proc (vector-k tuple1) (vector-k tuple2)))]
[(list (struct point (x1 y1 z1)) (struct point (x2 y2 z2)))
 (point (proc (point-x tuple1) (point-x tuple2))
(proc (point-y tuple1) (point-y tuple2))
(proc (point-z tuple1) (point-z tuple2)))]
[(list (struct color (r1 g1 b1)) (struct color (r2 g2 b2)))
 (color (proc (color-r tuple1) (color-r tuple2))
(proc (color-g tuple1) (color-g tuple2))
(proc (color-b tuple1) (color-b tuple2)))]))

(define (tuple-op-by-constant op tuple c)
  (tuple-map-elementwise (λ (e) (op e c)) tuple))

(define (tuple-op-pairwise op t1 t2 . tuples)
  (cond [(empty? tuples) (tuple-map-pairwise op t1 t2)]
[else (apply tuple-op-pairwise op
 (tuple-map-pairwise op t1 t2)
 (car tuples)
 (cdr tuples))]))

(define (vector+c v c)
  (tuple-op-by-constant + v c))

(define (vector*c v c)
  (tuple-op-by-constant * v c))

(define (vector+ u v . vectors)
  (apply tuple-op-pairwise + u v vectors))

(define (vector- u v . vectors)
  (apply tuple-op-pairwise - u v vectors))

Then I'll do something similar for points and colors. This library will 
probably be converted to Typed Racket, so the contracts are only temporary.

This seems to be the cleanest solution I think, and it's actually quite 
similar to the F# code I've written for the same project.

I know this seems simple, but wanted to check on people's thoughts on 
idiomatic ways in Racket, and to make sure I wasn't missing some secret 
sauce of structs or something else.


On Monday, February 1, 2021 at 4:38:37 PM UTC-6 making-a-racket wrote:

> Apologies. By fourth optional argument, I meant a fourth field with the 
> #auto field option. I'm experimenting with this now.
>
> On Monday, February 1, 2021 at 3:24:49 PM UTC-6 making-a-racket wrote:
>
>> Thanks for the suggestion and for the macro implementation. I'll have to 
>> pour over that a bit.
>>
>> I wanted to do map because I wanted to make it easy to idiomatically 
>> implement addition and other such operators on my data types such that they 
>> accept arbitrary amounts of arguments and provide the map for other uses.
>>
>> So that's why the vector (in the Racket sense) is the most simple option 
>> in that respect, since I can trivially do:
>>
>> (define (sum-vector v)
>> (apply + (vector->list v)))
>>
>> (define (vector+ . vs)
>> (apply vector-map + vs)) 
>>
>> (define (vector-i v)
>> (vector-ref v 0))
>> ;; and so on
>>
>> The only think I don't get there are my wanted datatypes and associated 
>> predicates, since vectors, points, and colors would all be Racket vectors.
>>
>> I could almost do structs with a fourth optional argument that holds a 
>> Racket vector that never gets used explicitly by the "user" and build 
>> helper functions to properly update it, which is then used to build all the 
>> operator and other such functions.
>>
>> If I just do structs as I originally notated, how do you suggest I 
>> implement things like vector+ to take in arbitrary amounts of arguments?
>>  
>>
>> On Monday, February 1, 2021 at 12:48:19 AM UTC-6 jackh...@gmail.com 
>> wrote:
>>
>>> I'd suggest just going with the structs and making them transparent. 
>>> It's only three structs and only with a handful of fields, abstracting over 
>>> them with map and fold doesn't seem worth the added complexity IMO. But if 
>>> you'd really like to map and fold over structs, I highly recommend using 
>>> macros, `syntax-parse` and the 

[racket-users] How to draw an arc with module `graphics/turtles`?

['Killian Zhuo (KDr2)' via Racket Users]

I am imitating the Logo API to draw some shapes with `graphics/turtles`, but in 
it I only find functions to draw lines, is there a way to draw an arc?



Greetings.

Killian Zhuo (KDr2, https://kdr2.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/1537717969.925560.1612223641051%40mail.yahoo.com.

[racket-users] Re: Looking for idiomatic way to represent very similar but different data types

[making-a-racket]

Apologies. By fourth optional argument, I meant a fourth field with the 
#auto field option. I'm experimenting with this now.

On Monday, February 1, 2021 at 3:24:49 PM UTC-6 making-a-racket wrote:

> Thanks for the suggestion and for the macro implementation. I'll have to 
> pour over that a bit.
>
> I wanted to do map because I wanted to make it easy to idiomatically 
> implement addition and other such operators on my data types such that they 
> accept arbitrary amounts of arguments and provide the map for other uses.
>
> So that's why the vector (in the Racket sense) is the most simple option 
> in that respect, since I can trivially do:
>
> (define (sum-vector v)
> (apply + (vector->list v)))
>
> (define (vector+ . vs)
> (apply vector-map + vs)) 
>
> (define (vector-i v)
> (vector-ref v 0))
> ;; and so on
>
> The only think I don't get there are my wanted datatypes and associated 
> predicates, since vectors, points, and colors would all be Racket vectors.
>
> I could almost do structs with a fourth optional argument that holds a 
> Racket vector that never gets used explicitly by the "user" and build 
> helper functions to properly update it, which is then used to build all the 
> operator and other such functions.
>
> If I just do structs as I originally notated, how do you suggest I 
> implement things like vector+ to take in arbitrary amounts of arguments?
>  
>
> On Monday, February 1, 2021 at 12:48:19 AM UTC-6 jackh...@gmail.com wrote:
>
>> I'd suggest just going with the structs and making them transparent. It's 
>> only three structs and only with a handful of fields, abstracting over them 
>> with map and fold doesn't seem worth the added complexity IMO. But if you'd 
>> really like to map and fold over structs, I highly recommend using macros, 
>> `syntax-parse` and the struct-id 
>> 
>>  
>> syntax class to do so:
>>
>> (require (for-syntax syntax/parse/class/struct-id)
>>  syntax/parse/define)
>>
>> (define-simple-macro (struct-map type:struct-id instance-expr:expr 
>> map-function-expr:expr)
>>   (let ([map-function map-function-expr]
>> [instance instance-expr])
>> (type.constructor-id (map-function (type.accessor-id instance)) ...)))
>>
>> (struct point (x y z) #:transparent)
>>
>> ;; Outputs (point 2 3 4)
>> (struct-map point (point 1 2 3) add1)
>> On Sunday, January 31, 2021 at 4:20:03 PM UTC-8 making-a-racket wrote:
>>
>>> Hello. I have a project where I am needing to represent vectors (in the 
>>> mathematical sense), points, and colors. Both the vectors and points will 
>>> be 3D. I'm having trouble knowing what's an idiomatic way to represent and 
>>> interact with data types that are similar but different.
>>>
>>> In general, I could simply all represent them with a list or vector (in 
>>> the Racket sense). So I could have:
>>>
>>> (define (vector i j k) #(i j k))
>>> (define (point x y z) #(x y z))
>>>
>>> Then I could readily use the existing vector functions, such as 
>>> vector-map without having to define my own. But I don't super like this 
>>> because I have to define my own accessor functions like vector-i and 
>>> point-y and also don't get predicates like vector? for free.
>>>
>>> Another way is that I could use structs, but then I'm stuck implementing 
>>> things myself and across the structs. To avoid the latter point, I could 
>>> use pattern matching. So something like:
>>>
>>> (struct vector (i j k))
>>> (struct point (x y z))
>>>
>>> (define (tuple-map proc tuple)
>>>   (match tuple
>>> [(struct vector (i j k)) (vector (proc (vector-i tuple))
>>>  (proc (vector-j tuple))
>>>  (proc (vector-k tuple)))]
>>> [(struct point (x y z)) (point (proc (point-x tuple))
>>>(proc (point-y tuple))
>>>(proc (point-z tuple)))]
>>> [(struct color (r g b)) (color (proc (color-r tuple))
>>>(proc (color-g tuple))
>>>(proc (color-b tuple)))]))
>>>
>>> But of course, this map doesn't take multiple tuples. And this feels 
>>> awkward, because I'll need to implement other things, like fold. Map and 
>>> fold would be used in defining new operators on vectors and points, like 
>>> addition, normalization (for vectors only), etc.
>>>
>>> The ideal thing would be that I could define a struct for these types, 
>>> that had the accessor functions like vector-i and predicates likes 
>>> vector? but was actually represented by a vector (in the Racket sense) 
>>> underneath the hood. Does something like this exist in Racket (not classes 
>>> please).
>>>
>>> In F#, I did this same thing using F#'s records for the vector, point, 
>>> and color data types, and they inherited an ITuple interface 

[racket-users] Racket News - Issue 45 - The Anniversary Issue

[Paulo Matos]

Hi everyone,

Here's Racket News Issue 45, the anniversary issue. RN turns 2!
https://racket-news.com/2021/02/racket-news-issue-45.html

Enjoy!

Paulo Matos

-- 
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/f570-c8c5-472a-8350-82d7f95859a5n%40googlegroups.com.

[racket-users] Re: Looking for idiomatic way to represent very similar but different data types

[making-a-racket]

Thanks for the suggestion and for the macro implementation. I'll have to 
pour over that a bit.

I wanted to do map because I wanted to make it easy to idiomatically 
implement addition and other such operators on my data types such that they 
accept arbitrary amounts of arguments and provide the map for other uses.

So that's why the vector (in the Racket sense) is the most simple option in 
that respect, since I can trivially do:

(define (sum-vector v)
(apply + (vector->list v)))

(define (vector+ . vs)
(apply vector-map + vs)) 

(define (vector-i v)
(vector-ref v 0))
;; and so on

The only think I don't get there are my wanted datatypes and associated 
predicates, since vectors, points, and colors would all be Racket vectors.

I could almost do structs with a fourth optional argument that holds a 
Racket vector that never gets used explicitly by the "user" and build 
helper functions to properly update it, which is then used to build all the 
operator and other such functions.

If I just do structs as I originally notated, how do you suggest I 
implement things like vector+ to take in arbitrary amounts of arguments?
 

On Monday, February 1, 2021 at 12:48:19 AM UTC-6 jackh...@gmail.com wrote:

> I'd suggest just going with the structs and making them transparent. It's 
> only three structs and only with a handful of fields, abstracting over them 
> with map and fold doesn't seem worth the added complexity IMO. But if you'd 
> really like to map and fold over structs, I highly recommend using macros, 
> `syntax-parse` and the struct-id 
> 
>  
> syntax class to do so:
>
> (require (for-syntax syntax/parse/class/struct-id)
>  syntax/parse/define)
>
> (define-simple-macro (struct-map type:struct-id instance-expr:expr 
> map-function-expr:expr)
>   (let ([map-function map-function-expr]
> [instance instance-expr])
> (type.constructor-id (map-function (type.accessor-id instance)) ...)))
>
> (struct point (x y z) #:transparent)
>
> ;; Outputs (point 2 3 4)
> (struct-map point (point 1 2 3) add1)
> On Sunday, January 31, 2021 at 4:20:03 PM UTC-8 making-a-racket wrote:
>
>> Hello. I have a project where I am needing to represent vectors (in the 
>> mathematical sense), points, and colors. Both the vectors and points will 
>> be 3D. I'm having trouble knowing what's an idiomatic way to represent and 
>> interact with data types that are similar but different.
>>
>> In general, I could simply all represent them with a list or vector (in 
>> the Racket sense). So I could have:
>>
>> (define (vector i j k) #(i j k))
>> (define (point x y z) #(x y z))
>>
>> Then I could readily use the existing vector functions, such as 
>> vector-map without having to define my own. But I don't super like this 
>> because I have to define my own accessor functions like vector-i and 
>> point-y and also don't get predicates like vector? for free.
>>
>> Another way is that I could use structs, but then I'm stuck implementing 
>> things myself and across the structs. To avoid the latter point, I could 
>> use pattern matching. So something like:
>>
>> (struct vector (i j k))
>> (struct point (x y z))
>>
>> (define (tuple-map proc tuple)
>>   (match tuple
>> [(struct vector (i j k)) (vector (proc (vector-i tuple))
>>  (proc (vector-j tuple))
>>  (proc (vector-k tuple)))]
>> [(struct point (x y z)) (point (proc (point-x tuple))
>>(proc (point-y tuple))
>>(proc (point-z tuple)))]
>> [(struct color (r g b)) (color (proc (color-r tuple))
>>(proc (color-g tuple))
>>(proc (color-b tuple)))]))
>>
>> But of course, this map doesn't take multiple tuples. And this feels 
>> awkward, because I'll need to implement other things, like fold. Map and 
>> fold would be used in defining new operators on vectors and points, like 
>> addition, normalization (for vectors only), etc.
>>
>> The ideal thing would be that I could define a struct for these types, 
>> that had the accessor functions like vector-i and predicates likes 
>> vector? but was actually represented by a vector (in the Racket sense) 
>> underneath the hood. Does something like this exist in Racket (not classes 
>> please).
>>
>> In F#, I did this same thing using F#'s records for the vector, point, 
>> and color data types, and they inherited an ITuple interface (F#'s 
>> immutable, functional data types can implement interfaces). Can Racket's 
>> stucts inherit from interfaces? Is there something I can do with generics?
>>
>> Thanks for any help on this design.
>>
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe 

Re: [racket-users] Does password reset work on pkgs.racket-lang.org?

['John Clements' via Racket Users]

FWIW, I recall problems like this as well, about four years ago. I think we 
wound up resetting it manually, at the time. 

John

> On Feb 1, 2021, at 8:48 AM, Jay McCarthy  wrote:
> 
> I just checked it and I got an email, but it was put into spam.
> 
> If you can't identify a problem on your side, contact me off list and
> we can debug together.
> 
> Jay
> 
> --
> Jay McCarthy
> Associate Professor @ CS @ UMass Lowell
> http://jeapostrophe.github.io
> Vincit qui se vincit.
> 
> On Sat, Jan 30, 2021 at 9:56 PM Danny Yoo  wrote:
>> 
>> Hi everyone,
>> 
>> Unfortunately, it looks like the password on my account 
>> (d...@hashcollision.org) on pkgd.racket-lang.org got compromised recently, 
>> so I'm trying to figure out how to reset it now.
>> 
>> I don't see an option to do so except in the Login page.  When I try to do 
>> so, I ask it to "Email me a code", but it doesn't seem to be working.  I've 
>> checked my spam folder just to check, but don't see it in there as well.  
>> Any suggestions?
>> 
>> Thanks in advance!
>> 
>> --
>> 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/32659ebf-55da-47a3-a459-6e664926bc67n%40googlegroups.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/CAJYbDanqK0%2BeQvFWXdi0w8Sa5Xfz7dtU-mMaySc%2BEiwAk3b_Dg%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/4ebaaf48-eecd-46e9-ae4b-571e2e1d843a%40mtasv.net.

Re: [racket-users] Does password reset work on pkgs.racket-lang.org?

[Jay McCarthy]

I just checked it and I got an email, but it was put into spam.

If you can't identify a problem on your side, contact me off list and
we can debug together.

Jay

--
Jay McCarthy
Associate Professor @ CS @ UMass Lowell
http://jeapostrophe.github.io
Vincit qui se vincit.

On Sat, Jan 30, 2021 at 9:56 PM Danny Yoo  wrote:
>
> Hi everyone,
>
> Unfortunately, it looks like the password on my account 
> (d...@hashcollision.org) on pkgd.racket-lang.org got compromised recently, so 
> I'm trying to figure out how to reset it now.
>
> I don't see an option to do so except in the Login page.  When I try to do 
> so, I ask it to "Email me a code", but it doesn't seem to be working.  I've 
> checked my spam folder just to check, but don't see it in there as well.  Any 
> suggestions?
>
> Thanks in advance!
>
> --
> 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/32659ebf-55da-47a3-a459-6e664926bc67n%40googlegroups.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/CAJYbDanqK0%2BeQvFWXdi0w8Sa5Xfz7dtU-mMaySc%2BEiwAk3b_Dg%40mail.gmail.com.