suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New naming convention for generics names.

Browse Source
This commit is contained in:
Vincent St-Amour 2012-05-21 21:10:16 -04:00
parent f866e34b26
commit 3bfaa2b00b
14 changed files with 96 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
collects/data/order.rkt
View File

@ -10,13 +10,13 @@
(provide ordering/c)
(define-generics (ordered-dict prop:ordered-dict ordered-dict?)
(dict-iterate-least ordered-dict)
(dict-iterate-greatest ordered-dict)
(dict-iterate-least/>? ordered-dict key)
(dict-iterate-least/>=? ordered-dict key)
(dict-iterate-greatest/<? ordered-dict key)
(dict-iterate-greatest/<=? ordered-dict key))
(define-generics (gen:ordered-dict prop:ordered-dict ordered-dict?)
(dict-iterate-least gen:ordered-dict)
(dict-iterate-greatest gen:ordered-dict)
(dict-iterate-least/>? gen:ordered-dict key)
(dict-iterate-least/>=? gen:ordered-dict key)
(dict-iterate-greatest/<? gen:ordered-dict key)
(dict-iterate-greatest/<=? gen:ordered-dict key))
(define extreme-contract
(->i ([d ordered-dict?])
@ -40,7 +40,7 @@
;; --------
(provide ordered-dict)
(provide gen:ordered-dict)
(provide/contract
[prop:ordered-dict
(struct-type-property/c prop:ordered-dict-contract)]

4
collects/data/scribblings/order.scrbl
View File

@ -25,7 +25,7 @@ Contract for orderings, represented by the symbols @racket['=],
}
@deftogether[[
@defthing[ordered-dict any/c]
@defthing[gen:ordered-dict any/c]
@defthing[prop:ordered-dict
(struct-type-property/c
(vectorof _e/c _e/c _s/c _s/c _s/c _s/c))]
@ -33,7 +33,7 @@ Contract for orderings, represented by the symbols @racket['=],
Struct-type property for defining new ordered dictionary types.
Methods can be attached to the @racket[prop:ordered-dict] struct property
using the @racket[methods] form and the @racket[ordered-dict] generic
using the @racket[methods] form and the @racket[gen:ordered-dict] generic
interface. Two ``extrema'' methods and four ``search'' methods should be
implemented. The extrema methods must satisfy @racket[_e/c] and the search
methods must satisfy @racket[_s/c]:

6
collects/data/skip-list.rkt
View File

@ -357,7 +357,7 @@ Levels are indexed starting at 1, as in the paper.
(vector-immutable any/c any/c skip-list-iter?
#f #f #f))
#:property prop:ordered-dict
(methods ordered-dict
(methods gen:ordered-dict
(define dict-iterate-least skip-list-iterate-least)
(define dict-iterate-greatest skip-list-iterate-greatest)
(define dict-iterate-least/>? skip-list-iterate-least/>?)
@ -373,7 +373,7 @@ Levels are indexed starting at 1, as in the paper.
(lambda (s) (skip-list*-value-c s))
#f))
#:property prop:ordered-dict
(methods ordered-dict
(methods gen:ordered-dict
(define dict-iterate-least skip-list-iterate-least)
(define dict-iterate-greatest skip-list-iterate-greatest)
(define dict-iterate-least/>? skip-list-iterate-least/>?)
@ -395,7 +395,7 @@ Levels are indexed starting at 1, as in the paper.
(lambda (s) (adjustable-skip-list*-value-c s))
#f))
#:property prop:ordered-dict
(methods ordered-dict
(methods gen:ordered-dict
(define dict-iterate-least skip-list-iterate-least)
(define dict-iterate-greatest skip-list-iterate-greatest)
(define dict-iterate-least/>? skip-list-iterate-least/>?)

4
collects/data/splay-tree.rkt
View File

@ -523,7 +523,7 @@ Options
splay-tree-iter?
#f #f #f))
#:property prop:ordered-dict
(methods ordered-dict
(methods gen:ordered-dict
(define dict-iterate-least n:splay-tree-iterate-least)
(define dict-iterate-greatest n:splay-tree-iterate-greatest)
(define dict-iterate-least/>? n:splay-tree-iterate-least/>?)
@ -541,7 +541,7 @@ Options
(lambda (s) (node-splay-tree*-value-c s))
#f))
#:property prop:ordered-dict
(methods ordered-dict
(methods gen:ordered-dict
(define dict-iterate-least n:splay-tree-iterate-least)
(define dict-iterate-greatest n:splay-tree-iterate-greatest)
(define dict-iterate-least/>? n:splay-tree-iterate-least/>?)

2
collects/racket/dict.rkt
View File

@ -217,7 +217,7 @@
(->i ([d dict?])
[_r (d) (listof (cons/c (dict-key-contract d) (dict-value-contract d)))])])
(provide dict
(provide gen:dict
prop:dict
make-custom-hash

28
collects/racket/private/dict.rkt
View File

@ -3,20 +3,20 @@
(require racket/private/generics ; to avoid circular dependencies
(for-syntax racket/base))
(define-generics (dict prop:dict dict? #:defined-table dict-def-table
(define-generics (gen:dict prop:dict dict? #:defined-table dict-def-table
;; private version needs all kw args, in order
#:coerce-method-table #f
#:prop-defined-already? #f)
(dict-ref dict key [default])
(dict-set! dict key val)
(dict-set dict key val)
(dict-remove! dict key)
(dict-remove dict key)
(dict-count dict)
(dict-iterate-first dict)
(dict-iterate-next dict pos)
(dict-iterate-key dict pos)
(dict-iterate-value dict pos))
(dict-ref gen:dict key [default])
(dict-set! gen:dict key val)
(dict-set gen:dict key val)
(dict-remove! gen:dict key)
(dict-remove gen:dict key)
(dict-count gen:dict)
(dict-iterate-first gen:dict)
(dict-iterate-next gen:dict pos)
(dict-iterate-key gen:dict pos)
(dict-iterate-value gen:dict pos))
(define (assoc? v)
(and (list? v) (andmap pair? v)))
@ -428,7 +428,7 @@
(struct custom-hash (table make-box)
#:property prop:dict
(methods dict
(methods gen:dict
(define dict-ref custom-hash-ref)
(define dict-set! custom-hash-set!)
(define dict-remove! custom-hash-remove!)
@ -448,7 +448,7 @@
(struct immutable-custom-hash custom-hash ()
#:property prop:dict
(methods dict
(methods gen:dict
(define dict-ref custom-hash-ref)
(define dict-set custom-hash-set)
(define dict-remove custom-hash-remove)
@ -506,7 +506,7 @@
;; --------------------
(provide dict
(provide gen:dict
prop:dict
(rename-out
[d:dict? dict?]

16
collects/racket/stream.rkt
View File

@ -13,7 +13,7 @@
(provide empty-stream
stream-cons
stream?
generic-stream
gen:stream
;; we don't need the generics versions of these because
;; the original sequence functions will work fine
;; for the dispatch. (the method table layout is
@ -39,15 +39,15 @@
stream-add-between
stream-count)
(define-generics (generic-stream prop:stream stream?
#:defined-table defined-table
#:coerce-method-table #f
#:prop-defined-already? stream-get-generics)
(define-generics (gen:stream prop:stream stream?
#:defined-table defined-table
#:coerce-method-table #f
#:prop-defined-already? stream-get-generics)
;; These three are never used for the reasons explained above.
;; We still need the headers for clients who extend racket/stream.
(stream-empty? generic-stream)
(stream-first generic-stream)
(stream-rest generic-stream))
(stream-empty? gen:stream)
(stream-first gen:stream)
(stream-rest gen:stream))
(define-syntax stream
(syntax-rules ()

4
collects/scribblings/reference/dicts.scrbl
View File

@ -529,7 +529,7 @@ Returns a list of the associations from
]}
@deftogether[[
@defthing[dict any/c]
@defthing[gen:dict any/c]
@defthing[prop:dict struct-type-property?]]]{
A @tech{structure type property} (see @secref["structprops"]) that
@ -575,7 +575,7 @@ type. The following methods can be implemented:
@examples[#:eval dict-eval
(struct alist (v)
#:property prop:dict
(methods dict
(methods gen:dict
(define (dict-ref dict key
[default (lambda () (error "key not found" key))])
(cond [(assoc key (alist-v dict)) => cdr]

40
collects/scribblings/reference/generics.scrbl
View File

@ -9,7 +9,7 @@
@defmodule[racket/generics]
@defform/subs[(define-generics (name prop:name name?
@defform/subs[(define-generics (gen:name prop:name name?
[#:defined-table defined-table])
[method . kw-formals*]
...)
@ -21,12 +21,12 @@
(code:line keyword id)
(code:line keyword [id])])
#:contracts
([name identifier?]
([gen:name identifier?]
[prop:name identifier?]
[name? identifier?]
[method identifier?])]{
Defines @racket[name] as a transformer binding for the static
Defines @racket[gen:name] as a transformer binding for the static
information about a new generic group.
Defines @racket[prop:name] as a structure type property. Structure
@ -44,7 +44,7 @@ types that implement this generic group.
Defines each @racket[method] as a generic procedure that calls the
corresponding method on values where @racket[name?] is true. Each method
must have a required by-position argument that is
@racket[free-identifier=?] to @racket[name]. This argument is used in
@racket[free-identifier=?] to @racket[gen:name]. This argument is used in
the generic definition to locate the specialization.
The optional @racket[defined-table] argument should be an identifier.
@ -57,38 +57,38 @@ availability.
}
@defform[(generics name
@defform[(generics gen:name
[method . kw-formals*]
...)
#:contracts
([name identifier?]
([gen:name identifier?]
[method identifier?])]{
Expands to
@racketblock[(define-generics (name _prop:name _name?)
@racketblock[(define-generics (gen:name _prop:name _name?)
[method . kw-formals*]
...)]
where @racket[_prop:name] and @racket[_name?] are created with the lexical
context of @racket[name].
context of @racket[gen:name].
}
@defform[(methods name definition ...)
@defform[(methods gen:name definition ...)
#:contracts
([name identifier?])]{
([gen:name identifier?])]{
@racket[name] must be a transformer binding for the static information
@racket[gen:name] must be a transformer binding for the static information
about a new generic group.
Expands to a value usable as the property value for the structure type
property of the @racket[name] generic group.
property of the @racket[gen:name] generic group.
If the @racket[definition]s define the methods of @racket[name], then
If the @racket[definition]s define the methods of @racket[gen:name], then
they are used in the property value.
If any method of @racket[name] is not defined, then @racket[#f] is used
If any method of @racket[gen:name] is not defined, then @racket[#f] is used
to signify that the structure type does not implement the particular
method.
@ -120,14 +120,14 @@ Syntactically an error when used outside @racket[methods].
@(define evaluator (new-evaluator))
@examples[#:eval evaluator
(define-generics (printable prop:printable printable?)
(gen-print printable [port])
(gen-port-print port printable)
(gen-print* printable [port] #:width width #:height [height]))
(define-generics (gen:printable prop:printable printable?)
(gen-print gen:printable [port])
(gen-port-print port gen:printable)
(gen-print* gen:printable [port] #:width width #:height [height]))
(define-struct num (v)
#:property prop:printable
(methods printable
(methods gen:printable
(define/generic super-print gen-print)
(define (gen-print n [port (current-output-port)])
(fprintf port "Num: ~a" (num-v n)))
@ -139,7 +139,7 @@ Syntactically an error when used outside @racket[methods].
(define-struct bool (v)
#:property prop:printable
(methods printable
(methods gen:printable
(define/generic super-print gen-print)
(define (gen-print b [port (current-output-port)])
(fprintf port "Bool: ~a"

20
collects/scribblings/reference/sequences.scrbl
View File

@ -73,7 +73,7 @@ except that @racket[_k] by itself is not a @tech{stream}.
Custom sequences can be defined using structure type properties.
The easiest method to define a custom sequence is to use the
@racket[prop:stream] property and the @racket[generic-stream]
@racket[prop:stream] property and the @racket[gen:stream]
extension interface. Streams are a suitable abstraction for data
structures that are directly iterable. For example, a list is directly
iterable with @racket[first] and @racket[rest]. On the other hand,
@ -89,7 +89,7 @@ that can be represented as streams:
@examples[#:eval stream-evaluator
(struct unrolled-list-iterator (idx lst)
#:property prop:stream
(methods generic-stream
(methods gen:stream
(define (stream-empty? iter)
(define lst (unrolled-list-iterator-lst iter))
(or (null? lst)
@ -776,7 +776,7 @@ A shorthand for nested @racket[stream-cons]es ending with
The new stream is constructed lazily.}
@deftogether[[
@defthing[generic-stream any/c]
@defthing[gen:stream any/c]
@defthing[prop:stream struct-type-property?]]]{
Associates three procedures to a structure type to implement stream
@ -795,13 +795,13 @@ A shorthand for nested @racket[stream-cons]es ending with
@examples[#:eval stream-evaluator
(define-struct list-stream (v)
#:property prop:stream
(methods generic-stream
(define (stream-empty? generic-stream)
(empty? (list-stream-v generic-stream)))
(define (stream-first generic-stream)
(first (list-stream-v generic-stream)))
(define (stream-rest generic-stream)
(rest (list-stream-v generic-stream)))))
(methods gen:stream
(define (stream-empty? stream)
(empty? (list-stream-v stream)))
(define (stream-first stream)
(first (list-stream-v stream)))
(define (stream-rest stream)
(rest (list-stream-v stream)))))
(define l1 (list-stream '(1 2)))
(stream? l1)

2
collects/tests/generics/alist.rkt
View File

@ -4,7 +4,7 @@
(define-struct alist (v)
#:property prop:dict
(methods dict
(methods gen:dict
(define (dict-ref dict key
[default (lambda () (error "key not found" key))])
(cond [(assoc key (alist-v dict)) => cdr]

4
collects/tests/generics/custom-hash.rkt
View File

@ -2,7 +2,7 @@
(require racket/generics
(only-in racket/dict
dict prop:dict
gen:dict prop:dict
dict?
dict-ref
dict-set!
@ -42,7 +42,7 @@
(struct custom-hash (table make-box)
#:property prop:dict
(methods dict
(methods gen:dict
(define dict-ref custom-hash-ref)
(define dict-set! custom-hash-set!)
(define (dict-set dict key val)

21
collects/tests/generics/equal+hash.rkt Normal file
View File

@ -0,0 +1,21 @@
#lang racket
;; vectors as method tables
(struct kons (kar kdr)
#:property prop:equal+hash
(vector 'ta
(lambda (x y rec)
(and (rec (kons-kar x) (kons-kar y))
(rec (kons-kdr x) (kons-kdr y))))
(lambda (x y) 12)
(lambda (x y) 13)))
(module+ test
(require rackunit)
(check-equal? (kons 1 2) (kons 1 2))
(check-false (equal? (kons 1 2) 2))
(check-false (equal? 2 (kons 1 2)))
(check-false (equal? (kons 1 2) (kons 3 4)))
(check-equal? (equal-hash-code (kons 1 2)) 60)
)

4
collects/tests/generics/stream.rkt
View File

@ -4,7 +4,7 @@
(define-struct list-stream (v)
#:property prop:stream
(methods generic-stream
(methods gen:stream
(define (stream-empty? generic-stream)
(empty? (list-stream-v generic-stream)))
(define (stream-first generic-stream)
@ -14,7 +14,7 @@
(struct vector-stream (i v)
#:property prop:stream
(methods generic-stream
(methods gen:stream
(define (stream-first x) (vector-ref (vector-stream-v x)
(vector-stream-i x)))
(define (stream-rest x) (vector-stream (add1 (vector-stream-i x))