from:"Alexander D. Knauth"


On Aug 15, 2015, at 9:50 PM, Matthew Butterick m...@mbtype.com wrote:

 BTW, is it possible to extend your solution to macro-introduced imports from 
 a submodule?
 
 In the original case, the identifier name was known in advance:

 But suppose instead the identifiers come from a submodule. I see from the 
 docs for `all-from-out` that macro-introduced imports are not re-exported, 
 unless the module-path was introduced at the same time, so it feels like it 
 should go something like this, though this doesn't work (there's a difference 
 between the unquoted and quoted name that I'm not capturing).
 
 (define-syntax my-module-begin
   (lambda (stx)
 (syntax-case stx ()
   [(_ body ...)
(with-syntax ([sub-id (datum-syntax stx 'sub)])
  #'(#%module-begin
  (module sub-id racket/base
(define x 2)
(provide x))
  (require sub-id)
  (provide (all-from-out sub-id))
  body ...))])))

Does this work?
(define-syntax my-module-begin
  (lambda (stx)
(syntax-case stx ()
  [(_ body ...)
   (with-syntax ([sub-id (datum-syntax stx ''sub)])
 #'(#%module-begin
 (module sub-id racket/base
   (define x 2)
   (provide x))
 (require sub-id)
 (provide (all-from-out sub-id))
 body ...))])))


 On Aug 15, 2015, at 6:21 PM, Matthew Butterick m...@mbtype.com wrote:
 
 Of your suggestions, I couldn't get `syntax-local-introduce` to work, but 
 `datum-syntax` did. That made the macro-introduced identifier accessible at 
 the REPL. Thanks.
 
 However, I also wanted to set up the #lang so that DrRacket would 
 automatically print the value of `id` when it ran the file. I noticed I 
 could do this by introducing a `(module+ test ...)` in the #lang itself that 
 prints `id` (because by default, DrRacket automatically runs test 
 submodules). Thus obviating the need for a wrapper module.
 
 
 
 
 
 On Aug 15, 2015, at 5:08 PM, Matthew Butterick m...@mbtype.com wrote:
 
 Probably the wiser option. I'll see if I can adapt that solution.
 
 
 On Aug 15, 2015, at 4:31 PM, Alexander D. Knauth alexan...@knauth.org 
 wrote:
 
 What kind of funny stuff?
 By the way, this sounds sort of like this
 http://www.mail-archive.com/racket-users@googlegroups.com/msg28020.html
 Solution: 
 http://www.mail-archive.com/racket-users@googlegroups.com/msg28031.html
 
 Although it could be a completely different problem, I don't know.
 
 On Aug 15, 2015, at 6:22 PM, Matthew Butterick m...@mbtype.com wrote:
 
 I have a #lang that does some funny stuff with #%module-begin (maybe too 
 funny), the result being that when I run it in DrRacket, the `provide`d 
 identifiers aren't visible at the top level:
 
 (module my-lang-module my-lang
 ...
 (define id 42)
 (provide id))
 
 id
 id : undefined;
 cannot reference undefined identifier
 
 
 I've found a simple cure (maybe too simple) whereby I wrap my-lang-module 
 with the usual racket/base module, which satisfies DrRacket:
 
 
 (module repl-wrapper racket/base
 (module my-lang-module my-lang
 ...
 (define id 42)
 (provide id))
 (require 'my-lang-module)
 (provide (all-from-out 'my-lang-module))
 
 id
 42
 
 
 Question: is there an approved way to make this #lang-wrapping happen for 
 the REPL, and only for the REPL? AFAICT `#%top-interaction` is not the 
 cure, because it wraps the commands coming off the REPL (as opposed to 
 the code in the definitions window). 
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.
 
 
 
 

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] how to wrap a #lang module for the REPL?

What kind of funny stuff?
By the way, this sounds sort of like this
http://www.mail-archive.com/racket-users@googlegroups.com/msg28020.html
Solution: 
http://www.mail-archive.com/racket-users@googlegroups.com/msg28031.html

Although it could be a completely different problem, I don't know.

On Aug 15, 2015, at 6:22 PM, Matthew Butterick m...@mbtype.com wrote:

 I have a #lang that does some funny stuff with #%module-begin (maybe too 
 funny), the result being that when I run it in DrRacket, the `provide`d 
 identifiers aren't visible at the top level:
 
 (module my-lang-module my-lang
  ...
  (define id 42)
  (provide id))
 
 id
 id : undefined;
 cannot reference undefined identifier
 
 
 I've found a simple cure (maybe too simple) whereby I wrap my-lang-module 
 with the usual racket/base module, which satisfies DrRacket:
 
 
 (module repl-wrapper racket/base
  (module my-lang-module my-lang
...
(define id 42)
(provide id))
  (require 'my-lang-module)
  (provide (all-from-out 'my-lang-module))
 
 id
 42
 
 
 Question: is there an approved way to make this #lang-wrapping happen for the 
 REPL, and only for the REPL? AFAICT `#%top-interaction` is not the cure, 
 because it wraps the commands coming off the REPL (as opposed to the code in 
 the definitions window). 
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] how to wrap a #lang module for the REPL?

Based on this experiment, the double-quoted sub should be the right thing, and 
the single-quoted inside the datum-syntax with another quote in the require 
and provide forms shouldn't work.

Just like this works:
#lang racket
(require syntax/parse/define)
(define-simple-macro (m x)
  #:with req-spec (datum-syntax #'x ''sub)
  (begin
(module sub racket/base
  (provide y)
  (define y 3))
(require req-spec)))
(m x)
y

But this doesn't:
#lang racket
(require syntax/parse/define)
(define-simple-macro (m x)
  #:with req-spec (datum-syntax #'x 'sub)
  (begin
(module sub racket/base
  (provide y)
  (define y 3))
(require 'req-spec)))
(m x)
y

On Aug 16, 2015, at 12:09 AM, Matthew Butterick m...@mbtype.com wrote:

 No, the double-quoted ''sub doesn't work (triggers bad-syntax error). 
 
 Nor does this (with quotes added to `sub-id` within the `require` and 
 `provide` forms):
 
 (define-syntax my-module-begin
   (lambda (stx)
 (syntax-case stx ()
   [(_ body ...)
(with-syntax ([sub-id (datum-syntax stx 'sub)])
  #'(#%module-begin
 (module sub-id racket/base
   (define x 2)
   (provide x))
 (require 'sub-id)
 (provide (all-from-out 'sub-id))
 body ...))])))
 
 On Sat, Aug 15, 2015 at 9:56 PM, Alexander D. Knauth alexan...@knauth.org 
 wrote:
 
 On Aug 15, 2015, at 11:53 PM, Alexander D. Knauth alexan...@knauth.org 
 wrote:
 
  Does this work?
  (define-syntax my-module-begin
   (lambda (stx)
 (syntax-case stx ()
   [(_ body ...)
(with-syntax ([sub-id (datum-syntax stx ''sub)])
  #'(#%module-begin
  (module sub-id racket/base
(define x 2)
(provide x))
  (require sub-id)
  (provide (all-from-out sub-id))
  body ...))])))
 
 I just realized that's not your example, so anyway, does modifying your 
 example to use (datum-syntax stx ''sub) instead of (datum-syntax stx 'sub) 
 work?
 
 

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] how to wrap a #lang module for the REPL?


On Aug 15, 2015, at 11:53 PM, Alexander D. Knauth alexan...@knauth.org wrote:

 Does this work?
 (define-syntax my-module-begin
  (lambda (stx)
(syntax-case stx ()
  [(_ body ...)
   (with-syntax ([sub-id (datum-syntax stx ''sub)])
 #'(#%module-begin
 (module sub-id racket/base
   (define x 2)
   (provide x))
 (require sub-id)
 (provide (all-from-out sub-id))
 body ...))])))

I just realized that's not your example, so anyway, does modifying your example 
to use (datum-syntax stx ''sub) instead of (datum-syntax stx 'sub) work?

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Export indentation preferences in a package's info.rkt?

2015-08-09 Thread Alexander D. Knauth

I would really like to have such a feature.  

On Aug 9, 2015, at 1:23 PM, Jack Firth jackhfi...@gmail.com wrote:

 I find it irritating when I have to repeatedly add various macros exported by 
 libraries to their proper group in the Indenting section of DrRacket's 
 settings so that they're properly formatted. Is there a way for a package's 
 info.rkt to specify default indentation preferences for it's macros for 
 DrRacket to make sense of? If not, would that be something easy enough to do 
 and useful enough to be worth doing?
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] #lang languages and REPL


On Aug 7, 2015, at 4:35 PM, Alexander D. Knauth alexan...@knauth.org wrote:

 The definition of x in `my-module-begin` doesn't work because it comes from 
 the macro's scope, not from the module's scope.
 See 
 http://docs.racket-lang.org/reference/syntax-model.html#%28part._macro-introduced-bindings%29
 
 If you really need to use that approach instead of what I suggested above, 
 you should be able use either syntax-local-introduce or datum-syntax.
 You could try building off of one of these: (not tested)
 
 (require syntax/parse/define)
 ;; one option, using syntax-local-introduce:
 (define-simple-macro (my-module-begin body ...)
   #:with x-id (syntax-local-introduce #'x)
   (#%module-begin
(define x 2)

Sorry I meant (define x-id 2)

body ...))
 ;; another option, using syntax-local-introduce:
 (define-syntax my-module-begin
   (lambda (stx)
 (syntax-case stx ()
   [(_ body ...)
(with-syntax ([x-id (syntax-local-introduce #'x)])
  #'(#%module-begin
  (define x 2)

And here too, (define x-id 2)

  body ...))])))
 ;; another option, using datum-syntax:
 (define-syntax my-module-begin
   (lambda (stx)
 (syntax-case stx ()
   [(_ body ...)
(with-syntax ([x-id (datum-syntax stx 'x)])
  #'(#%module-begin
  (define x 2)

And here, (define x-id 2)

  body ...))])))
 
 Hope this helps!
 
 Alex Knauth
 

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] #lang languages and REPL


On Aug 7, 2015, at 4:15 PM, Deren Dohoda deren.doh...@gmail.com wrote:

 I have a minimal example that reproduces the behavior and I can track it 
 down to the fact that I do not export define and the file which uses the 
 new #lang does not define anything, except through a #%module-begin rewrite.

You shouldn't need a #%module-begin rewrite either though. (cont. below)

 If the file written in the new #lang has access to define and defines 
 anything, then indeed it shows up. Please forgive any gmail formatting:
 
 TEST/
 --test.rkt
 --test-lang/
 test-lang.rkt
 lang/
 --reader.rkt
 
 I add the TEST directory to PLTCOLLECTS.
 
 reader.rkt:
 #lang s-exp syntax/module-reader
 test-lang/test-lang.rkt
 
 test-lang.rkt:
 #lang racket/base
 (provide (rename-out (my-module-begin #%module-begin))
  #%app #%top #%datum #%top-interaction
  require displayln)
 
 (define-syntax-rule (my-module-begin body ...)
   (#%module-begin
(define x 2)
(provide x)
body ...))

I don't think that's what you want to do.

What you probably want is this:

test-lang.rkt:
#lang racket/base
(provide #%module-begin ; from racket/base
 #%app #%top #%datum #%top-interaction
 require displayln
 x)

(define x 2)

Then the repl for test.rkt should work. (cont. below)

 test.rkt:
 #lang test-lang
 (displayln 2)
 
 Run test.rkt
 Welcome to DrRacket, version 6.2 [3m].
 Language: test-lang [custom]; memory limit: 4096 MB.
 2
  x
 . . x: undefined;
  cannot reference an identifier before its definition
  (require test.rkt)
  x
 2
 ;
 
 It seems to be because of the definition of x in my-module-begin. But I don't 
 understand why this doesn't work.

The definition of x in `my-module-begin` doesn't work because it comes from the 
macro's scope, not from the module's scope.
See 
http://docs.racket-lang.org/reference/syntax-model.html#%28part._macro-introduced-bindings%29

If you really need to use that approach instead of what I suggested above, you 
should be able use either syntax-local-introduce or datum-syntax.
You could try building off of one of these: (not tested)

(require syntax/parse/define)
;; one option, using syntax-local-introduce:
(define-simple-macro (my-module-begin body ...)
  #:with x-id (syntax-local-introduce #'x)
  (#%module-begin
   (define x 2)
   body ...))
;; another option, using syntax-local-introduce:
(define-syntax my-module-begin
  (lambda (stx)
(syntax-case stx ()
  [(_ body ...)
   (with-syntax ([x-id (syntax-local-introduce #'x)])
 #'(#%module-begin
 (define x 2)
 body ...))])))
;; another option, using datum-syntax:
(define-syntax my-module-begin
  (lambda (stx)
(syntax-case stx ()
  [(_ body ...)
   (with-syntax ([x-id (datum-syntax stx 'x)])
 #'(#%module-begin
 (define x 2)
 body ...))])))

Hope this helps!

Alex Knauth

 Thanks for any insight here, I seem to have a bad mental model of what's 
 happening,
 Deren
 
 
 On Fri, Aug 7, 2015 at 4:32 PM, Alexander D. Knauth alexan...@knauth.org 
 wrote:
 That sounds weird. You shouldn't need to do anything special with 
 #%top-interaction or anything, so I'm not sure what's going on.
 
 How are you defining it?  Can you show us some of the source code?
 
 On Aug 7, 2015, at 1:09 PM, Deren Dohoda deren.doh...@gmail.com wrote:
 
  I have a #lang I'm working on and everything seems to be going very well. 
  One thing I don't understand, though, is that when a file written in this 
  language is opened in DrRacket and Run, I still have to (require 
  file.rkt) in the REPL before I am able to use anything provided by the 
  file.
 
  I assume that I am neglecting to do something somewhere related to the use 
  of #%top-interaction, because when I fail to provide this from the 
  implementation of the language, I cannot run the file in DrRacket at all. 
  But merely adding it to the provide expression doesn't do what I expect.
 
  Any help?
 
  Deren
 
  --
  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.
  For more options, visit https://groups.google.com/d/optout.
 
 
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] #lang languages and REPL

That sounds weird. You shouldn't need to do anything special with 
#%top-interaction or anything, so I'm not sure what's going on.

How are you defining it?  Can you show us some of the source code?

On Aug 7, 2015, at 1:09 PM, Deren Dohoda deren.doh...@gmail.com wrote:

 I have a #lang I'm working on and everything seems to be going very well. One 
 thing I don't understand, though, is that when a file written in this 
 language is opened in DrRacket and Run, I still have to (require file.rkt) 
 in the REPL before I am able to use anything provided by the file.
 
 I assume that I am neglecting to do something somewhere related to the use of 
 #%top-interaction, because when I fail to provide this from the 
 implementation of the language, I cannot run the file in DrRacket at all. But 
 merely adding it to the provide expression doesn't do what I expect.
 
 Any help?
 
 Deren
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] is this a bug?


On Aug 7, 2015, at 12:27 PM, Michael Titke michael.tied...@o2online.de wrote:

 I always suspected this to be a logical joke of forcing people to write their 
 own quantifiers and to not let them fall for predicate logic.
 
 The best thing about a logic scheme declaring everything but really 
 everything to be true when it is not false are expressions like the following:
 (when (cond (#f 'true)) 'what-is-true?) = 'what-is-true?

The confusing thing about your example, I think, is that cond returns #void 
if none of the clauses match, when it would be slightly less bug-prone if it 
raised an error in that case.

 Yes, even unspecified is not false but it could have been. But that was not 
 specified. ;-)

Do you mean #void?  I think it's great that #void is a truthy value, 
because it allows things like:

(and
  (some-predicate ...)
  (some-effect-returning-void ...)
  (some-predicate ...)
  (some-effect-returning-void ...)
  ...)

Or possibly one of those effects could return void on success, but false on a 
failure, which would cause the `and` expression to stop and return false, 
signaling a failure. That's one nice use of that, at least. 

Also the simpler the true/false separation is, the better, in my opinion. 


-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Communicating between macros without mutation, problems with multiple modules?

Hi. I have been trying to create a macro that communicates without using 
mutation, but I'm having problems with communicating across multiple modules.  

I have three files:

macro.rkt:
#lang racket
(provide start add)
(require (for-syntax syntax/parse racket/match racket/syntax))
(begin-for-syntax
  ;; (thing stx-lst next-id)
  ;; stx-lst : Syntax ; will be quoted
  ;; next-id : Identifier ; points to the next identifier, which is or will be 
the next thing
  ;;   if the next thing exists, then this one is old
  (struct thing (stx-lst next-id) #:transparent)
  ;; get-thing : Identifier - thing
  (define (get-thing id)
(follow-next-things (syntax-local-value id)))
  ;; follow-next-things : thing - thing
  (define (follow-next-things v)
(match v
  [(thing _ next-id)
   (define v* (syntax-local-value (syntax-local-introduce next-id) (λ () 
#f)))
   (cond [v* (follow-next-things v*)]
 [else v])])))
(define-syntax start
  (syntax-parser
[(start id)
 #:with next (generate-temporary #'id)
 #'(define-syntax id (thing #'() #'next))]))
(define-syntax add
  (syntax-parser
[(add id new-stx)
 #:do [(match-define (thing stx next-id) (get-thing #'id))]
 #:with (old-stx ...) (syntax-local-introduce stx)
 #:with next (syntax-local-introduce next-id)
 #:with next-next (generate-temporary #'id)
 (printf macro.rkt add\n  next: ~v\n #'next)
 #'(begin
 (define-syntax next (thing #'(old-stx ... new-stx) #'next-next))
 '(old-stx ... new-stx))]))

test1.rkt:
#lang racket
(provide id)
(require macro.rkt)
(start id)
(add id a) ; '(a)
(add id b) ; '(a b)

test2.rkt:
#lang racket
(require macro.rkt test1.rkt)
(add id c) ; this works fine, produces '(a b c) when run
;(add id d) ; module: duplicate definition for identifier

If I uncomment the last line of test2.rkt, it produces that duplicate 
definition error.

I'm guessing that the second use of add in test2.rkt isn't picking up the 
next-id definition put there by the first use of add in test2.rkt.

When I run test1.rkt in DrRacket it prints out:
macro.rkt add
  next: .#syntax id1
macro.rkt add
  next: .#syntax id2
'(a)
'(a b)

The first 4 lines were printed out by the add macro at compile time, and the 
last 2 are the run time results.

When I run test2.rkt in DrRacket it prints out:
macro.rkt add
  next: .#syntax id3
'(a)
'(a b)
'(a b c)

But then if I uncomment the last line:
macro.rkt add
  next: .#syntax id3
macro.rkt add
  next: .#syntax id3
module: duplicate definition for identifier in: id3
With this at the bottom:
module: duplicate definition for identifier at: id3 in: (define-syntaxes (id3) 
(thing (syntax (a b d)) (syntax id2)))

The message at the bottom shows that the (add id d) isn't picking up the 
next-id definition put there by the (add id c), so that it puts out (a b d) 
instead of (a b c d), and tries to define the same next-id that the previous 
(add id c) already defined.

What's happening here?

I know about the separate compilation guarantee, but don't think that could be 
the problem, since it works perfectly when add is used only once in test2.rkt.

Alex Knauth


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Communicating between macros without mutation, problems with multiple modules?

Oh, thanks!
That makes sense.

On the off chance that you have an idea, is there a good way of doing this that 
doesn't require b being able to see c?

On Aug 7, 2015, at 10:23 PM, Matthew Flatt mfl...@cs.utah.edu wrote:

 That's an interesting attempt to exploit the mutation inherent in a
 recursive definition context to build a reference chain.
 
 It doesn't work across module boundaries because the recursive binding
 context doesn't extend across that boundary. The binding structure
 created by your example is something like
 
 (let ()
   (define (a) b)
   (define (b) c)
   (let ()
 (define (c) )
 ))
 
 Here, the body of `a` can refer to `b`, because they're in the same
 recursive definition context. The body of `b` cannot refer to `c`,
 however, because `c` is in a different context (although the body of
 `c` can see `b`). An importing module is analogous to the more nested
 context above.
 
 
 The way you wrote the example, it may seem that `(add id b)` is somehow
 able to reference the definition in `(add id c) `, but that's not the
 case. The `(add id c)` is able to refer to things in test1.rkt, and
 it also prints itself, so '(a b c) show up together. Since the `(add id
 b)` doesn't see `(add id c)`, the pieces that `(add id d)` can see
 point back to the same identifier as when `(add id c)` traverses them,
 so you end up with a duplicate definition of that identifier. That is,
 the `next-next` identifier created by `(add id b)` is never bound in
 the same was that `c` is never bound above for `(define (b) c)`.
 
 
 At Fri, 7 Aug 2015 22:02:48 -0500, Alexander D. Knauth wrote:
 Hi. I have been trying to create a macro that communicates without using 
 mutation, but I'm having problems with communicating across multiple 
 modules.  
 
 I have three files:
 
 macro.rkt:
 #lang racket
 (provide start add)
 (require (for-syntax syntax/parse racket/match racket/syntax))
 (begin-for-syntax
  ;; (thing stx-lst next-id)
  ;; stx-lst : Syntax ; will be quoted
  ;; next-id : Identifier ; points to the next identifier, which is or will 
 be 
 the next thing
  ;;   if the next thing exists, then this one is old
  (struct thing (stx-lst next-id) #:transparent)
  ;; get-thing : Identifier - thing
  (define (get-thing id)
(follow-next-things (syntax-local-value id)))
  ;; follow-next-things : thing - thing
  (define (follow-next-things v)
(match v
  [(thing _ next-id)
   (define v* (syntax-local-value (syntax-local-introduce next-id) (λ () 
 #f)))
   (cond [v* (follow-next-things v*)]
 [else v])])))
 (define-syntax start
  (syntax-parser
[(start id)
 #:with next (generate-temporary #'id)
 #'(define-syntax id (thing #'() #'next))]))
 (define-syntax add
  (syntax-parser
[(add id new-stx)
 #:do [(match-define (thing stx next-id) (get-thing #'id))]
 #:with (old-stx ...) (syntax-local-introduce stx)
 #:with next (syntax-local-introduce next-id)
 #:with next-next (generate-temporary #'id)
 (printf macro.rkt add\n  next: ~v\n #'next)
 #'(begin
 (define-syntax next (thing #'(old-stx ... new-stx) #'next-next))
 '(old-stx ... new-stx))]))
 
 test1.rkt:
 #lang racket
 (provide id)
 (require macro.rkt)
 (start id)
 (add id a) ; '(a)
 (add id b) ; '(a b)
 
 test2.rkt:
 #lang racket
 (require macro.rkt test1.rkt)
 (add id c) ; this works fine, produces '(a b c) when run
 ;(add id d) ; module: duplicate definition for identifier
 
 If I uncomment the last line of test2.rkt, it produces that duplicate 
 definition error.
 
 I'm guessing that the second use of add in test2.rkt isn't picking up the 
 next-id definition put there by the first use of add in test2.rkt.
 
 When I run test1.rkt in DrRacket it prints out:
 macro.rkt add
  next: .#syntax id1
 macro.rkt add
  next: .#syntax id2
 '(a)
 '(a b)
 
 The first 4 lines were printed out by the add macro at compile time, and the 
 last 2 are the run time results.
 
 When I run test2.rkt in DrRacket it prints out:
 macro.rkt add
  next: .#syntax id3
 '(a)
 '(a b)
 '(a b c)
 
 But then if I uncomment the last line:
 macro.rkt add
  next: .#syntax id3
 macro.rkt add
  next: .#syntax id3
 module: duplicate definition for identifier in: id3
 With this at the bottom:
 module: duplicate definition for identifier at: id3 in: (define-syntaxes 
 (id3) 
 (thing (syntax (a b d)) (syntax id2)))
 
 The message at the bottom shows that the (add id d) isn't picking up the 
 next-id definition put there by the (add id c), so that it puts out (a b d) 
 instead of (a b c d), and tries to define the same next-id that the previous 
 (add id c) already defined.
 
 What's happening here?
 
 I know about the separate compilation guarantee, but don't think that could 
 be 
 the problem, since it works perfectly when add is used only once in 
 test2.rkt.
 
 Alex Knauth
 
 
 -- 
 You received this message because you are subscribed to the Google Groups 
 Racket Users group.
 To unsubscribe from

Re: [racket-users] is this a bug?

2015-08-06 Thread Alexander D. Knauth

I believe this pull request is about solving that problem:
https://github.com/plt/racket/pull/928
Either through modifying `and` and `or`, or providing variations that can be 
used with apply and foldr (or other higher-order functions).

On Aug 6, 2015, at 10:09 AM, sagyo12341...@gmail.com wrote:

 In racket, the proc apply-or is needed.
 
 (or #f 1 2 #f 3 4 #f)
 1
 (apply or (list #f 1 2 #f 3 4 #f))
 . or: bad syntax in: or
 (define (apply-or lst) (foldr or #t lst))
 . or: bad syntax in: or
 (define (apply-or lst) (foldr (lambda (x y) (or x y)) #t lst))
 (apply-or (list #f 1 2 #f 3 4 #t))
 1
 (foldl (lambda (x y) (or x y)) #t (list #f 1 2 #t 3 4 #t))
 #t
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Distinct instantiations of modules

2015-08-06 Thread Alexander D. Knauth

I think namespace-attach-module is one way to do this:

#lang racket
(module a racket
  (define ns (make-base-namespace))
  (namespace-attach-module (current-namespace) 'racket/promise ns)
  (parameterize ((current-namespace ns)) (namespace-require 'racket))
  (define *promise? (namespace-variable-value 'promise? #t #f ns))
  (*promise? (lazy 1)))
(require 'a) ; #t


On Aug 1, 2015, at 8:03 PM, Jos Koot jos.k...@gmail.com wrote:

 Some (I think many) modules define struct types and provide the constructors 
 and predicates of these structs. A predicate of an instance of such a module 
 does not recognize a struct made by a distinct instance of the same module. 
 For example:
  
 #lang racket
 (module a racket
  (define ns (make-base-namespace))
  (parameterize ((current-namespace ns)) (namespace-require 'racket))
  (define *promise? (namespace-variable-value 'promise? #t #f ns))
  (*promise? (lazy 1)))
 (require 'a) ; - #f where I would want #t
  
 I know there is a solution for this problem:
  
 #lang racket
 (module b racket
  (define-namespace-anchor id)
  (define ns (namespace-anchor-namespace id))
  (void (parameterize ((current-namespace ns)) (namespace-anchor-namespace 
 id)))
  (define *promise? (namespace-variable-value 'promise? #t #f ns))
  (*promise? (lazy 1)))
 (require 'b) ; - #t as wanted 
 Nevertheless, is there any chance to modify things such that once a module 
 has been instantiated, each new require of that module gives the same 
 instantiation?
 May be there are reasons not to do so, but I do not know why not.
  
 Your opinion would be much appreciated.
 Thanks,
 Jos Koot
  
  
  
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] A couple of questions about Neil's html reader/writer

2015-07-29 Thread Alexander D. Knauth

Would it be easier using match?

(define (xexpr-tok-tree an-xexpr)
  (match as-xexpr
['()
 '()]
[(not (cons _ _))
 (tok-make ...)]
[(list tag)
 (list tag)]
[(list-rest tag (? is-at-list at-list) r2)
 ]
))

On Jul 29, 2015, at 7:56 AM, Thomas Lynch 
thomas.ly...@reasoningtechnology.com wrote:

 I wrote primitive conversion routines to bring the xexpr or Neil's xexpr into 
 ... oh gosh, my parser token format, which by coincidence is very close.  
 Just playing with this now .. In my target format token children are always 
 other tokens.  All values given as attributes in value tokens.  I use an 
 empty list if there are no attributes.  The conversion routines are very 
 simple, though I'm just playing with this, there will be other cases I 
 missed, I suspect:
 
  (define (xexpr-tok-tree an-xexpr)
 (define (is-at-list e)
   (and
 (pair? e)
 (pair? (car e
 (cond
   [(null? an-xexpr) an-xexpr]
   [(not (pair? an-xexpr)) (tok-make 'tok:value `((value ,an-xexpr)))] ; 
 actually diff toks for diff types
   [else
 (let(
   [tag (car an-xexpr)]
   [r1  (cdr an-xexpr)]
   )
   (cond
 [(null? r1) an-xexpr]
 [else
   (let(
 [first-element (car r1)]
 [r2 (cdr r1)]
 )
 (cond
   [(is-at-list first-element) (cons tag (cons first-element 
 (map xexpr-tok-tree r2)))]
   [else (cons tag (cons '() (map xexpr-tok-tree r1)))]
   ))]))]))
 
 (define (test-xexpr-tok-tree-0)
   (equal?
 (xexpr-tok-tree
   '(html (head (title My Title))
  (body ((bgcolor white))
(h1 My Heading)
(p ((style default)) This is a paragraph.)
(p This is another paragraph.
 '(html
()
(head () (title () (tok:value ((value My Title)
(body
  ((bgcolor white))
  (h1 () (tok:value ((value My Heading
  (p ((style default)) (tok:value ((value This is a paragraph.
  (p () (tok:value ((value This is another paragraph.)
)))
 
 
 On Wed, Jul 29, 2015 at 7:05 AM, Matthew Butterick m...@mbtype.com wrote:
 Yes, more or less. In an X-expression, an attribute list is the only element 
 that's a list made of sublists. A list of embedded X-expressions, OTOH, will 
 start with a symbol. To look at it another way,
 
 (cons symbol (list xexpr ...))
 
 really amounts to
 
 (list symbol xexpr ...)
 
 
 which is just
 
 (list symbol (list (list symbol string) ...) xexpr ...)
 
 
 but without the attribute list, cf.
 
 '(p foo bar)
 
 '(p ((style default)) foo bar)
 
 A recurring annoyance in X-expressions is distinguishing these two cases on 
 input, because the second element can be either an attribute list or nested 
 X-expression. You can use `xexpr-drop-empty-attributes` to force an attribute 
 list (even empty). My `txexpr` package also has utilities for handling them.
 
 
 
 Here is the syntax for an xexp from xexp? in the reference:
 
   xexpr  =   string
  |   (list symbol (list (list symbol string) ...) 
 xexpr ...)
  |   (cons symbol (list xexpr ...))
  |   symbol
  |   valid-char?
  |   cdata
  |   misc
 
 And in this latter syntax, how is the attribute list distinguished from a 
 list of embedded xexps? Is it due to the nesting in the attribute list?
 
 
 
 
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Question : Local Definition

2015-07-24 Thread Alexander D. Knauth


On Jul 24, 2015, at 11:29 PM, sagyo12341...@gmail.com wrote:

 Nice to meet you.
 
 
 I'm a racket beginner and I'm not a English speaker. Please forgive my poor 
 skills.
 
 In racket tutorials or HtDP, it uses some local definitions, as follows:
 
 (define (f x)
  (local [((define g x) (add1 x))]
(f (g x.
 
 I'm not sure about the difference from the code:
 
 (define (f x)
  (define (g x) (add1 x))
  (f (g x))).
 
 Please help me. Thank you.
 
 Taro

Other than the misplaced paren typo in the first bit of code, these will do 
exactly the same thing.

Alex Knauth


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Question : Local Definition

2015-07-24 Thread Alexander D. Knauth


On Jul 25, 2015, at 12:20 AM, Alexander D. Knauth alexan...@knauth.org wrote:

 
 On Jul 24, 2015, at 11:29 PM, sagyo12341...@gmail.com wrote:
 
 Nice to meet you.
 
 
 I'm a racket beginner and I'm not a English speaker. Please forgive my poor 
 skills.
 
 In racket tutorials or HtDP, it uses some local definitions, as follows:
 
 (define (f x)
 (local [((define g x) (add1 x))]
   (f (g x.
 
 I'm not sure about the difference from the code:
 
 (define (f x)
 (define (g x) (add1 x))
 (f (g x))).
 
 Please help me. Thank you.
 
 Taro
 
 Other than the misplaced paren typo in the first bit of code, these will do 
 exactly the same thing.

It's a matter of style. (Unless of course you're in an HTDP language that 
doesn't support internal definitions.)

There are times when I prefer local, for instance, when I want to clearly 
separate the definitions from the last expression, or when I want to indent the 
definitions more than the last expression.  

But there are also many times when an internal definition context is just more 
convenient, since comes with less keystrokes, less parens, and less 
indentation, and a bit more flexibility, especially if I want to put some 
debugging or error checking code in there.


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Macro to extract select subexpressions into other locations

2015-07-21 Thread Alexander D. Knauth

Here's a macro that does something similar:

#lang at-exp racket

(require (for-syntax syntax/parse
 racket/contract
 ))

(begin-for-syntax
  (define (get-extracted-exprs-box extracted-exprs-id)
(syntax-local-value extracted-exprs-id))
  (define (get-extracted-exprs extracted-exprs-id)
(unbox (get-extracted-exprs-box extracted-exprs-id)))
  (define (box-update! b f)
(set-box! b (f (unbox b
  (define (add-extracted-expr! extracted-exprs-id new-expr)
(box-update! (get-extracted-exprs-box extracted-exprs-id)
 (λ (lst) (append lst (list (syntax-local-introduce 
new-expr)))

(define-syntax extract-expression
  (syntax-parser
[(extract-expression expr:expr extracted-exprs-id:id)
 (add-extracted-expr! #'extracted-exprs-id #'expr)
 #'expr]))

(define-syntax with-extract-expressions
  (syntax-parser
[(with-extract-expressions stx-expr:expr ...)
 #:with [extracted-exprs macro-id:id ...]
 (generate-temporaries #'[extracted-expressions stx-expr ...])
 #'(begin
 (define-syntax extracted-exprs (box '()))
 (begin
   (define-syntax macro-id
 (lambda (stx)
   (stx-expr #'extracted-exprs)))
   (macro-id))
 ...)]))

(define (square x) (* x x))

(with-extract-expressions
 (lambda (exprs)
   (with-syntax ([exprs exprs])
 #'(module+ test
 (require rackunit)
 (check-equal? (extract-expression (square 5) exprs) 25)
 (check-equal? (extract-expression (square -5) exprs) 25
 (lambda (exprs)
   (with-syntax ([(expr ...) (get-extracted-exprs exprs)])
 #'(module+ doc
 (require scribble/manual
  scribble/eval)
 (define evaluator (make-base-eval))
 @defproc[(square [x real?]) real?]{
   Returns the square of @racket[x], the result of
   multiplying @racket[x] by itself.
   @examples[#:eval evaluator expr ...]}


On Jul 20, 2015, at 8:03 PM, Jack Firth jackhfi...@gmail.com wrote:

 I'm trying to create a way to automatically turn test cases into examples. 
 I'd like a macro that turns this:
 
 (extract-expressions
 (module+ test
   (check-equal? (extract-expression (square 5)) 25)
   (check-equal? (extract-expression (square -5)) 25))
 (module+ doc
   @defproc[(square [x real?]) real?]{
 Returns the square of @racket[x], the result of
 multiplying @racket[x] by itself.
 @examples[#:eval evaluator (include-extracted-expressions)]}))
 
 into this:
 
 (begin
  (module+ test
(check-equal? (square 5) 25))
  (module+ doc
@defproc[(square [x real?]) real?]{
  Returns the square of @racket[x], the result of
  multiplying @racket[x] by itself.
  @examples[#:eval evaluator (square 5) (square -5)]}))
 
 That's the general idea anyway. I want to be able to gather arbitrary 
 expressions inside a region and copy them into some other marked place 
 inside the expressions. How exactly do I go about doing this, and how should 
 I do it properly?
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Macro to extract select subexpressions into other locations

2015-07-21 Thread Alexander D. Knauth

Oh. I checked that that the expressions were accumulating in the definition of 
extract-expression, but I didn't check that it expanded in the right order to 
do what you want.

So this doesn't actually work. 

On Jul 21, 2015, at 3:08 PM, Alexander D. Knauth alexan...@knauth.org wrote:

 Here's a macro that does something similar:
 
 #lang at-exp racket
 
 (require (for-syntax syntax/parse
 racket/contract
 ))
 
 (begin-for-syntax
  (define (get-extracted-exprs-box extracted-exprs-id)
(syntax-local-value extracted-exprs-id))
  (define (get-extracted-exprs extracted-exprs-id)
(unbox (get-extracted-exprs-box extracted-exprs-id)))
  (define (box-update! b f)
(set-box! b (f (unbox b
  (define (add-extracted-expr! extracted-exprs-id new-expr)
(box-update! (get-extracted-exprs-box extracted-exprs-id)
 (λ (lst) (append lst (list (syntax-local-introduce 
 new-expr)))
 
 (define-syntax extract-expression
  (syntax-parser
[(extract-expression expr:expr extracted-exprs-id:id)
 (add-extracted-expr! #'extracted-exprs-id #'expr)
 #'expr]))
 
 (define-syntax with-extract-expressions
  (syntax-parser
[(with-extract-expressions stx-expr:expr ...)
 #:with [extracted-exprs macro-id:id ...]
 (generate-temporaries #'[extracted-expressions stx-expr ...])
 #'(begin
 (define-syntax extracted-exprs (box '()))
 (begin
   (define-syntax macro-id
 (lambda (stx)
   (stx-expr #'extracted-exprs)))
   (macro-id))
 ...)]))
 
 (define (square x) (* x x))
 
 (with-extract-expressions
 (lambda (exprs)
   (with-syntax ([exprs exprs])
 #'(module+ test
 (require rackunit)
 (check-equal? (extract-expression (square 5) exprs) 25)
 (check-equal? (extract-expression (square -5) exprs) 25
 (lambda (exprs)
   (with-syntax ([(expr ...) (get-extracted-exprs exprs)])
 #'(module+ doc
 (require scribble/manual
  scribble/eval)
 (define evaluator (make-base-eval))
 @defproc[(square [x real?]) real?]{
   Returns the square of @racket[x], the result of
   multiplying @racket[x] by itself.
   @examples[#:eval evaluator expr ...]}
 
 
 On Jul 20, 2015, at 8:03 PM, Jack Firth jackhfi...@gmail.com wrote:
 
 I'm trying to create a way to automatically turn test cases into examples. 
 I'd like a macro that turns this:
 
 (extract-expressions
 (module+ test
  (check-equal? (extract-expression (square 5)) 25)
  (check-equal? (extract-expression (square -5)) 25))
 (module+ doc
  @defproc[(square [x real?]) real?]{
Returns the square of @racket[x], the result of
multiplying @racket[x] by itself.
@examples[#:eval evaluator (include-extracted-expressions)]}))
 
 into this:
 
 (begin
 (module+ test
   (check-equal? (square 5) 25))
 (module+ doc
   @defproc[(square [x real?]) real?]{
 Returns the square of @racket[x], the result of
 multiplying @racket[x] by itself.
 @examples[#:eval evaluator (square 5) (square -5)]}))
 
 That's the general idea anyway. I want to be able to gather arbitrary 
 expressions inside a region and copy them into some other marked place 
 inside the expressions. How exactly do I go about doing this, and how should 
 I do it properly?
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Macro introduce identifiers in the new expander

2015-07-20 Thread Alexander D. Knauth

I don't really know what's going on, but this might help:

;; It seems to be introducing the definition correctly, but not the use:
;; this works
(let ()
  (def) ; no difference between (def) and (define id 5)
  id)

;; this doesn't
(let ()
  (def)
  (use)) ; but there is a difference between (use) and id

;; and this doesn't either
(let ()
  (define id 5)
  (use))

On Jul 20, 2015, at 12:35 PM, Spencer Florence spen...@florence.io wrote:

 Hello,
 
 I'm trying to update some code to the new expander. The below code works on 
 6.2 but fails on the new expander with an unbound identifier error. 
 
 #lang racket
 (require (for-syntax syntax/parse))
 
 ;; a standard context for identifiers
 (define-for-syntax ctx #'ctx)
 
 ;; create an ID with the context `ctx`, and the current
 ;; expander mark (so that the mark is canceled later),
 ;; and the location loc
 (define-for-syntax (make-id loc)
   (syntax-local-introduce
(datum-syntax ctx 'id loc)))
 
 ;; This introduces a binding
 (define-syntax (def stx)
   (syntax-parse stx
 [(def)
  (with-syntax ([id (make-id #'here)])
#'(define id 5))]))
 
 ;; this attempts to use the binding introduced by `def`
 (define-syntax (use stx)
   (syntax-parse stx
 [(use)
  (with-syntax ([id (make-id #'here)])
#'id)]))
 
 ;; this works
 #;
 (begin
   (def)
   (use))
 
 ;; this fails
 (let ()
   (def)
   (use))
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Current snapshot: problem with generic interfaces and contracts

2015-07-19 Thread Alexander D. Knauth

This is a simplified example of something that worked in racket version 6.2.0.4 
from 2015-06-08, but is now broken in version 6.2.900.4 from 2015-07-17.

gen-foo.rkt:
#lang racket
(provide gen:foo foo? foo/c (contract-out [bar (foo? . - . any/c)]))
(require racket/generic)
(define-generics foo
  (bar foo))

contract.rkt:
#lang racket
(require gen-foo.rkt)
(define (foo/c* c)
  (foo/c
   [bar (foo? . - . c)]))

This works fine in the snapshot from last month, but in the current one, it 
fail with this error:
. redirect-generics: bar is not a method of generic interface gen:foo in: bar

One way to get around this is to export an uncontracted version from 
gen-foo.rkt, and possibly put the `bar` contract in a separate, third module, 
but why would this be broken now?


-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Is there a sequence combinator with a for*-like behavior?

2015-07-12 Thread Alexander D. Knauth

I'm wondering if there's anything I can use so that

(for/whatever ([(v1 v2 v3) (in-for*-sequence seq1 seq2 seq3)])
  )

Would be equivalent to

(for*/whatever ([v1 seq1] [v2 seq2] [v3 seq3])
  )

The reason I want this because with using for*, I'm constrained by the syntax, 
and I can't use apply when given a list of sequences that I want to combine in 
a for*-like manner.

If I understand correctly, this is similar to what cartesian-product from 
unstable/list does, so another way to put it would be asking if there is a 
sequence version cartesian-product.
http://docs.racket-lang.org/unstable/list.html#%28def._%28%28lib._unstable%2Flist..rkt%29._cartesian-product%29%29

Also a related question, is there a sequence equivalent to take on lists?

I found stream-tail and sequence-tail, which if I understand correctly are 
analogous to drop, but I couldn't find a take variant.


-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] How to specify fallbacks for generic interfaces without going into an infinite loop?

2015-07-06 Thread Alexander D. Knauth

What is the proper way to do this?

This goes into an infinite loop:

#lang racket/base

(require racket/generic)

(define-generics foo
  (a foo) (b foo) (c foo)
  #:fallbacks
  [(define (a foo)
 (displayln a-fallback)
 (b foo))
   (define (b foo)
 (displayln b-fallback)
 (a foo))])

(struct foo-struct ()
  #:methods gen:foo
  [(define (a foo) 1)])

(b (foo-struct))


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] How to specify fallbacks for generic interfaces without going into an infinite loop?

2015-07-06 Thread Alexander D. Knauth

Thanks!

On Jul 6, 2015, at 9:53 PM, Jon Zeppieri zeppi...@gmail.com wrote:

 Use define/generic:
 
 #lang racket/base
 
 (require racket/generic)
 
 (define-generics foo
  (a foo) (b foo) (c foo)
  #:fallbacks
  [(define/generic gen-a a)
   (define/generic gen-b b)
 
   (define (a foo)
 (displayln a-fallback)
 (gen-b foo))
   (define (b foo)
 (displayln b-fallback)
 (gen-a foo))])
 
 (struct foo-struct ()
  #:methods gen:foo
  [(define (a foo) 1)])
 
 (b (foo-struct))
 
 
 On Mon, Jul 6, 2015 at 9:50 PM, Alexander D. Knauth
 alexan...@knauth.org wrote:
 What is the proper way to do this?
 
 This goes into an infinite loop:
 
 #lang racket/base
 
 (require racket/generic)
 
 (define-generics foo
  (a foo) (b foo) (c foo)
  #:fallbacks
  [(define (a foo)
 (displayln a-fallback)
 (b foo))
   (define (b foo)
 (displayln b-fallback)
 (a foo))])
 
 (struct foo-struct ()
  #:methods gen:foo
  [(define (a foo) 1)])
 
 (b (foo-struct))
 
 
 --
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] help please on git/github pull request

2015-07-02 Thread Alexander D. Knauth


On Jul 2, 2015, at 6:34 AM, Tim Brown tim.br...@cityc.co.uk wrote:

 Folks,
 
 I have two pull requests related to my separation of net/url-string
 from net/url.
 
 plt/racket #948  implementation of the separation
 racket/net #4test and documentation of the above
 
 My problem is that I have been working on other things, and these are
 now not able to be merged into the master. (I've tried get pull
 --ff-only... as per Greg Hendershott's crib sheet)

Did you try `git pull --ff-only` from your topic branch, or from the master 
branch?

 How do I resolve this?

You probably need to checkout the master branch, then do git pull --ff-only 
upstream master,
then checkout your topic branch, and then `git rebase -i master`, find the 
conflicts, and resolve them.

After you resolve them you will (I think) need to `git add` the files that you 
resolved conflicts for, then
 `git rebase --continue`, and then when the rebase is finished, `git push -f 
origin topic-branch`.

Hope this helps!
Alex Knauth

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] help please on git/github pull request

2015-07-02 Thread Alexander D. Knauth

On Jul 2, 2015, at 1:53 PM, John Clements cleme...@brinckerhoff.org wrote:

On Jul 2, 2015, at 7:31 AM, Alexander D. Knauth alexan...@knauth.org wrote:

After you resolve them you will (I think) need to `git add` the files that
you resolved conflicts for, then
`git rebase --continue`, and then when the rebase is finished, `git push -f
origin topic-branch`.

Also, I think you eventually want to get things back onto the master branch,
right? After rebasing, you should be able to check out master again, then do
a

git merge —ff-only topic-branch

at which point you should be able to push cleanly.

Um, I'm going by Greg Hendershott's advice in his guide for infrequent
contributors to Racket, but
wouldn't you not want to do that, because that would mess up the master branch
and make it a dirty fork?

http://www.greghendershott.com/2013/04/a-guide-for-infrequent-contributors-to-racket.html#waiting-is-the-hardest-part

In the meantime, you might be tempted to merge your topic branch into your
own master. Don’t!

If you were to do that, your master would cease being a nice clean mirror of
the upstream master. Remember how no one likes a dirty fork, so we’re
diligently using git pull --ff-only upstream master?

--
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] generalised set! in Racket

2015-07-01 Thread Alexander D. Knauth


On Jul 1, 2015, at 4:27 AM, Alexey Cherkaev alexey.cherk...@gmail.com wrote:

 Hi all,
 
 Thanks to all replies, at the moment I would tend to agree that generalised 
 `set!` might not be such a great idea after all:
 The notion of 'place' is essentially a pointer to a memory location, but it 
 is not the first-class citizen: the following expressions are not equivalent: 
 (let ((x (aref v 5))) (set! x 100)) and (set! (aref v 5) 100), and it might 
 be the place for confusion.
 The syntax part of it, `(set! (what-ever ...) new-value)`, however, I don't 
 mind: `set!` is a special form/macro after all, not a procedure. No one would 
 demand the procedural clarity from `let` or `define`. The question is rather 
 if it worth having yet another special form.
The syntax part of it is what srfi/17 does, and anyone who requires srfi/17 
hopefully understands that it’s another special form, and that the (what-ever 
…) is not actually an expression, and hopes that people reading the code will 
also understand that. Because of the first point, it’s best that it’s in a 
separate library like srfi/17, not available by default, because that avoids 
confusion unless you require srfi/17 on purpose. 

 Summarising the points above, what if instead of `set!` there is a more 
 general abstraction 'location’:

Side note: Such a `location` abstraction doesn’t have to be all about 
mutability.

There is a purely functional version of this concept in Jack Firth's `lenses` 
package, which says that
lenses are functions that take a data structure and returns two values;
 the first being the “view,” or the value at that location,
 and the second being the “context” of that value, represented as a function 
that acts as a functional “setter,”
and these lenses are functional and compose-able.

http://pkg-build.racket-lang.org/doc/lenses@lenses/index.html
https://github.com/jackfirth/lenses

Also, because lenses return two values, they don't have to allocate a new 
structure every time, which (I think) means slightly better performance.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] generalised set! in Racket

2015-06-30 Thread Alexander D. Knauth


On Jun 30, 2015, at 5:34 PM, 'John Clements' via Racket Users 
racket-users@googlegroups.com wrote:

 Specifically, one of the basic ideas of algebraic languages is that programs 
 are compositional. Specifically, if I write (a (b x) c), then the meaning of 
 this term depends on the meanings of a, (b x), and c. That is, I can combine 
 these three values to get the result. Generalized set! breaks this intuition. 
 Specifically, (set! (aref x 0 1) 13) does not depend on the value of (aref x 
 0 1). Rather, it pulls apart this term and uses its subterm’s meanings.

Actually, this makes a lot of sense to me and is probably the best argument 
I’ve heard for why lvalues can be a bad idea.
(and some time ago I read the discussion on SRFI 17, just for fun looking at 
the reasoning on both sides)
Thanks!


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] generalised set! in Racket

2015-06-29 Thread Alexander D . Knauth


On Jun 29, 2015, at 5:56 AM, Alexey Cherkaev alexey.cherk...@gmail.com wrote:

 For example, I was thinking of defining syntax to access my implementation of 
 multidimensional arrays
 as
 
 (define-syntax aref
  (syntax-rules (set!)
[(set! (aref ?a ?i ...) ?v) (array-set! ?a ?i ... ?v)]
[(aref ?a ?i ...) (array-ref ?a ?i ...)]))
 
 but obviously it won't work now as `set!` expects the `id` not an expression 
 (`syntax-id-rules` won't work either as `aref` is not an `id`).


#lang racket
(require srfi/17 math/array)
(define (aref a . is)
  (array-ref a (list-vector is)))
(set! (setter aref)
  (λ (a . is+v)
(match-define (list is ... v) is+v)
(array-set! a (list-vector is) v)))
(define a (mutable-array #[#[1 2] #[3 4]]))
(aref a 0 1)
(set! (aref a 0 1) 20)
(aref a 0 1)

If you wanted, you could also define your own version of set! that does what 
you want, which (I think) you would need to do if you needed aref to be a macro.


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Fast way to map over a list many times, changing ONE element each time?

2015-06-26 Thread Alexander D. Knauth

Is there a split-at-reverse anywhere, equivalent to split-at except that the 
first return value is reversed?
If not, should that be added somewhere like srfi/1?

I’m asking because wanted to be able to write functions like:

(define ((drop-lens n) lst)
  (define-values [fst-lst rst-lst] (split-at-reverse lst n))
  (values rst-lst (λ (x) (append-reverse fst-lst x

(define ((list-ref-lens i) lst)
  (match-define-values [fst-lst val:rst-lst] (split-at-reverse lst i))
  (match-define (cons val rst-lst) val:rst-lst)
  (values val (λ (x) (append-reverse fst-lst (cons x rst-lst)

These are lenses as used in this package:
https://github.com/jackfirth/lenses

I wrote my own version of split-at-reverse, but I’m wondering if it should be 
put in something like srfi/1 as a companion to append-reverse, or if it perhaps 
already is in some other library.

Alex Knauth

On Jun 19, 2015, at 4:28 PM, Jens Axel Søgaard jensa...@soegaard.net wrote:

 A more efficient version using append-reverse from srfi/1.
 
 #lang racket
 (require (only-in srfi/1 append-reverse))
 
 (define (list-splits xs)
   (define (loop ys zs)  ; xs = (append (reverse ys) yz)
 (match zs
   ['()  '()]
   [(cons z zs*) (cons (list ys zs)
   (loop (cons z ys) zs*))]))
   (loop '() xs))
 
 
 (define (map-once f xs)
   (for/list ([ys+zs (list-splits xs)])
 (match ys+zs
   [(list ys '()) '()]
   [(list ys (cons z zs)) (append-reverse ys (cons (f z) zs))])))
 
 (list-splits  '(1 2 3))
 (map-once sqr '(1 2 3))
 
 
 2015-06-19 22:07 GMT+02:00 Jens Axel Søgaard jensa...@soegaard.net:
 #lang racket
 (define (list-splits xs)
   (define (loop ys zs)  ; xs = (append (reverse ys) yz)
 (match zs
   ['()  '()]
   [(cons z zs*) (cons (list ys zs)
   (loop (cons z ys) zs*))]))
   (loop '() xs))
 
 
 (define (map-once f xs)
   (for/list ([ys+zs (list-splits xs)])
 (match ys+zs
   [(list ys '()) '()]
   [(list ys (cons z zs)) (append (reverse ys) (cons (f z) zs))])))
 
 (list-splits  '(1 2 3))
 (map-once sqr '(1 2 3))
 
 
 2015-06-19 22:05 GMT+02:00 Jon Zeppieri zeppi...@gmail.com:
 It's unlikely that an implementation using continuations would be
 faster than one that does not.
 
 An idiomatic solution might look like:
 
 (define (map-once fn xs)
   (for/list ([i (in-range (length xs))])
 (for/list ([(x j) (in-indexed (in-list xs))])
   (cond [(= i j) (fn x)]
 [else x]
 
 
 But it's not terribly fast.
 If you're willing to use vectors instead of lists, then maybe:
 
 (define (map-once fn xs)
   (build-vector (vector-length xs)
 (λ (i)
   (define v (vector-copy xs))
   (vector-set! v i (fn (vector-ref v i)))
   v)))
 
 
 On Fri, Jun 19, 2015 at 3:24 PM, Luke Miles rashreportl...@gmail.com wrote:
  Say I have a list ls and I want to produce a list of
  lists where the i'th list has the i'th element of ls tripled,
  but all other elements are the same.
 
  e.g. '(3 5 7) = '((9 5 7) (3 15 7) (3 5 21))
 
  What is a fast way to do this?
 
 
  I could do a loop with appending.
  (define (map-once f ls)
(let M ([sooner null] [later ls])
  (if (null? later) null
(cons (append sooner (list (f (car later))) (cdr later))
  (M (append sooner (list (car later))) (cdr later))
 
  - (map-once sqr '(4 5 6))
  '((16 5 6) (4 25 6) (4 5 36))
 
  Unfortunately, this is very slow  messy.
  I have to do 2 big appends for every element is the return list.
 
 
  Here is a cleaner-looking, but still slow way:
  (define (list-set ls i new-val)
(let-values ([(sooner later) (split-at ls i)])
  (append sooner (list new-val) (cdr later
 
  (define (map-once f ls)
(for/list ([i (in-naturals)]
   [elm (in-list ls)])
  (list-set ls i (f elm
 
 
  I'm thinking a good implementation might use continuations somehow?
 
  Maybe of vector-set (without the exclamation point) existed, I could use it?
 
  --
  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.
  For more options, visit https://groups.google.com/d/optout.
 
 --
 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.
 For more options, visit https://groups.google.com/d/optout.
 
 
 
 -- 
 -- 
 Jens Axel Søgaard
 
 
 
 
 -- 
 -- 
 Jens Axel Søgaard
 
 
 -- 
 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.
 For more options, visit

Re: [racket-users] try a new macro expander

2015-06-25 Thread Alexander D. Knauth

Another weird error:
#lang racket/base
(require racket/stxparam (for-syntax racket/base))
(define-syntax-parameter add (make-rename-transformer #'+))
(define-syntax add1 (make-rename-transformer #'add))
add1

;add1: identifier's binding is ambiguous
;  context.:
;  matching binding.:
;  matching binding.:
;  = add context.:
;  = add matching binding.:
;  matching binding.: in: add1

I found this because of this Travis CI build failure:
https://travis-ci.org/AlexKnauth/infix-macro/jobs/68245124#L164

On Jun 25, 2015, at 12:31 AM, Matthew Flatt mfl...@cs.utah.edu wrote:

 Yes, I overlooked `splicing-local`, and I'll repair it. Thanks for the
 report!
 
 At Wed, 24 Jun 2015 20:27:39 -0400, Alexander D. Knauth wrote:
 I’ve just found something that I expected to work, but didn’t:
 
 #lang racket/base
 (require racket/splicing (for-syntax racket/base))
 (splicing-local
[(define x 1)]
  (define-syntax outer-x (make-rename-transformer #'x)))
 outer-x
 
 ;. outer-x: unbound identifier in module in: outer-x
 
 This works in the current expander, but fails in the scope-set expander.
 
 It does work for splicing-let and splicing-letrec though.
 
 I found it because I rely on it in this macro here:
 https://github.com/AlexKnauth/my-object/blob/master/my-object/stuff.rkt#L25
 And Travis CI was giving me this error:
 https://travis-ci.org/AlexKnauth/my-object/jobs/68248192#L209
 
 On Jun 22, 2015, at 8:25 AM, Matthew Flatt mfl...@cs.utah.edu wrote:
 
 At Thu, 21 May 2015 07:15:14 -0600, Matthew Flatt wrote:
 Otherwise, be prepared for me to come back in a few
 weeks and lobby for moving to a new macro expander.
 
 Here's the proposal: let's switch on July 16. Switch means that I'd
 merge the new macro expander to the master branch of the development
 repository.
 
 Thanks to those who have tried the new expander and reported back!
 Meanwhile, I've expanded the write-up and filled out the formal model
 (at the same URL as before).
 
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] try a new macro expander

2015-06-24 Thread Alexander D. Knauth

I’ve just found something that I expected to work, but didn’t:

#lang racket/base
(require racket/splicing (for-syntax racket/base))
(splicing-local
[(define x 1)]
  (define-syntax outer-x (make-rename-transformer #'x)))
outer-x

;. outer-x: unbound identifier in module in: outer-x

This works in the current expander, but fails in the scope-set expander.

It does work for splicing-let and splicing-letrec though.

I found it because I rely on it in this macro here:
https://github.com/AlexKnauth/my-object/blob/master/my-object/stuff.rkt#L25
And Travis CI was giving me this error:
https://travis-ci.org/AlexKnauth/my-object/jobs/68248192#L209

On Jun 22, 2015, at 8:25 AM, Matthew Flatt mfl...@cs.utah.edu wrote:

 At Thu, 21 May 2015 07:15:14 -0600, Matthew Flatt wrote:
 Otherwise, be prepared for me to come back in a few
 weeks and lobby for moving to a new macro expander.
 
 Here's the proposal: let's switch on July 16. Switch means that I'd
 merge the new macro expander to the master branch of the development
 repository.
 
 Thanks to those who have tried the new expander and reported back!
 Meanwhile, I've expanded the write-up and filled out the formal model
 (at the same URL as before).


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Defining contracts sanely

2015-06-21 Thread Alexander D. Knauth


On Jun 21, 2015, at 5:41 AM, Aidan Gauland aidal...@slingshot.co.nz wrote:

 Say I want to define a flat contract for the freshness field of my
 fish class, so I define a contract for it like so:
 
 (define/contract fish-freshness/c
  (- any/c
  boolean?)
  (flat-named-contract 'fish-freshness/c
(lambda (x)
  (not (eq? #f (member x '(fresh frozen edible rotten)))
 
 Am I barking up the wrong tree here, or is this perfectly sensible?
 
 Regards,
 Aidan Gauland

If this does what you want, it’s fine, but the define/contract is probably 
unnecessary, and
(define fish-freshness/c
  (flat-named-contract ‘fish-freshness/c
(lambda (x)
  (not (eq? ….)
Should do what you want.

The flat-named-contract is also probably unnecessary (though it can be useful 
if the name isn’t just a symbol), so
(define (fish-freshness/c x)
  (not (eq? ….)))
Will also do what you want.

And finally, another way of doing this would be:
(define fish-freshness/c (or/c ‘fresh ‘frozen ‘edible ‘rotten))

Or if you prefer giving the contract a better name for error messages:
(define fish-freshness/c
  (flat-named-contract ‘fish-freshness/c (or/c ‘fresh ‘frozen ‘edible ‘rotten)))

Any one of these is “sane” as long as they work, and it depends on which one 
you think looks more readable, makes you’re intent clear, and gives error 
messages that make sense.

I just finished this when I saw Matthias Felleisen’s reply.  I’m sending it 
anyway.


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Closing big-bang windows

2015-06-21 Thread Alexander D. Knauth


On Jun 21, 2015, at 10:18 PM, Neil Toronto neil.toro...@gmail.com wrote:

 I'm working on a `big-bang3d` game intended to expose shortcomings in 
 universe-style programs when used at a larger scale than in the classroom. 
 Here are my main criticisms so far:
 
 1. Adding new state is painful. Every time I add a little bit to track
something - a cooldown timer, camera momentum, a list of planes the
player collided against - I have to change a lot of unrelated code.

 For #1, I think we need nicer ways to reach deep into heterogeneous data 
 structures to read from and update them. Refactoring data structures only 
 goes so far. Game state is a big, messy thing with a lot of interaction that 
 defies neatly compartmentalized trees.

For this problem, I wonder if using compose-able functional lenses like this 
would be a good solution:
https://github.com/jackfirth/lenses
http://pkg-build.racket-lang.org/doc/lenses@lenses/index.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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Reporting Simple Bugs and Fixing Them

2015-06-20 Thread Alexander D. Knauth


On Jun 20, 2015, at 12:39 PM, Kartik Singhal kartiksing...@gmail.com wrote:

 On Friday, June 19, 2015 at 7:14:56 AM UTC+5:30, Alex Knauth wrote:
 Also, if you’re interested, I found this blog post helpful:
 http://www.greghendershott.com/2013/04/a-guide-for-infrequent-contributors-to-racket.html
 Although for the HTDP student languages you’d want to think “racket/htdp” 
 when it says “plt/racket”, and you’d skip the `make` steps. 
 (If it were something other than documentation typos, you’d want to use the 
 package system instead for that, but that doesn’t apply here)
 
 
 Thanks for sharing link to this blog post, I found Tutorial: Contributing to 
 Racket[1] helpful as well, in building the latest racket source locally.
 
 But I can't find any instructions for how to build/install latest DrRacket 
 after cloning it from GitHub and link it with my fresh racket build. I looked 
 at 'Building Installers' section at [2], but that looks needlessly 
 complicated for my need -- I just want to generate a build for my local 
 machine (Mac OS X) for small hacks to DrRacket IDE.
 
 Perhaps I need to use the package system as you mention, but it's not clear 
 what is the correct way of doing that.

The way I’ve done it for things like DrRacket is to get a recent snapshot 
installation from one of http://pre.racket-lang.org/installers/, and then 
cloning my fork of the drracket repository (or another repo) on my computer (if 
I haven’t already).
After that, I have a normal directory, and I can use the normal `raco pkg 
update path/to/drracket/drracket/`, or the DrRacket package manager with that 
path, to update the package to point to that directory in my clone of the 
repository.

That has worked for me, although there could be better ways of doing it.  
There’s the raco pkg update --clone option, for instance, but I haven’t used 
that yet.

 [1]: http://blog.racket-lang.org/2012/11/tutorial-contributing-to-racket.html
 [2]: https://github.com/plt/racket/blob/master/INSTALL.txt

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Macro-introducing macros with inter-macro communication channel

2015-06-20 Thread Alexander D. Knauth


On Jun 19, 2015, at 7:44 PM, Thomas Dickerson thomas_dicker...@brown.edu 
wrote:

 I was intending for that example to have the variables be defined outside the 
 macro, but being able to create the (set! ...) forms outside should mean I 
 could also hypothetically create let/define-values forms. This is why I 
 originally specified being able to effect generation of both prologue + 
 epilogue code.

I figured this out for code that will be expanded after the body:

#lang racket/base

(require racket/stxparam
 (for-syntax racket/base
 syntax/parse
 racket/set
 ))

;; (syntax-parameter-value vars) : (U #f (MutableSetof Identifier))
(define-syntax-parameter vars #f)

(define-syntax Accum
  (lambda (stx)
(syntax-parse stx
  [(Accum x:id dx:expr)
   (define vs (syntax-parameter-value #'vars))
   (unless (set-mutable? vs)
 (raise-syntax-error #f cannot be used outside Loop stx))
   (set-add! vs (syntax-local-introduce #'x))
   #'(set! x (+ x dx))])))

(define-syntax set-accums-zero!
  (syntax-parser
[(set-accums-zero!)
 #:with [x ...]
 (map syntax-local-introduce (set-list (syntax-parameter-value #'vars)))
 #'(begin (set! x 0) ...)]))

(define-syntax Loop
  (syntax-parser
[(Loop up-to-expr:expr body:expr ...+)
 #'(syntax-parameterize ([vars (mutable-set)])
 (let ([up-to up-to-expr])
   (letrec
   ([loop
 (lambda (n)
   body
   ...
   (if ( n up-to)
   (loop (add1 n))
   (void)))])
 (set-accums-zero!)
 (loop 0]))

(let ([x x] [y y] [z z])
  (Loop 10
(begin
  (define-values 
[dx dy dz] 
(values 1 2 3))
  (printf x = ~v, y = ~v, z = ~v\n x y z)
  (Accum x dx)
  (Accum y dy)
  (Accum z dz

To generate a let outside of that you’d probably need to do some kind of 
local-expand, but I’m not sure.


 On Friday, June 19, 2015 at 6:47:15 PM UTC-4, Alex Knauth wrote:
 Are the x, y, and z variables meant to be defined outside the macro by the 
 user as in:
 (let ([x “something”] [y “something else”] [z “and something else”])
   (Loop ….))
 ?
 
 
 Or should the Loop macro create a (let ([x 0] [y 0] [z 0]) ….) for you 
 instead?
 
 
 On Jun 19, 2015, at 5:58 PM, Thomas Dickerson thomas_d...@brown.edu wrote:
 
 
 Sure, here's a toy example.
 
 This code:
 
 
 (Loop 10
   (begin
 (define-values 
   [dx dy dz] 
   (values 0 0 0))
 ; Some calculation here
 (Accum x dx)
 (Accum y dy)
 (Accum z dz)))
 
 Should desugar into this code:
 (letrec 
 ([loop 
   (lambda (n) 
 (begin
   (define-values 
 [dx dy dz] 
 (values 0 0 0))
   ; Some calculation here
   (set! x (+ x dx))
   (set! y (+ y dy))
   (set! z (+ z dz)))
 (if ( n 10)
 (loop (+ 1 n))
 (void)))])
   (set! x 0)
   (set! y 0)
   (set! z 0)
   (loop 0))
 
 
 And in general, every unique id occuring in an (Accum id delta) in the loop 
 body should result in (set! id 0) in the prologue.
 
 
 Also, some context to avoid unproductive side-conversation: I'm using 
 Racket's macro facility to do pre-compilation of a totally different 
 language. The fully-expanded program in this case is going to be a call to a 
 function that rewrites Racket syntax objects into strings in the syntax of 
 something which isn't Racket. This means that I really want my original 
 question answered, rather than suggestions to solve a different problem that 
 happens to accomplish the same thing for this toy example. The critical 
 pieces here are that Accum only be defined within the body of a Loop, and 
 that it be able to communicate outwards to effect the code generation of the 
 specific instantiation of Loop in which it appears.
 
 
 
 
 
 
 
 
 
 
 Thomas Dickerson
 
 Brown University
 Department of Computer Science
 
 115 Waterman St, 4th Floor
 
 Providence, RI 02912
 
 802-458-0637
 
 
 
 On Fri, Jun 19, 2015 at 3:22 PM, Ryan Culpepper ry...@ccs.neu.edu wrote:
 On 06/19/2015 03:07 PM, Thomas Dickerson wrote:
 
 
 Hi All,
 
 
 
 I'm trying to figure out how best to implement the following pattern of 
 macro behavior:
 
 
 
 Let's say we are writing Loop macro that implements a looped computation 
 over a specified body. I would like to then be able to
 
 (a) introduce additional Loop-specific macros that are defined only within 
 the scope of the body
 
 (b) are able to coordinate with the outer macro so as to alter its 
 generation of prologue and epilogue code.
 
 
 
 My best guess here is some use of local-expand with 
 syntax-local-bind-syntaxes, or perhaps syntax-parameterize, but I can't 
 quite work out the appropriate constructions.
 
 
 
 I've been able to

Re: [racket-users] Macro-introducing macros with inter-macro communication channel

2015-06-19 Thread Alexander D. Knauth

Are the x, y, and z variables meant to be defined outside the macro by the user 
as in:
(let ([x “something”] [y “something else”] [z “and something else”])
  (Loop ….))
?

Or should the Loop macro create a (let ([x 0] [y 0] [z 0]) ….) for you instead?

On Jun 19, 2015, at 5:58 PM, Thomas Dickerson thomas_dicker...@brown.edu 
wrote:

 Sure, here's a toy example.
 
 This code:
 (Loop 10
   (begin
 (define-values 
   [dx dy dz] 
   (values 0 0 0))
 ; Some calculation here
 (Accum x dx)
 (Accum y dy)
 (Accum z dz)))
 
 Should desugar into this code:
 (letrec 
 ([loop 
   (lambda (n) 
 (begin
   (define-values 
 [dx dy dz] 
 (values 0 0 0))
   ; Some calculation here
   (set! x (+ x dx))
   (set! y (+ y dy))
   (set! z (+ z dz)))
 (if ( n 10)
 (loop (+ 1 n))
 (void)))])
   (set! x 0)
   (set! y 0)
   (set! z 0)
   (loop 0))
 
 And in general, every unique id occuring in an (Accum id delta) in the loop 
 body should result in (set! id 0) in the prologue.
 
 Also, some context to avoid unproductive side-conversation: I'm using 
 Racket's macro facility to do pre-compilation of a totally different 
 language. The fully-expanded program in this case is going to be a call to a 
 function that rewrites Racket syntax objects into strings in the syntax of 
 something which isn't Racket. This means that I really want my original 
 question answered, rather than suggestions to solve a different problem that 
 happens to accomplish the same thing for this toy example. The critical 
 pieces here are that Accum only be defined within the body of a Loop, and 
 that it be able to communicate outwards to effect the code generation of the 
 specific instantiation of Loop in which it appears.
 
 
 Thomas Dickerson
 
 Brown University
 Department of Computer Science
 115 Waterman St, 4th Floor
 Providence, RI 02912
 
 802-458-0637
 
 On Fri, Jun 19, 2015 at 3:22 PM, Ryan Culpepper ry...@ccs.neu.edu wrote:
 On 06/19/2015 03:07 PM, Thomas Dickerson wrote:
 Hi All,
 
 I'm trying to figure out how best to implement the following pattern of macro 
 behavior:
 
 Let's say we are writing Loop macro that implements a looped computation over 
 a specified body. I would like to then be able to
 (a) introduce additional Loop-specific macros that are defined only within 
 the scope of the body
 (b) are able to coordinate with the outer macro so as to alter its generation 
 of prologue and epilogue code.
 
 My best guess here is some use of local-expand with 
 syntax-local-bind-syntaxes, or perhaps syntax-parameterize, but I can't quite 
 work out the appropriate constructions.
 
 I've been able to implement something similar using syntax-case functions on 
 syntax objects at phase-0, by essentially implementing my own namespace for 
 macros and passing it as an explicit argument, but this loses the hygiene 
 benefits of coordinating with expand.  I had an offline discussion with 
 Shriram yesterday in which he suggested looking into ways to reify the 
 expansion-time namespace, but obviously current-namespace does the wrong 
 thing here.
 
 Can you provide a small example program and describe how you want it to 
 behave?
 
 Ryan
 
 
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Reporting Simple Bugs and Fixing Them

2015-06-18 Thread Alexander D. Knauth


You could probably use either one, but a github pull request would be more 
helpful, I think.

Also, if you’re interested, I found this blog post helpful:
http://www.greghendershott.com/2013/04/a-guide-for-infrequent-contributors-to-racket.html
Although for the HTDP student languages you’d want to think “racket/htdp” when 
it says “plt/racket”, and you’d skip the `make` steps. 
(If it were something other than documentation typos, you’d want to use the 
package system instead for that, but that doesn’t apply here)

On Jun 18, 2015, at 8:55 PM, Jeffrey Edgington jedgi...@du.edu wrote:

 Greetings,
 
 Recently while looking through the documentation on the Student Languages,
 I noticed a few mispelled words.
 
 (sorry for the beginner questions that follow)
 
 Are issues such as this reported through the Bug Report Form under Help?
 
 (I only saw a few bugs of this type listed on bugs.racket-lang.org)
 
 Or do people just fix them and ask for it to be added in Git?
 
 I ask because I am hoping to understand and “walk through” the process using 
 a 
 simple case so I can start to contribute (even in some small way) to this 
 community.
 
 Thank you!
 
 Jeffrey Edgington
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] DrRacket rendering issues OS X

2015-06-17 Thread Alexander D. Knauth

One data point:
I’m using DrRacket version 6.2.0.4--2015-06-08 with OS X Version 10.9.5, and if 
I remember correctly it was a Racket plus Tests 64-bit installation.
I tried those steps, and it worked fine, with no weird black areas, though I do 
remember occasionally getting similar small black areas in the past, covering 
just the tab bar or something like that, and when I moved my mouse over it it 
fixed itself? I’m not sure if I remember that correctly, and I’m not sure if 
that could be related to what you got, because that wasn’t with full screen or 
the mission control screen, and I could not produce that consistently.

On Jun 17, 2015, at 12:25 PM, Andrew Kent andmk...@indiana.edu wrote:

 Good day all!
 
 First, I just wanted to say DrRacket is *amazing* and thank all who have 
 helped it become what it is today! I'm currently using it to work on Typed 
 Racket and it is a godsend.
 
 Right now, unfortunately, I am having some problems w/ DrRacket rendering in 
 OS X -- I am getting large black areas appearing in full screen mode in 
 DrRacket. They seem pretty serious/severe, and I was curious if anyone else 
 has seen this behavior?
 
 PDF w/ screenshots  some attempt to describe problem(s):
 https://drive.google.com/file/d/0B-HcU1nZPrwJWXFNbEdOV0doeUE/view?usp=sharing
 
 Steps that seem to recreate issue:
 1) Open DrRacket
 2) Make it full screen by clicking green button at top left of DrRacket
 3) Open OS X ‘Mission Control’ (cmd+up or 3-finger-swipe up on touchpad) 4) 
 Close OS X ‘Mission Control’ (cmd+down or 3-finger-swipe downon
 touchpad) nd
 5) Repeat 3-4 a couple times (after the 2 time it seemed to consistently
 happen on my machine)
 
 - This worked whether or not I was plugged into the external monitor
 - the snapshots reproduced the issue on were the Racket plus Tests | Mac OS X 
 | 32-bit Intel distribution for version 6.2.0.4 (20150609-bf12a2b)  version 
 6.2.0.4 (20150617-97827ac)
 - I’m running the latest OS X Yosemite (Version 10.10.3 (14D136)) on a early 
 2013 13” MacBook Air
 
 
 Best,
 Andrew
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] 3d-syntax and sharing values between read-time and run-time?

2015-06-15 Thread Alexander D. Knauth

I just tried doing something for Asumu Takikawa’s `#lang clojure` with reading 
sets.

In the reader module #{1 2 3} is read, and the reader returns a syntax object 
created with
(datum-syntax … (list-set …) …)

And then if I write (quote #{1 2 3}), it actually works?

I’m a bit pleasantly surprised, because I was pretty sure this would fail with 
some kind of error related to 3d-syntax.

Is there a reason why this should always work?

Or is there a situation where this will sometimes fail?


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] iso-recursive types not allowed in TR?

2015-06-15 Thread Alexander D. Knauth


On Jun 13, 2015, at 8:18 AM, Hendrik Boom hend...@topoi.pooq.com wrote:
 On Fri, Jun 12, 2015 at 06:06:05PM -0700, 'John Clements' via users-redirect 
 wrote:
 On Jun 12, 2015, at 5:52 PM, Alexander D. Knauth alexan...@knauth.org 
 wrote:
 On Jun 12, 2015, at 8:30 PM, 'John Clements' via users-redirect 
 us...@plt-scheme.org wrote:
 
 (define-type (HuffJsexpr T)
 (U T (HashTable Symbol HuffJsexpr)))
 
 Do you mean this?
 (define-type (HuffJsexpr T)
 (U T (HashTable Symbol (HuffJsexpr T

 Actually, I also can’t believe that TR allowed me to use a type constructor 
 without an argument like that.
 
 Maybe the type definitions need to be type-checked, too?
 
 -- hendrik

I was thinking about this and I was coming up with an explanation of why it 
wouldn’t work (the way TR is currently set up), but then I realized there could 
be a way of doing this that makes sense without restructuring TR, so …

First, the reason I thought it might not work: In TR a type constructor and a 
polymorphic type are the same thing. And that makes sense because it makes 
sense to instantiate polymorphic types as if they were type constructors.
But that means that when it comes across a type constructor, it sees it as a 
polymorphic type, so it doesn’t raise a type error.

But type constructors like this don’t always make sense as polymorphic types, 
because polymorphic types only really make sense when there is something in the 
value with that type that can take some kind of input, like a function, some 
data structure containing a function, an object, or even something that could 
be mutable, I guess? I’m not sure. Anyway that could be something that TR could 
check for in this kind of thing, but it seems like it could be complicated? 
Again I’m not sure.

Or would it be simpler to just separate type constructors from polymorphic 
types completely, but allow polymorphic types to be used as type constructors 
as well for backwards compatibility?  But that could involve …

Actually, I was I about to say that would probably involve restructuring a lot 
of the type checker, but then I thought maybe type constructors could be a 
container type that contains a “polymorphic” type, and when it is “applied the 
type-checker would just ignore this and look at the “polymorphic” type inside, 
but in a situation that requires an actual “non-constructor” type, it would 
raise a type error?  But then what if you wanted to define a type constructor 
that accepts type constructors as arguments (a higher-order type-constructor)?  
Again, it seems like this could also be complicated?

I’m not sure what the best thing to do is. 

Would bounded polymorphism help to solve this?  Or would it require another 
whole type system for types and type constructors?

Sorry if this doesn’t make much sense. I’m sending it anyway.


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] iso-recursive types not allowed in TR?

2015-06-13 Thread Alexander D. Knauth


On Jun 13, 2015, at 12:18 AM, 'John Clements' via users-redirect 
us...@plt-scheme.org wrote:

 Okay, I shouldn’t change topics, but while I’ve got you (guys): it looks like 
 (module+ test …) now works in TR, but not when there are imported bindings… 
 suppose I have foo.rkt:

I’ve run into similar problems with module+ before as you did below, but I 
found that something like this has worked so far:
(module* test racket/base
  (require (submod “..”) rackunit)
  … tests here …
  )

But anyway, I think I remember asking on the list and it being some problem 
with, and it might have been a problem with it being confused about whether the 
tests were typed or untyped?
http://lists.racket-lang.org/users/archive/2014-July/063668.html
http://lists.racket-lang.org/users/archive/2014-July/063669.html
http://lists.racket-lang.org/users/archive/2014-July/063670.html

But some time after that I found that (module* test racket/base …) worked.

 #lang typed/racket
 
 (provide [struct-out Z])
 
 (define-struct Z ([a : Number]))
 
 … and then try to import it in a test+:
 
 #lang typed/racket
 
 (require foo.rkt)
 
 (Z 3)
 
 (module+ test
  (Z 3))
 
 this leads to this error message:
 
 Type Checker: missing type for identifier;
 consider using `require/typed' to import it
  identifier: make-Z
  from module: (submod foo.rkt #%contract-defs-reference .. #%contract-defs) 
 in: make-Z
 
 I tried various require/typed combinations, but only managed to get an error 
 on `make-Z1`, which doesn’t sound like forward progress.
 

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] iso-recursive types not allowed in TR?

2015-06-12 Thread Alexander D. Knauth


On Jun 12, 2015, at 8:30 PM, 'John Clements' via users-redirect 
us...@plt-scheme.org wrote:

 Here’s the type I want to write:
 
 (define-type (HuffJsexpr T)
  (U T (HashTable Symbol HuffJsexpr)))


Do you mean this?
(define-type (HuffJsexpr T)
  (U T (HashTable Symbol (HuffJsexpr T

#lang typed/racket
(define-type (HuffJsexpr T)
  (U T (HashTable Symbol (HuffJsexpr T
(: x : (HuffJsexpr String))
(define x
  #hash([a . a string]
[b . #hash([c . #hash()]
   [d . another string])]
[e . #hash([f . and another])]))

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] System Scheme (RnRS): Shared Secret Generator

2015-06-12 Thread Alexander D. Knauth


On Jun 12, 2015, at 9:35 AM, Michael Titke michael.tied...@o2online.de wrote:

 On 12/06/2015 13:21, Konrad Hinsen wrote:

 Seeding is provided for two use cases: 1) Reproducibility, ... 2) Real 
 randomization, by setting the seed from some unpredictable source, such as 
 the system time. In both cases, the idea is to set the seed once at the 
 beginning of a program run.

 With your idea in #2 I would reliably produce known sequences depending on 
 only 256 original states. 

 The statistical properties of the pseudo-random sequence hold only for an 
 unperturbed sequence, i.e. without changing the seed. If you set the seed 
 every time you ask for a random number, your random sequence becomes simply 
 some complicated function of your input seed, whose statistical properties 
 are hard to predict and most probably not what you want.

 If you want to look at the system and do a black box test then the result 
 would be:

 true randomness / noise - Racket's randomness implementation with one 
 initial state - one of 256 known sequences

If you want one of 65536 known sequences, you can get 2 bytes of initial 
randomness to start though, right?
And if you want one of 16777216 known sequences, you can use 3 bytes, and so on?
Increase the seed space?

 true randomness / noise - GNU-Guile's randomness implementation - noise
 
 BTW the basic formula of cryptography is: Message |+| Randomness - Randomness
 Now replace Randomness with Racket and try to ...

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] strange bug with racket/gui

2015-06-02 Thread Alexander D. Knauth

I have never worked with a canvas% before (I have worked with a lot of other 
racket gui stuff), so I have no idea what’s going on, but watch what happens 
with this:
#lang racket
(require racket/gui/base)
(define frame (new frame%
   [label Example]
   [width 300]
   [height 300]))
(define canvas
  (new canvas% [parent frame]))
(define dc (send canvas get-dc))
(send frame show #t)
(sleep 1)
(send dc draw-rectangle 30 20 10 40)

And even better, with this:
#lang racket
(require racket/gui/base)
(define frame (new frame%
   [label Example]
   [width 300]
   [height 300]))
(define canvas
  (new canvas% [parent frame]))
(define dc (send canvas get-dc))
(send frame show #t)
(sleep 1)
(send dc draw-rectangle 30 20 10 40)
(sleep 2)


On Jun 2, 2015, at 3:17 PM, John Smith rashreportl...@gmail.com wrote:

 Alexis,
 Thank you for the speedy answer.
 I think I correctly implemented what you described. See attached.
 In the new code, no error is thrown but the rectangle is not drawn.
 Reorderings of displaying the window and drawing the rectangle appear to have 
 no effect.
 The only way I can get anything to show up is if I enter it in the REPL once 
 the code is executed.
 
 Any idea what might be causing this?
 
 -Luke
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.
 graphics-3.rkt

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] How to check for existing definitions

2015-05-31 Thread Alexander D. Knauth


On May 24, 2015, at 3:20 AM, Michael Tiedtke michael.tied...@o2online.de 
wrote:

 I can of course use /version/ to check for Racket's version but this doesn't 
 take
 patches or third party libraries/modules into account.


I was just re-reading this, and for your particular use case this has been 
answered already by Laurent, but:

One way to do this kind of thing for normal identifiers is to use this:

http://www.greghendershott.com/2014/06/fallback-when-required-function-not-available.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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] How to check for existing definitions

2015-05-27 Thread Alexander D. Knauth


On May 27, 2015, at 6:13 AM, Michael Tiedtke michael.tied...@o2online.de 
wrote:

 I'm a little bit astonished that Racket doesn't offer a defined? primitve 
 when it's not
 possible to implement it with macros because of the strange compile-time 
 behavior.

Here’s a fairly useless macro that can tell if a given identifier is defined or 
not:
#lang racket
(require (for-syntax racket/base syntax/parse))
(define-syntax defined?
  (syntax-parser
[(defined? x:id)
 (if (identifier-binding #'x)
 #'#t
 #'#f)]))
(defined? x)
(define y 3)
(defined? y)
(let ([x 4])
  (defined? x))


 Where compile time sound to me like put all the interned things together, 
 call it
 byte code and dump it into a file.

Well, there’s expansion time, which is the part of “compile time” in which 
macros expand, and in racket that’s often what people are talking about when 
they say compile time.

Racket is a lot more useful because you would never get an error about an 
unbound identifier at runtime, because it can always tell during compile time 
whether it’s bound or not.  And this makes things like `defined?` fairly 
useless at runtime, because that information is useful during expansion time 
instead.  That’s why functions like identifier-binding and syntax-local-value 
are provided.



-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Flower Garden: Open Flowers

2015-05-25 Thread Alexander D. Knauth

You could also try other options for package sources, which includes things 
like .zip files and .plt files, in addition to github repositories.
http://docs.racket-lang.org/pkg/Package_Concepts.html#%28part._concept~3asource%29

I have no experience with using anything other than a github repository though.

You could also look at these:
https://www.youtube.com/watch?v=jnPf6S0_6Xw
http://con.racket-lang.org/2013/

On May 25, 2015, at 3:30 AM, Michael Tiedtke michael.tied...@o2online.de 
wrote:

 
 Il giorno 23/mag/2015, alle ore 19.28, Matthias Felleisen ha scritto:
 
 
 Why don't you put this into github and register it with the package server? 
 
 
 Well, I tried to download git for my Mac twice. Two times it was interrupted
 after half of the 20MB version control monster had been downloaded. So,
 there won't be any repository on github because the webmob around G, my
 adblocker and ... some years ago downloads tended to fail at 99.99%.
 
 Never mind.
 
 Then I created the package as a plt file and uploaded it to the /planet/ 
 server.
 Still it does not appear in the catalog of Dr. Racket's package manager while 
 it
 can be found with the web interface. But it doesn't show the nice description
 I put into the description field.
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Typed racket equivalent of Haskell newtype?

2015-05-24 Thread Alexander D. Knauth

Also opaque types might help you:
http://docs.racket-lang.org/ts-reference/special-forms.html#%28form._%28%28lib._typed-racket%2Fbase-env%2Fprims..rkt%29._require%2Ftyped%29%29
http://docs.racket-lang.org/ts-reference/type-ref.html#%28form._%28%28lib._typed-racket%2Fbase-env%2Fbase-types-extra..rkt%29._.Opaque%29%29

If you wanted sub-typing too, then refinement types would help, except I don’t 
think they work yet.

An example of using them for radians and degrees:

untyped-radians-degrees.rkt:
#lang racket/base
(provide radians? real-radians radians-real
 degrees? real-degrees degrees-real
 radians-degrees degrees-radians)
(require racket/math)
(define (radians? v) (real? v))
(define (real-radians x) x)
(define (radians-real x) x)
(define (degrees? v) (real? v))
(define (real-degrees x) x)
(define (degrees-real x) x)

typed-radians-degrees.rkt:
#lang typed/racket/base
(require/typed/provide untyped-radians.rkt
   [#:opaque Radians radians?]
   [real-radians [Real - Radians]]
   [radians-real [Radians - Real]]
   [#:opaque Degrees degrees?]
   [real-degrees [Real - Degrees]]
   [degrees-real [Degrees - Real]]
   [radians-degrees [Radians - Degrees]]
   [degrees-radians [Degrees - Radians]])

try-radians-degrees.rkt:
#lang typed/racket/base
(require typed-radians-degrees.rkt)
(: d-90 : Degrees)
(define d-90 (real-degrees 90.0))
; type mismatch!
(: r-PI : Radians)
(define r-PI (real-degrees 180.0))


On May 23, 2015, at 11:34 PM, Stuart Hungerford stuart.hungerf...@gmail.com 
wrote:

 On Sunday, 24 May 2015 12:50:48 UTC+10, Matthias Felleisen  wrote:
 
 Stuart, would a predicated refinement type work for you: 
 
 -- 
 http://docs.racket-lang.org/ts-reference/special-forms.html?q=define-predicate#%28form._%28%28lib._typed-racket%2Fbase-env%2Fprims..rkt%29._make-predicate%29%29
 
 Looking into that now--many thanks.
 
 Stu  
 
 
 

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] test amazes me

2015-05-24 Thread Alexander D. Knauth

Look at what this does:
#lang racket
(require test-engine/racket-tests)
(check-expect 1 1)
(check-expect 2 2)
(check-expect 3 3)
(check-expect (displayln hello) (displayln world))
(test)
(test)
Welcome to DrRacket, version 6.2.0.3--2015-05-17(542b960/a) [3m].
Language: racket [custom]; memory limit: 8182 MB.
world
hello
All 4 tests passed!
world
hello
All 8 tests passed!
 

The test expressions are each evaluated twice, and each test passes a second 
time.

I imagine this could be considered useful if for instance the tests depended on 
a mutable value and that value was mutated in between the runs of test, but was 
that the intention? I don’t know.

Also it appears to evaluate the second expression first and the first 
expression second. Weird.


On May 24, 2015, at 6:42 PM, Jos Koot jos.k...@gmail.com wrote:

 #lang racket
  
 (module a racket
  (require test-engine/racket-tests)
  (check-expect 1 1)
  (test))
  
 (module b racket
  (require test-engine/racket-tests)
  (check-expect 2 2)
  (test))
  
 (require 'a 'b)
  
 This gives me:
  
 Welcome to DrRacket, version 6.2.900.3--2015-05-16(e8b52f6/a) [3m].
 Language: racket [custom]; memory limit: 2000 MB.
 The only test passed!
 All 3 tests passed!
  
 Apparently test does not clear the list of tests already done.
 But even then I am surprised by seeing THREE tests passed.
 Without clearing the accumulated tests, I would expect:
 All TWO tests passed!
  
 Should test not eliminate the tests already done from the list of tests to be 
 gathered in future?
 And how come (require 'a 'b) does THREE tests, not TWO?
  
 Is is not a big problem. I am just curious.
 Thanks,
 Jos
  
  
  
  
  
  
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] Typed racket equivalent of Haskell newtype?

2015-05-23 Thread Alexander D. Knauth

As far as I know, this doesn’t exist in typed racket currently, but I’m 
wondering:  (I’m thinking of seeing if I can implement this when I have time 
this summer)

How should sub-typing interact with this?
Should it be a completely separate type, not related by sub-typing at all, or 
should the new type be a subtype of the representation type?
What should happen if values with these types crossed into untyped code? 
What should happen if an untyped program passes a normal flonum to a function 
that was supposed to accept Radians?
Would you want to be able to supply a predicate to check properties of the 
values of the new type? 

If you want them to be completely separate types, then I think what you have 
with struct will work fine, and the link you provided does say that Haskell 
newtypes are similar to using data with a single variant with a single field.

Although if it matters to you there will be the extra overhead of allocating 
the structs, accessing the fields and that kind of thing, which could be 
avoided if a newtype-like feature existed.

Alex Knauth


On May 23, 2015, at 4:21 PM, Stuart Hungerford stuart.hungerf...@gmail.com 
wrote:

 Hi,
 
 Is there an idiomatic Typed Racket equivalent to the Haskell concept of 
 newtypes?
 
 https://www.haskell.org/tutorial/moretypes.html
 
 That is, some way to have separate types that share a common structure? 
 
 For example I'd like to define Radians and Degrees types that are both 
 implemented as Flonums but have Typed Racket raise a type error when a 
 Radians value is used where a Degrees value is expected. I can see using 
 single field structs might work:
 
 (struct: Radians ([a : Flonum]))
 
 (struct: Degrees ([a : Flonum]))
 
 ; type checks
 (: d-90 : Degrees)
 (define d-90 (Degrees 90.0))
 
 ; type mismatch!
 (: r-PI : Radians)
 (define r-PI (Degrees 180.0))
 
 
 Is there a better way of working with the Typed Racket idioms to do this kind 
 of thing?
 
 Thanks,
 
 Stu

-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Is there a way to access test submodule from repl in DrRacket?

2015-05-23 Thread Alexander D. Knauth

Is there a way to access definitions in the test submodule from the repl in 
DrRacket as if I were in the repl of the test submodule?

I tried these and they didn’t work:

#lang racket
(require racket/enter)
(module+ test
  (define x 3))

 (enter! (submod try-repl-submod-test.rkt test))
 x
x: undefined;
 cannot reference an identifier before its definition
 (current-namespace (module-namespace '(submod try-repl-submod-test.rkt 
 test)))
 x
x: undefined;
 cannot reference an identifier before its definition

Using require works if I explicitly provide it from x from the test submodule, 
but I was hoping to be able to access it as if I were in the repl of the test 
submodule.  


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] racket versus racket/base

2015-05-23 Thread Alexander D. Knauth

It sounds to me like you're understanding this perfectly.
racket provides all of racket/base for-syntax.

On May 23, 2015, at 1:52 PM, Jos Koot jos.k...@gmail.com wrote:

 This works:
  
 #lang racket
 (define-syntax (x y) (syntax-case y () (_ (syntax (quote monkey)
 x ; - monkey
  
 This does not work
  
 #lang racket/base
 (define-syntax (x y) (syntax-case y () (_ (syntax (quote monkey)
  
 gives the expansion time error:
  
 syntax-case: unbound identifier in the transformer environment;
  also, no #%app syntax transformer is bound in: syntax-case
  
 This does work:
  
 #lang racket/base
 (require (for-syntax (only-in racket/base syntax syntax-case)))
 (define-syntax (x y) (syntax-case y () (_ (syntax (quote monkey)
 x ; - monkey
  
 And this works too:
  
 #lang racket/base (syntax-case #'x () #''monkey) - monkey
  
 This puzzles me. Both syntax-case and syntax are provided by both racket/base 
 and racket.
 It is as though racket provides syntax and syntax-case for syntax too and 
 that syntax/base does not.
 Probably I am misunderstanding things, but what?
  
 Thanks, Jos
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Is there a way for a function to tell how many values it's caller expects? (the continuation expects?)

Is there a way for a function to tell how many values it’s caller expects it to 
return?

I’ve tried this and it didn’t work:
#lang racket
(define (show-k-arity)
  (let/ec k
(error 'print-k-arity the arity of k is ~v (procedure-arity k
(let-values ([(x y) (show-k-arity)]) (void))


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] test submodules vs tests in separate file

If you want to have the contracts enforced in the test submodule, all you have 
to do is add (require (submod “..”)) to the submodule.

You don’t need to use define/contract, and you don’t need to use module* 
instead of module+.

You can just use

#lang racket
(provide
 (contract-out
   ; convert a fahrenheit temperature to a celsius
  [fahrenheit-celsius (- (and/c number? (=/c -459.67)) number?)]))
(define (fahrenheit-celsius f)
 (/ (* 5 (- f 32)) 9))
(module+ test
  (require rackunit (submod ..)) ; the (submod ..) makes it enforce the 
contracts
  (check-equal? (fahrenheit-celsius -40) -40)
  (check-equal? (fahrenheit-celsius 32) 0)
  (check-equal? (fahrenheit-celsius 212) 100)
  ;; this checks that it raises a contract-error
  (check-exn exn:fail:contract?
 (λ () (fahrenheit-celsius -500


On May 22, 2015, at 7:58 AM, Atticus attic...@posteo.org wrote:

 Yes, there is :
 http://docs.racket-lang.org/style/Units_of_Code.html?q=define%2Fcontract#%28part._.Contracts%29
 
 Thank you for the link. The How to Program Racket Guide will be really
 helpful.
 
 But I must admit I'm a little confused. Looking at the *fahrenheit* example 
 in the
 Guide:
 
 
 #lang racket
 
 (provide
  (contract-out
; convert a fahrenheit temperature to a celsius
[fahrenheit-celsius (- number? number?)]))
 
 (define (fahrenheit-celsius f)
  (/ (* 5 (- f 32)) 9))
 
 (module+ test
  (require rackunit)
  (check-equal? (fahrenheit-celsius -40) -40)
  (check-equal? (fahrenheit-celsius 32) 0)
  (check-equal? (fahrenheit-celsius 212) 100))
  
 
 This example implies that the contracts are enforced in the test
 submodule (contrary to Matthews example) but modifing the example shows
 that this is not the case:
 
 
 (provide
  (contract-out
; convert a fahrenheit temperature to a celsius
[fahrenheit-celsius (- integer? integer?)]))
 
 (define (fahrenheit-celsius f)
  (/ (* 5 (- f 32)) 9))
 
 (module+ test
  (require rackunit)
  (check-equal? (fahrenheit-celsius -40) -40)
  (check-equal? (fahrenheit-celsius 32) 0)
  (check-equal? (fahrenheit-celsius 212.1) 100.06))
 
 
 This is not very clear and confusing. If I would read the guide and I
 didn't know about Matthews example I would assume that the test in the
 modified example fails.
 
 My conclusion is:
 When using contracts with submodules use define/contract instead of
 (provide (contract-out ...))
 
 
 black-box tests are always embedded in documentation so that
 if the documentation does not show errors, then the system is reasonably
 correct (for bugs that already found).
 source code can keep elegant, and leave all the dirty things to scribble.
 
 This is a really nice idea. Thanks for sharing.
 
 
 WarGrey Gyoudmon Ju juzhenli...@gmail.com writes:
 
 On Fri, May 22, 2015 at 5:41 PM, Atticus attic...@posteo.org wrote:
 
 
 Imho it would be nice if there was a small hint in the documentation
 about that case, perhaps there is and I didn't see it?
 
 
 Yes, there is :
 http://docs.racket-lang.org/style/Units_of_Code.html?q=define%2Fcontract#%28part._.Contracts%29
 
 
 In practice, I design tests in a system level abstraction.
 
 black-box tests are always embedded in documentation so that
 if the documentation does not show errors, then the system is reasonably
 correct (for bugs that already found).
 source code can keep elegant, and leave all the dirty things to scribble.
 
 I almost do not write white-box tests since Racket and Typed Racket itself
 has already formal enough,
 moreover these tests or verifications can also be moved to documentation if
 needed.
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] test submodules vs tests in separate file


On May 22, 2015, at 8:19 AM, Robby Findler ro...@eecs.northwestern.edu wrote:

 Contracts mediate boundaries between parts of your program and sometimes 
 tests should go across the boundary (to help test the contracts) and 
 sometimes they should go inside (to test internal functions). You have to 
 pick one or the other with a given test module tho. 

Wouldn’t just this:
(module+ test
  (require (submod “..”))
  ; tests here
  )

Allow both of those things?

#lang racket
(provide
 (contract-out
   ; convert a fahrenheit temperature to a celsius
  [fahrenheit-celsius (- (and/c number? (=/c -459.67)) number?)]))
(define (fahrenheit-celsius f)
  (multiply-by-5/9 (- f 32)))
(define (multiply-by-5/9 x) ; not provided
  (* 5/9 x))
(module+ test
  (require rackunit (submod ..)) ; the (submod ..) makes it enforce the 
contracts
  (check-equal? (fahrenheit-celsius -40) -40)
  (check-equal? (fahrenheit-celsius 32) 0)
  (check-equal? (fahrenheit-celsius 212) 100)
  ;; this checks that it raises a contract-error
  (check-exn exn:fail:contract?
 (λ () (fahrenheit-celsius -500)))
  ;; this checks the internal unprovided function
  (check-equal? (multiply-by-5/9 18) 10)
  )


-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] disappeeraing binding arrows

For me the arrows seem to work fine for both versions.
I tried it with racket version 6.1.1 and a racket snapshot build version 
6.2.0.3--2015-05-17.
Which arrows aren’t working for you?

On May 22, 2015, at 1:40 PM, Jos Koot jos.k...@gmail.com wrote:

 Below two versions of a very stripped version of a macro I have made.
 In version 1 background expansion and check-syntax show binding arrows within 
 macro stx-case.
 However, in version 2 the arrows are not shown.
 How come?
 Thanks, Jos
  
 #lang racket
  
 (require (for-syntax racket))
  
 ;;; version 1
  
 (begin-for-syntax
  (define-syntax (stx-case stx) ; Here background expansion and macro stepper
   (syntax-case stx ()  ; do show binding arrows in stx-case.
((_ stx-expr clause ...)
 (with-syntax
  ((+ (datum-syntax stx '+))
   (- (datum-syntax stx '-))
   (* (datum-syntax stx '*))
   (/ (datum-syntax stx '/)))
#'(syntax-case stx-expr (+ - * /) clause ...))
  
 (define-syntax (a stx)
  (stx-case stx
   ((_ +) #''plus)
   ((_ -) #''minus)
   ((_ *) #''mult)
   ((_ /) #''div)
   ((_ x) #''x)))
  
 ;;; version 2
  
 (define-syntax (b stx)
  (define-syntax (stx-case stx) ; Here background expansion and macro stepper
   (syntax-case stx ()  ; do NOT show binding arrows in stx-case.
((_ stx-expr clause ...)
 (with-syntax
  ((+ (datum-syntax stx '+))
   (- (datum-syntax stx '-))
   (* (datum-syntax stx '*))
   (/ (datum-syntax stx '/)))
#'(syntax-case stx-expr (+ - * /) clause ...)
  (stx-case stx
   ((_ +) #''plus)
   ((_ -) #''minus)
   ((_ *) #''mult)
   ((_ /) #''div)
   ((_ x) #''x)))
  
 ; Both a and b work correctly:
  
 (a +)
 (a else)
 (b -)
 (b else)
 
 -- 
 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.
 For more options, visit https://groups.google.com/d/optout.

-- 
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.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] disappeeraing binding arrows