From 8c1723e87a5466a185af9e3c9216783d335410fc Mon Sep 17 00:00:00 2001 From: Matthew Butterick Date: Thu, 29 Oct 2015 19:34:11 -0700 Subject: [PATCH] remove typed/txexpr --- README.md | 6 +- info.rkt | 10 +- typed/txexpr/main.rkt => main.rkt | 236 +++++++++++------- .../scribblings => scribblings}/txexpr.scrbl | 12 +- txexpr/tests.rkt => tests.rkt | 19 +- txexpr/core-predicates.rkt | 69 ----- txexpr/info.rkt | 3 - txexpr/main.rkt | 43 ---- typed/txexpr.rkt | 4 - typed/txexpr/core-predicates.rkt | 76 ------ 10 files changed, 162 insertions(+), 316 deletions(-) rename typed/txexpr/main.rkt => main.rkt (52%) rename {txexpr/scribblings => scribblings}/txexpr.scrbl (94%) rename txexpr/tests.rkt => tests.rkt (93%) delete mode 100644 txexpr/core-predicates.rkt delete mode 100644 txexpr/info.rkt delete mode 100644 txexpr/main.rkt delete mode 100644 typed/txexpr.rkt delete mode 100644 typed/txexpr/core-predicates.rkt diff --git a/README.md b/README.md index 3e87f3d..cfe35e8 100644 --- a/README.md +++ b/README.md @@ -15,8 +15,4 @@ In safe mode (with contracts): (require (submod txexpr safe)) -Or in typed mode: - - (require typed/txexpr) - -Full docs are installed with the package. You can also [read the docs here](http://pkg-build.racket-lang.org/doc/txexpr). +Full docs are installed with the package. You can also [read the docs here](http://pkg-build.racket-lang.org/doc/txexpr). \ No newline at end of file diff --git a/info.rkt b/info.rkt index 7be6e0a..0b89049 100644 --- a/info.rkt +++ b/info.rkt @@ -1,7 +1,7 @@ #lang info -(define collection 'multi) -(define deps '("base" "sugar" "typed-racket-lib" - "typed-racket-more" - "rackunit-lib")) +(define collection "txexpr") +(define deps '("base" "sugar" "rackunit-lib")) (define update-implies '("sugar")) -(define build-deps '("scribble-lib" "racket-doc" "typed-racket-doc")) \ No newline at end of file +(define build-deps '("scribble-lib" "racket-doc")) +(define scribblings '(("scribblings/txexpr.scrbl" ()))) +(define compile-omit-paths '("tests.rkt")) \ No newline at end of file diff --git a/typed/txexpr/main.rkt b/main.rkt similarity index 52% rename from typed/txexpr/main.rkt rename to main.rkt index 5045f96..202518b 100644 --- a/typed/txexpr/main.rkt +++ b/main.rkt @@ -1,12 +1,90 @@ -#lang typed/racket/base -(require (for-syntax typed/racket/base) typed/sugar/define) -(require racket/match racket/string racket/list racket/bool "core-predicates.rkt") -(provide (all-defined-out) (all-from-out "core-predicates.rkt")) - -(define/typed (validate-txexpr-attrs x #:context [txexpr-context #f]) - (Txexpr-Attrs [#:context Any] -> Txexpr-Attrs) - (define/typed (make-reason) - (-> String) +#lang racket/base +(require sugar/define racket/string racket/list racket/match xml) +(provide cdata? cdata valid-char? xexpr->string xexpr?) ; from xml + +;; Section 2.2 of XML 1.1 +;; (XML 1.0 is slightly different and more restrictive) +;; make private version of my-valid-char to get consistent results with Racket 6.0 +(define (my-valid-char? i) + (and (exact-nonnegative-integer? i) + (or (<= #x1 i #xD7FF) + (<= #xE000 i #xFFFD) + (<= #x10000 i #x10FFFF)))) + +(define (my-xexpr? x) + (or (txexpr? x) (xexpr? x) (my-valid-char? x))) + +(define+provide+safe (txexpr-short? x) + predicate/c + (match x + [(list (? symbol? name) (? my-xexpr?) ...) #t] + [else #f])) + +(define+provide+safe (txexpr? x) + predicate/c + (or (txexpr-short? x) + (match x + [(list (? symbol?) (list (list (? symbol?) (? string?)) ...) (? my-xexpr?) ...) #t] + [else #f]))) + +(define+provide+safe (txexpr-tag? x) + predicate/c + (symbol? x)) + +(define+provide+safe (txexpr-tags? x) + predicate/c + (and (list? x) (andmap txexpr-tag? x))) + +(define+provide+safe (txexpr-attr? x) + predicate/c + (match x + [(list (? symbol?) (? string?)) #t] + [else #f])) + + +(define+provide+safe (txexpr-attrs? x) + predicate/c + (and (list? x) (andmap txexpr-attr? x))) + +(define+provide+safe (txexpr-element? x) + predicate/c + (my-xexpr? x)) + +(define+provide+safe (txexpr-elements? x) + predicate/c + (and (list? x) (andmap txexpr-element? x))) + +(define+provide+safe (txexpr-attr-key? x) + predicate/c + (symbol? x)) + +(define+provide+safe (can-be-txexpr-attr-key? x) + predicate/c + (or (symbol? x) (string? x))) + +(define+provide+safe (txexpr-attr-value? x) + predicate/c + (string? x)) + +(define+provide+safe (txexpr-attr-values? x) + predicate/c + (and (list? x) (andmap txexpr-attr-value? x))) + +(define+provide+safe (can-be-txexpr-attr-value? x) + predicate/c + (or (symbol? x) (string? x))) + +(define+provide+safe (can-be-txexpr-attrs? x) + predicate/c + (ormap (λ(test) (test x)) (list txexpr-attr? txexpr-attrs? can-be-txexpr-attr-key? can-be-txexpr-attr-value?))) + +(define+provide+safe (list-of-can-be-txexpr-attrs? xs) + predicate/c + (and (list? xs) (andmap can-be-txexpr-attrs? xs))) + + +(define (validate-txexpr-attrs x #:context [txexpr-context #f]) + (define (make-reason) (if (not (list? x)) (format "because ~v is not a list" x) (let ([bad-attrs (filter (λ(i) (not (txexpr-attr? i))) x)]) @@ -20,8 +98,7 @@ (format "~v is not a valid list of attributes ~a" x (make-reason))))])) -(define/typed (validate-txexpr-element x #:context [txexpr-context #f]) - (Txexpr-Element [#:context Any] -> Txexpr-Element) +(define (validate-txexpr-element x #:context [txexpr-context #f]) (cond [(or (string? x) (txexpr? x) (symbol? x) (valid-char? x) (cdata? x)) x] @@ -32,22 +109,20 @@ ;; is it a named x-expression? ;; todo: rewrite this recurively so errors can be pinpointed (for debugging) -(define/typed (validate-txexpr x) - (Any -> (Option Txexpr)) +(define+provide+safe (validate-txexpr x) + (any/c . -> . txexpr?) (define-syntax-rule (validate-txexpr-attrs-with-context e) (validate-txexpr-attrs e #:context x)) (define-syntax-rule (validate-txexpr-element-with-context e) (validate-txexpr-element e #:context x)) (cond [(txexpr-short? x) x] [(txexpr? x) (and (validate-txexpr-attrs-with-context (get-attrs x)) - (andmap (λ:([e : Txexpr-Element]) (validate-txexpr-element-with-context e)) (get-elements x)) x)] + (andmap (λ(e) (validate-txexpr-element-with-context e)) (get-elements x)) x)] [else (error 'validate-txexpr (format "~v is not a list starting with a symbol" x))])) -(define/typed (make-txexpr tag [attrs null] [elements null]) - (case-> (Symbol -> Txexpr) - (Symbol Txexpr-Attrs -> Txexpr) - (Symbol Txexpr-Attrs (Listof Txexpr-Element) -> Txexpr)) +(define+provide+safe (make-txexpr tag [attrs null] [elements null]) + ((symbol?) (txexpr-attrs? txexpr-elements?) . ->* . txexpr?) (define result (cons tag (append (if (empty? attrs) empty (list attrs)) elements))) (if (txexpr? result) result @@ -62,66 +137,63 @@ [else ""])))) -(define/typed (txexpr->values x) - (Txexpr -> (values Txexpr-Tag Txexpr-Attrs Txexpr-Elements)) +(define+provide+safe (txexpr->values x) + (txexpr? . -> . (values symbol? txexpr-attrs? txexpr-elements?)) (if (txexpr-short? x) (values (car x) '() (cdr x)) (values (car x) (cadr x) (cddr x)))) -(define/typed (txexpr->list x) - (Txexpr -> (List Txexpr-Tag Txexpr-Attrs Txexpr-Elements)) +(define+provide+safe (txexpr->list x) + (txexpr? . -> . list?) (define-values (tag attrs content) (txexpr->values x)) (list tag attrs content)) ;; convenience functions to retrieve only one part of txexpr -(define/typed (get-tag x) - (Txexpr -> Txexpr-Tag) +(define+provide+safe (get-tag x) + (txexpr? . -> . txexpr-tag?) (car x)) -(define/typed (get-attrs x) - (Txexpr -> Txexpr-Attrs) +(define+provide+safe (get-attrs x) + (txexpr? . -> . txexpr-attrs?) (define-values (tag attrs content) (txexpr->values x)) attrs) -(define/typed (get-elements x) - (Txexpr -> Txexpr-Elements) +(define+provide+safe (get-elements x) + (txexpr? . -> . txexpr-elements?) (define-values (tag attrs elements) (txexpr->values x)) elements) ;; helpers. we are getting a string or symbol -(define/typed (->txexpr-attr-key x) - (Can-Be-Txexpr-Attr-Key -> Txexpr-Attr-Key) +(define+provide+safe (->txexpr-attr-key x) + (can-be-txexpr-attr-key? . -> . txexpr-attr-key?) (if (string? x) (string->symbol x) x)) -(define/typed (->txexpr-attr-value x) - (Can-Be-Txexpr-Attr-Value -> Txexpr-Attr-Value) +(define+provide+safe (->txexpr-attr-value x) + (can-be-txexpr-attr-value? . -> . txexpr-attr-value?) (->string x)) -(define/typed (->string x) - ((U Symbol String) -> String) +(define (->string x) (if (symbol? x) (symbol->string x) x)) -(define/typed (attrs->hash . items-in) - (Can-Be-Txexpr-Attr * -> Txexpr-Attr-Hash) +(define+provide+safe (attrs->hash . items-in) + (() #:rest (listof can-be-txexpr-attrs?) . ->* . hash?) ;; can be liberal with input because they're all just nested key/value pairs ;; but still need this function to make sure that 'foo and "foo" are treated as the same hash key (define items (reverse - (for/fold: ([items : (Listof (U Can-Be-Txexpr-Attr-Key Can-Be-Txexpr-Attr-Value)) null]) - ([i (in-list items-in)]) + (for/fold ([items null]) ([i (in-list items-in)]) (cond [(txexpr-attr? i) (append (reverse i) items)] - [(txexpr-attrs? i) (append (append* (map (λ:([a : Txexpr-Attr]) (reverse a)) i)) items)] + [(txexpr-attrs? i) (append (append* (map (λ(a) (reverse a)) i)) items)] [else (cons i items)])))) - (define/typed (make-key-value-list items) - ((Listof (U Can-Be-Txexpr-Attr-Key Can-Be-Txexpr-Attr-Value)) -> (Listof (Pairof Txexpr-Attr-Key Txexpr-Attr-Value))) + (define (make-key-value-list items) (if (< (length items) 2) null (let ([key (->txexpr-attr-key (car items))] @@ -131,62 +203,62 @@ (make-immutable-hash (make-key-value-list items))) -(define/typed (hash->attrs attr-hash) - (Txexpr-Attr-Hash -> Txexpr-Attrs) - (map (λ:([k : Txexpr-Attr-Key]) (list k (hash-ref attr-hash k))) (hash-keys attr-hash))) +(define+provide+safe (hash->attrs attr-hash) + (hash? . -> . txexpr-attrs?) + (map (λ(k) (list k (hash-ref attr-hash k))) (hash-keys attr-hash))) -(define/typed (attrs-have-key? x key) - ((U Txexpr-Attrs Txexpr) Can-Be-Txexpr-Attr-Key -> Boolean) +(define+provide+safe (attrs-have-key? x key) + ((or/c txexpr-attrs? txexpr?) can-be-txexpr-attr-key? . -> . boolean?) (define attrs (if (txexpr-attrs? x) x (get-attrs x))) (hash-has-key? (attrs->hash attrs) (->txexpr-attr-key key))) -(define/typed (attrs-equal? x1 x2) - ((U Txexpr-Attrs Txexpr) (U Txexpr-Attrs Txexpr) -> Boolean) +(define+provide+safe (attrs-equal? x1 x2) + ((or/c txexpr-attrs? txexpr?) (or/c txexpr-attrs? txexpr?) . -> . boolean?) (define attrs-tx1 (attrs->hash (if (txexpr-attrs? x1) x1 (get-attrs x1)))) (define attrs-tx2 (attrs->hash (if (txexpr-attrs? x2) x2 (get-attrs x2)))) (and (= (length (hash-keys attrs-tx1)) (length (hash-keys attrs-tx2))) (for/and ([(key value) (in-hash attrs-tx1)]) - (equal? (hash-ref attrs-tx2 key) value)))) + (equal? (hash-ref attrs-tx2 key) value)))) -(define/typed (attr-set tx key value) - (Txexpr Can-Be-Txexpr-Attr-Key Can-Be-Txexpr-Attr-Value -> Txexpr) +(define+provide+safe (attr-set tx key value) + (txexpr? can-be-txexpr-attr-key? can-be-txexpr-attr-value? . -> . txexpr?) (define new-attrs (hash->attrs (hash-set (attrs->hash (get-attrs tx)) (->txexpr-attr-key key) (->txexpr-attr-value value)))) (make-txexpr (get-tag tx) new-attrs (get-elements tx))) -(define/typed (attr-ref tx key) - (Txexpr Can-Be-Txexpr-Attr-Key -> Txexpr-Attr-Value) +(define+provide+safe (attr-ref tx key) + (txexpr? can-be-txexpr-attr-key? . -> . txexpr-attr-value?) (with-handlers ([exn:fail? (λ(e) (error (format "attr-ref: no value found for key ~v" key)))]) (hash-ref (attrs->hash (get-attrs tx)) (->txexpr-attr-key key)))) -(define/typed (attr-ref* tx key) - (Txexpr Can-Be-Txexpr-Attr-Key -> (Listof Txexpr-Attr-Value)) - (define: results : (Listof Txexpr-Attr-Value) empty) - (let: loop : Void ([tx : Xexpr tx]) +(define+provide+safe (attr-ref* tx key) + (txexpr? can-be-txexpr-attr-key? . -> . txexpr-attr-values?) + (define results empty) + (let loop ([tx tx]) (when (and (txexpr? tx) (attrs-have-key? tx key) (attr-ref tx key)) (set! results (cons (attr-ref tx key) results)) - (map (λ:([e : Txexpr-Element]) (loop e)) (get-elements tx)) + (map (λ(e) (loop e)) (get-elements tx)) (void))) (reverse results)) ;; convert list of alternating keys & values to attr -(define/typed (merge-attrs . items) - (Can-Be-Txexpr-Attr * -> Txexpr-Attrs) +(define+provide+safe (merge-attrs . items) + (() #:rest list-of-can-be-txexpr-attrs? . ->* . txexpr-attrs?) (define attrs-hash (apply attrs->hash items)) ;; sort needed for predictable results for unit tests - (define sorted-hash-keys (sort (hash-keys attrs-hash) (λ:([a : Txexpr-Tag][b : Txexpr-Tag]) (stringstring a) (->string b))))) - `(,@(map (λ:([key : Txexpr-Tag]) (list key (hash-ref attrs-hash key))) sorted-hash-keys))) + (define sorted-hash-keys (sort (hash-keys attrs-hash) (λ(a b) (stringstring a) (->string b))))) + `(,@(map (λ(key) (list key (hash-ref attrs-hash key))) sorted-hash-keys))) -(define/typed (remove-attrs x) - (Xexpr -> Xexpr) +(define+provide+safe (remove-attrs x) + (txexpr? . -> . txexpr?) (if (txexpr? x) (let-values ([(tag attr elements) (txexpr->values x)]) (make-txexpr tag null (map remove-attrs elements))) @@ -194,58 +266,54 @@ -(define/typed (map-elements/exclude proc x exclude-test) - ((Xexpr -> Xexpr) Xexpr (Xexpr -> Boolean) -> Xexpr) +(define+provide+safe (map-elements/exclude proc x exclude-test) + (procedure? txexpr? procedure? . -> . txexpr?) (cond [(txexpr? x) (if (exclude-test x) x (let-values ([(tag attr elements) (txexpr->values x)]) (make-txexpr tag attr - (map (λ:([x : Xexpr])(map-elements/exclude proc x exclude-test)) elements))))] + (map (λ(x)(map-elements/exclude proc x exclude-test)) elements))))] ;; externally the function only accepts txexpr, ;; but internally we don't care [else (proc x)])) -(define/typed (map-elements proc x) - ((Xexpr -> Xexpr) Xexpr -> Xexpr) +(define+provide+safe (map-elements proc x) + (procedure? txexpr? . -> . txexpr?) (map-elements/exclude proc x (λ(x) #f))) ;; function to split tag out of txexpr (define deleted-signal (gensym)) -(define/typed (splitf-txexpr tx pred [proc (λ:([x : Xexpr]) deleted-signal)]) - (case-> (Txexpr (Xexpr -> Boolean) -> (values Txexpr Txexpr-Elements)) - (Txexpr (Xexpr -> Boolean) (Xexpr -> Xexpr) -> (values Txexpr Txexpr-Elements))) - (define: matches : Txexpr-Elements null) - (define/typed (do-extraction x) - (Xexpr -> Xexpr) +(define+provide+safe (splitf-txexpr tx pred [proc (λ(x) deleted-signal)]) + ((txexpr? procedure?) (procedure?) . ->* . (values txexpr? txexpr-elements?)) + (define matches null) + (define (do-extraction x) (cond [(pred x) (begin ; store matched item and return processed value (set! matches (cons x matches)) (proc x))] [(txexpr? x) (let-values([(tag attr elements) (txexpr->values x)]) - (make-txexpr tag attr (filter (λ:([e : Xexpr]) (not (equal? e deleted-signal))) (map do-extraction elements))))] + (make-txexpr tag attr (filter (λ(e) (not (equal? e deleted-signal))) (map do-extraction elements))))] [else x])) - (define: tx-extracted : Xexpr (do-extraction tx)) ;; do this first to fill matches + (define tx-extracted (do-extraction tx)) ;; do this first to fill matches (values (if (txexpr? tx-extracted) tx-extracted (error 'splitf-txexpr "Bad input")) (reverse matches))) -(define/typed (xexpr->html x) - (Xexpr -> String) - (define/typed (->cdata x) - (Xexpr -> Xexpr) +(define+provide+safe (xexpr->html x) + (xexpr? . -> . string?) + (define (->cdata x) (cond [(cdata? x) x] [(string? x) (cdata #f #f x)] ; don't use "![CDATA[...]]" wrapper in HTML, it's not consistent with the spec [else x])) - (xexpr->string (let: loop : Xexpr ([x : Xexpr x]) + (xexpr->string (let loop ([x x]) (cond [(txexpr? x) (if (member (get-tag x) '(script style)) (make-txexpr (get-tag x) (get-attrs x) (map ->cdata (get-elements x))) (make-txexpr (get-tag x) (get-attrs x) (map loop (get-elements x))))] - [else x])))) - + [else x])))) \ No newline at end of file diff --git a/txexpr/scribblings/txexpr.scrbl b/scribblings/txexpr.scrbl similarity index 94% rename from txexpr/scribblings/txexpr.scrbl rename to scribblings/txexpr.scrbl index 61cf594..f6ee679 100644 --- a/txexpr/scribblings/txexpr.scrbl +++ b/scribblings/txexpr.scrbl @@ -3,7 +3,7 @@ @; for documentation purposes, use the xexpr? from xml. @; the one in txexpr is just to patch over an issue with @; `valid-char?` in Racket 6. -@(require scribble/eval (for-label racket txexpr xml (only-in typed/racket require/typed))) +@(require scribble/eval (for-label racket txexpr xml)) @(define my-eval (make-base-eval)) @(my-eval `(require txexpr xml)) @@ -13,12 +13,10 @@ @author[(author+email "Matthew Butterick" "mb@mbtype.com")] -@defmodule[#:multi (txexpr (submod txexpr safe) typed/txexpr)] +@defmodule[#:multi (txexpr (submod txexpr safe))] A set of small but handy functions for improving the readability and reliability of programs that operate on tagged X-expressions (for short, @italic{txexpr}s). -I thank Alexis King for helpful suggestions on the typed version. - @section{Installation} @@ -30,16 +28,12 @@ After that, you can update the package from the command line: @section{Importing the module} -The module can be invoked three ways: fast, safe, and typed. +The module can be invoked two ways: fast or safe. Fast mode is the default, which you get by importing the module in the usual way: @code{(require txexpr)}. Safe mode enables the function contracts documented below. Use safe mode by importing the module as @code{(require (submod txexpr safe))}. -The typed version is invoked as @code{(require typed/txexpr)}. The typed version is implemented ``natively'' in the sense that it is compiled separately with type annotations. It is not a @racket[require/typed] wrapper around the untyped code. This avoids the contract barrier that is otherwise automatically imposed between typed and untyped code. - -@margin-note{I explain more about this cross-compiling technique in @link["http://unitscale.com/mb/technique/dual-typed-untyped-library.html"]{Making a dual typed / untyped Racket library}.} - @section{What’s a txexpr?} diff --git a/txexpr/tests.rkt b/tests.rkt similarity index 93% rename from txexpr/tests.rkt rename to tests.rkt index a2502c8..8bc9b46 100644 --- a/txexpr/tests.rkt +++ b/tests.rkt @@ -16,24 +16,7 @@ ,@(syntax->datum #'(exprs ...))) (require ',(syntax->datum #'sym2))) stx))])) - -(define-syntax (eval-as-typed stx) - (syntax-case stx () - [(_ exprs ...) - (with-syntax ([sym (syntax-e (generate-temporary))]) - (datum->syntax stx `(begin - (module ,(syntax->datum #'sym) typed/racket - (require typed/rackunit "../typed/txexpr.rkt") - ,@(syntax->datum #'(exprs ...))) - (require ',(syntax->datum #'sym))) stx))])) - -(define-syntax-rule (eval-as-typed-and-untyped exprs ...) - (begin - (eval-as-typed exprs ...) - (eval-as-untyped exprs ...))) - - -(eval-as-typed-and-untyped +(eval-as-untyped (require racket/set) (define-syntax (values->list stx) (syntax-case stx () diff --git a/txexpr/core-predicates.rkt b/txexpr/core-predicates.rkt deleted file mode 100644 index f13b10f..0000000 --- a/txexpr/core-predicates.rkt +++ /dev/null @@ -1,69 +0,0 @@ -#lang racket/base -(require sugar/define xml racket/match) -(provide (all-defined-out) cdata? cdata valid-char? xexpr->string xexpr?) - -;; Section 2.2 of XML 1.1 -;; (XML 1.0 is slightly different and more restrictive) -;; make private version of my-valid-char to get consistent results with 6.0 -(define (my-valid-char? i) - (and (exact-nonnegative-integer? i) - (or (<= #x1 i #xD7FF) - (<= #xE000 i #xFFFD) - (<= #x10000 i #x10FFFF)))) - -(define (my-xexpr? x) - (or (txexpr? x) (xexpr? x) (my-valid-char? x))) - -(define (txexpr-short? x) - (match x - [(list (? symbol? name) (? my-xexpr?) ...) #t] - [else #f])) - -(define (txexpr? x) - (or (txexpr-short? x) - (match x - [(list (? symbol?) (list (list (? symbol?) (? string?)) ...) (? my-xexpr?) ...) #t] - [else #f]))) - -(define (txexpr-tag? x) - (symbol? x)) - -(define (txexpr-tags? x) - (and (list? x) (andmap txexpr-tag? x))) - -(define (txexpr-attr? x) - (match x - [(list (? symbol?) (? string?)) #t] - [else #f])) - - -(define (txexpr-attrs? x) - (and (list? x) (andmap txexpr-attr? x))) - -(define (txexpr-element? x) - (my-xexpr? x)) - -(define (txexpr-elements? x) - (and (list? x) (andmap txexpr-element? x))) - -(define (txexpr-attr-key? x) - (symbol? x)) - -(define (can-be-txexpr-attr-key? x) - (or (symbol? x) (string? x))) - -(define (txexpr-attr-value? x) - (string? x)) - -(define (txexpr-attr-values? x) - (and (list? x) (andmap txexpr-attr-value? x))) - -(define (can-be-txexpr-attr-value? x) - (or (symbol? x) (string? x))) - -(define (can-be-txexpr-attrs? x) - (ormap (λ(test) (test x)) (list txexpr-attr? txexpr-attrs? can-be-txexpr-attr-key? can-be-txexpr-attr-value?))) - -(define (list-of-can-be-txexpr-attrs? xs) - (and (list? xs) (andmap can-be-txexpr-attrs? xs))) - diff --git a/txexpr/info.rkt b/txexpr/info.rkt deleted file mode 100644 index add507f..0000000 --- a/txexpr/info.rkt +++ /dev/null @@ -1,3 +0,0 @@ -#lang info -(define scribblings '(("scribblings/txexpr.scrbl" ()))) -(define compile-omit-paths '("tests.rkt")) \ No newline at end of file diff --git a/txexpr/main.rkt b/txexpr/main.rkt deleted file mode 100644 index 4961fe0..0000000 --- a/txexpr/main.rkt +++ /dev/null @@ -1,43 +0,0 @@ -#lang racket/base -(require sugar/define) - -(require-via-wormhole "../typed/txexpr/main.rkt") - -(provide+safe - [xexpr? predicate/c] - [txexpr? predicate/c] - [txexpr-short? predicate/c] - [txexpr-tag? predicate/c] - [txexpr-tags? predicate/c] - [txexpr-attr? predicate/c] - [txexpr-attrs? predicate/c] - [txexpr-element? predicate/c] - [txexpr-elements? predicate/c] - [validate-txexpr (any/c . -> . txexpr?)] - [make-txexpr ((symbol?) (txexpr-attrs? txexpr-elements?) . ->* . txexpr?)] - [txexpr->values (txexpr? . -> . (values symbol? txexpr-attrs? txexpr-elements?))] - [txexpr->list (txexpr? . -> . list?)] - [get-tag (txexpr? . -> . txexpr-tag?)] - [get-attrs (txexpr? . -> . txexpr-attrs?)] - [get-elements (txexpr? . -> . txexpr-elements?)] - [txexpr-attr-key? predicate/c] - [txexpr-attr-value? predicate/c] - [can-be-txexpr-attr-key? predicate/c] - [can-be-txexpr-attr-value? predicate/c] - [->txexpr-attr-key (can-be-txexpr-attr-key? . -> . txexpr-attr-key?)] - [->txexpr-attr-value (can-be-txexpr-attr-value? . -> . txexpr-attr-value?)] - [can-be-txexpr-attrs? predicate/c] - [list-of-can-be-txexpr-attrs? predicate/c] - [attrs->hash (() #:rest (listof can-be-txexpr-attrs?) . ->* . hash?)] - [hash->attrs (hash? . -> . txexpr-attrs?)] - [attr-ref (txexpr? can-be-txexpr-attr-key? . -> . txexpr-attr-value?)] - [attr-ref* (txexpr? can-be-txexpr-attr-key? . -> . txexpr-attr-values?)] - [attrs-have-key? ((or/c txexpr-attrs? txexpr?) can-be-txexpr-attr-key? . -> . boolean?)] - [attrs-equal? ((or/c txexpr-attrs? txexpr?) (or/c txexpr-attrs? txexpr?) . -> . boolean?)] - [attr-set (txexpr? can-be-txexpr-attr-key? can-be-txexpr-attr-value? . -> . txexpr?)] - [merge-attrs (() #:rest list-of-can-be-txexpr-attrs? . ->* . txexpr-attrs?)] - [remove-attrs (txexpr? . -> . txexpr?)] - [map-elements/exclude (procedure? txexpr? procedure? . -> . txexpr?)] - [map-elements (procedure? txexpr? . -> . txexpr?)] - [splitf-txexpr ((txexpr? procedure?) (procedure?) . ->* . (values txexpr? txexpr-elements?))] - [xexpr->html (xexpr? . -> . string?)]) \ No newline at end of file diff --git a/typed/txexpr.rkt b/typed/txexpr.rkt deleted file mode 100644 index f731208..0000000 --- a/typed/txexpr.rkt +++ /dev/null @@ -1,4 +0,0 @@ -#lang typed/racket/base - -(require "txexpr/main.rkt") -(provide (all-from-out "txexpr/main.rkt")) \ No newline at end of file diff --git a/typed/txexpr/core-predicates.rkt b/typed/txexpr/core-predicates.rkt deleted file mode 100644 index b9ebca2..0000000 --- a/typed/txexpr/core-predicates.rkt +++ /dev/null @@ -1,76 +0,0 @@ -#lang typed/racket/base -(require (for-syntax racket/base) racket/match typed/sugar/define) -(provide (all-defined-out)) - -; Section 2.2 of XML 1.1 -; (XML 1.0 is slightly different and more restrictive) -(define/typed (valid-char? i) - (Any -> Boolean) - (and (exact-nonnegative-integer? i) - (or (<= #x1 i #xD7FF) - (<= #xE000 i #xFFFD) - (<= #x10000 i #x10FFFF)))) - -(require/typed - xml - [#:struct location ([line : (Option Natural)] - [char : (Option Natural)] - [offset : Natural])] - [#:struct source ([start : (U location Symbol #f)] - [stop : (U location Symbol #f)])] - [#:struct (cdata source) ([string : String])] - [#:struct comment ([text : String])] - [#:struct (p-i source) ([target-name : Symbol] - [instruction : String])] - [xexpr->string (Xexpr -> String)]) -(provide (all-from-out xml) cdata? xexpr->string) - - -(define-type Valid-Char Natural) ;; overinclusive but that's as good as it gets -(define-type Txexpr-Tag Symbol) -(define-type Txexpr-Attr-Key Symbol) -(define-type Txexpr-Attr-Value String) -(define-type Txexpr-Attr (List Txexpr-Attr-Key Txexpr-Attr-Value)) -(define-predicate Txexpr-Attr? Txexpr-Attr) -(define-type Can-Be-Txexpr-Attr-Key (U Symbol String)) -(define-type Can-Be-Txexpr-Attr-Value (U Symbol String)) -(define-type Txexpr-Attrs (Listof Txexpr-Attr)) -(define-type Txexpr-Attr-Hash (HashTable Txexpr-Attr-Key Txexpr-Attr-Value)) -(define-type Txexpr-Element Xexpr) -(define-type Txexpr-Elements (Listof Txexpr-Element)) -(define-type Txexpr-Full (List* Txexpr-Tag Txexpr-Attrs (Listof Xexpr))) -(define-type Txexpr-Short (Pairof Txexpr-Tag (Listof Xexpr))) -(define-type Txexpr (U Txexpr-Full Txexpr-Short)) -(define-type Xexpr (Rec X - (U String - (List* Txexpr-Tag Txexpr-Attrs (Listof X)) - (Pairof Txexpr-Tag (Listof X)) - Symbol - Valid-Char - cdata - comment - p-i))) - -(define-predicate xexpr? Xexpr) -(define-predicate txexpr? Txexpr) -(define-predicate txexpr-short? Txexpr-Short) -(define-predicate txexpr-tag? Txexpr-Tag) -(define-predicate txexpr-tags? (Listof Txexpr-Tag)) -(define-predicate txexpr-attr? Txexpr-Attr) -(define-predicate txexpr-attrs? Txexpr-Attrs) -(define-predicate Valid-Char? Valid-Char) -(define/typed (txexpr-element? x) - (Any -> Boolean) - (if (xexpr? x) - (if (Valid-Char? x) (valid-char? x) #t) - #f)) -(define-predicate txexpr-elements? (Listof Xexpr)) -(define-predicate txexpr-attr-key? Txexpr-Attr-Key) -(define-predicate txexpr-attr-value? Txexpr-Attr-Value) -(define-predicate txexpr-attr-values? (Listof Txexpr-Attr-Value)) -(define-predicate can-be-txexpr-attr-key? Can-Be-Txexpr-Attr-Key) -(define-predicate can-be-txexpr-attr-value? Can-Be-Txexpr-Attr-Value) -(define-predicate can-be-txexpr-attr? (List Can-Be-Txexpr-Attr-Key Can-Be-Txexpr-Attr-Value)) -(define-type Can-Be-Txexpr-Attr (U Txexpr-Attr Txexpr-Attrs Can-Be-Txexpr-Attr-Key Can-Be-Txexpr-Attr-Value)) -(define-predicate can-be-txexpr-attrs? Can-Be-Txexpr-Attr) -(define-predicate list-of-can-be-txexpr-attrs? (Listof Can-Be-Txexpr-Attr)) \ No newline at end of file