nendo 0.6.4 → 0.6.5

data/lib/nendo/nendo/experimental.nnd

@@ -32,6 +32,37 @@
 ;;;   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ;;;  
 
+;; for nendo.lazy
+(define *ruby-lazy-enabled-platform*
+  (let ((arr (. Array new)))
+    (arr.respond_to? (. "lazy" to_sym)))) ;; Check the Emumerable#lazy method
+(define (ruby-lazy-enabled-platform?) *ruby-lazy-enabled-platform*)
+
+
+(define (ruby-lazy enumerable)
+  (if (and (ruby-lazy-enabled-platform?)
+           (enumerable.is_a? Enumerable))
+      (. enumerable lazy)
+      enumerable))
+
+(define (ruby-lazy? v)
+  (if (ruby-lazy-enabled-platform?)
+      (v.is_a? Enumerator::Lazy)
+      #f))
+
+(define (vector? v)
+  (or (v.is_a? Array)
+      (ruby-lazy? v)))
+  
+(define (vector->list v)
+  (let1 v (if (ruby-lazy? v)
+              (v.to_a)
+              v)
+    v.to_list))
+
+
+
+
 
 ;; Checking (Ruby's Enumerable?) and (not Nendo's list?)
 (define (%%enumerable? x)
@@ -88,10 +119,33 @@
       (%filter-original proc lst)))
 
 
+(define (%%fold-able? proc knil lst)
+  (%%enumerable? lst))
+
+(define (%%fold proc knil vec)
+  (vec.inject knil
+              (&block (result item)
+                (proc item result))))
+
+(define (%fold-original proc knil lis1)
+  (define (null-list? l)
+    (cond ((pair? l) #f)
+          ((null? l) #t)
+          (else (error "null-list?: argument out of domain" l))))
+  (check-arg procedure? proc %fold-original)
+  (let lp ((lis lis1) (ans knil))
+    (if (null-list? lis) ans
+        (lp (cdr lis) (proc (car lis) ans)))))
+
+(define (%fold proc knil lst)
+  (if (%%fold-able?   proc knil lst)
+      (%%fold         proc knil lst)
+      (%fold-original proc knil lst)))
+
 (define map         %map)
 (define for-each    %for-each)
 (define filter      %filter)
-
+(define fold        %fold)
 
 
 ;; dis-assembler
@@ -197,3 +251,17 @@
      (raise nendo-syntax-error "let1 requires (let1 var expr body ...) form."))
     ((let1 var expr body ...)
      (%let ((var expr)) body ...))))
+
+
+(define (readlines io)
+  (if (not (io.is_a? IO))
+      (raise ArgumentError "readlines expects IO object.")
+      (map
+       (lambda (x) (x.chomp))
+       (ruby-lazy (io.each_line)))))
+
+
+(define (readchars io)
+  (if (not (io.is_a? IO))
+      (raise ArgumentError "readlines expects IO object.")
+      (ruby-lazy (io.each_char))))