add listof-zero?

Author: wargrey

cmdopt.rkt

@@ -6,8 +6,7 @@
 (require racket/symbol)
 
 (require "digitama/cmdopt.rkt")
-
-(require "number.rkt")
+(require "digitama/predicate.rkt")
 
 (require (for-syntax racket/base))
 (require (for-syntax racket/syntax))

digitama/predicate.rkt

@@ -0,0 +1,18 @@
+#lang typed/racket/base
+
+(provide (all-defined-out))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define nonnegative-fixnum? : (-> Any Boolean : Nonnegative-Fixnum) (λ [n] (and (fixnum? n) (>= n 0))))
+(define nonnegative-flonum? : (-> Any Boolean : #:+ Nonnegative-Flonum) (λ [f] (and (flonum? f) (>= f 0.0)))) ; unable to deal with +nan.0
+
+(define positive-byte? : (-> Any Boolean : Positive-Byte) (λ [b] (and (byte? b) (> b 0))))
+(define positive-index? : (-> Any Boolean : Positive-Index) (λ [i] (and (index? i) (> i 0))))
+(define positive-fixnum? : (-> Any Boolean : Positive-Fixnum) (λ [n] (and (fixnum? n) (> n 0))))
+(define positive-flonum? : (-> Any Boolean : #:+ Positive-Flonum) (λ [f] (and (flonum? f) (> f 0.0)))) ; unable to deal with +nan.0
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define real-zero? : (-> Any Boolean)
+  (lambda [v]
+    (and (real? v)
+         (zero? v))))

number.rkt

@@ -2,21 +2,14 @@
 
 (provide (all-defined-out))
 (provide (rename-out [string+>integer string->natural]))
+(provide (all-from-out "digitama/predicate.rkt"))
 (provide msb-bytes->float lsb-bytes->float
          msb-bytes->double lsb-bytes->double)
 
 (require "digitama/unsafe/number.rkt")
+(require "digitama/predicate.rkt")
 (require "digitama/number.rkt")
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define nonnegative-fixnum? : (-> Any Boolean : Nonnegative-Fixnum) (λ [n] (and (fixnum? n) (>= n 0))))
-(define nonnegative-flonum? : (-> Any Boolean : #:+ Nonnegative-Flonum) (λ [f] (and (flonum? f) (>= f 0.0)))) ; unable to deal with +nan.0
-
-(define positive-byte? : (-> Any Boolean : Positive-Byte) (λ [b] (and (byte? b) (> b 0))))
-(define positive-index? : (-> Any Boolean : Positive-Index) (λ [i] (and (index? i) (> i 0))))
-(define positive-fixnum? : (-> Any Boolean : Positive-Fixnum) (λ [n] (and (fixnum? n) (> n 0))))
-(define positive-flonum? : (-> Any Boolean : #:+ Positive-Flonum) (λ [f] (and (flonum? f) (> f 0.0)))) ; unable to deal with +nan.0
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (define string->byte : (->* (String) (Integer) (Option Byte))
   (lambda [str.n [radix 10]]

predicate.rkt

@@ -2,24 +2,41 @@
 
 (provide (all-defined-out))
 
+(require "digitama/predicate.rkt")
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define is-listof? : (All (T) (-> Any (-> Any Boolean : T) Boolean : #:+ (Listof T) #:- (! (Listof T))))
+(define listof? : (All (T) (case-> [Any (-> Any Boolean : T) -> Boolean : #:+ (Listof T) #:- (! (Listof T))]
+                                   [Any (-> Any Boolean) -> Boolean]))
   (lambda [v ?]
     (and (list? v)
          (andmap ? v))))
 
-(define is-listof+? : (All (T) (-> Any (-> Any Boolean : T) Boolean : #:+ (Pairof T (Listof T)) #:- (! (Pairof T (Listof T)))))
+(define listof+? : (All (T) (case-> [Any (-> Any Boolean : T) -> Boolean : #:+ (Pairof T (Listof T)) #:- (! (Pairof T (Listof T)))]
+                                    [Any (-> Any Boolean) -> Boolean]))
   (lambda [v ?]
     (and (list? v)
          (pair? v)
          (andmap ? v))))
 
+(define make-listof? : (All (T) (case-> [(-> Any Boolean : T) -> (-> Any Boolean : #:+ (Listof T) #:- (! (Listof T)))]
+                                        [(-> Any Boolean) -> (-> Any Boolean)]))
+  (lambda [?]
+    (λ [v] (listof? v ?))))
+
+(define make-listof+? : (All (T) (case-> [(-> Any Boolean : T) -> (-> Any Boolean : #:+ (Pairof T (Listof T)) #:- (! (Pairof T (Listof T))))]
+                                         [(-> Any Boolean) -> (-> Any Boolean)]))
+  (lambda [?]
+    (λ [v] (listof+? v ?))))
+
 (define disjoin? : (All (a b c) (case-> [Any (-> Any Boolean : a) (-> Any Boolean : b) -> Boolean : #:+ (U a b) #:- (! (U a b))]
                                         [Any (-> Any Boolean : a) (-> Any Boolean : b) (-> Any Boolean : c) -> Boolean : #:+ (U a b c) #:- (! (U a b c))]))
   (case-lambda
     [(v p1? p2?) (or (p1? v) (p2? v))]
     [(v p1? p2? p3?) (or (p1? v) (p2? v) (p3? v))]))
 
+(define listof-zero? : (-> Any Boolean) (make-listof? real-zero?))
+(define listof+zero? : (-> Any Boolean) (make-listof+? real-zero?))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (define bs-regexp? : (-> Any Boolean : (U Regexp Byte-Regexp))
   (lambda [v]

tamer/zip/lz77.rkt

@@ -9,10 +9,10 @@
 (require digimon/cmdopt)
 (require digimon/dtrace)
 (require digimon/format)
-(require digimon/number)
 (require digimon/debug)
 (require digimon/echo)
 
+(require digimon/digitama/predicate)
 (require digimon/digitama/bintext/lz77)
 (require digimon/digitama/bintext/archive)
 (require digimon/digitama/bintext/zipconfig)