razyk 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.rspec

@@ -0,0 +1 @@
+--color

data/LICENSE

@@ -0,0 +1,56 @@
+RazyK is copyrighted free software by Tomoyuki Chikanaga <nagachika00@gmail.com>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= RazyK
+
+RazyK is a LazyK implementation by pure ruby.
+
+== LazyK
+LazyK is referentially transparent functional programming language.
+ * LazyK programs are expressed by only S, K, I combinators
+ * Lazy evaluation
+ * Stream I/O system
+
+For details, see website bellow.
+
+http://homepages.cwi.nl/~tromp/cl/lazy-k.html
+
+== Copyright
+
+Copyright (c) 2010 nagachika. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "razyk"
+    gem.summary = %Q{pure ruby LazyK implementation}
+    gem.description = %Q{RazyK is a LazyK implementetion by pure ruby}
+    gem.email = "nagachika00@gmail.com"
+    gem.homepage = "http://github.com/nagachika/razyk"
+    gem.authors = ["nagachika"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency "rack"
+    gem.add_dependency "ruby-graphviz"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+begin
+  require 'spec/rake/spectask'
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  Spec::Rake::SpecTask.new(:rcov) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rcov = true
+  end
+
+  task :spec => :check_dependencies
+rescue LoadError
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov_opts = %q[--exclude "spec"]
+  end
+
+  task :spec => :check_dependencies
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "razyk #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :racc => [ "lib/razyk/parser.y" ] do
+  sh "racc -o lib/razyk/parser.rb lib/razyk/parser.y"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/razyk

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require "razyk"
+require "optparse"
+
+module RazyK
+  class Application
+    def initialize
+      @program = nil
+      @step = false
+      @web_server = false
+      @optparse = option_parser
+    end
+
+    def option_parser
+      OptionParser.new do |opt|
+        opt.on("-e 'program'",
+               "specify LazyK program string. Omit [programfile]") do |prog|
+          @program = prog
+        end
+        opt.on("-s", "--step", "step execution. Dump combinator tree by each step") do
+          @step = true
+        end
+        opt.on("--server [PORT]", "start web server") do |port|
+          @port = Integer(port || 9292)
+          @step = true
+          @web_server = true
+        end
+      end
+    end
+    private :option_parser
+
+    def run(argv)
+      @optparse.parse!(argv)
+
+      if @web_server
+        require "razyk/webapp"
+        app = RazyK::WebApp.new
+        # This should work, but rack-1.2.1 fails. :app don't overwrite config.ru
+        #Rack::Server.start(:app => app, :Port => @port)
+        trap(:INT) do
+          if Rack::Handler::WEBrick.respond_to?(:shutdown)
+            Rack::Handler::WEBrick.shutdown
+          else
+            exit
+          end
+        end
+        Rack::Handler::WEBrick.run(app, :Port => @port)
+        return
+      end
+
+      if @program.nil?
+        if argv.empty?
+          raise "please specify LazyK program file"
+        end
+        filepath = argv.shift
+        @program = IO.read(filepath)
+      end
+
+      if @step
+        RazyK.run(@program) do |vm|
+          $stderr.puts vm.tree.inspect
+        end
+      else
+        RazyK.run(@program)
+      end
+    end
+  end
+end
+
+app = RazyK::Application.new
+app.run(ARGV)

data/examples/lazier.scm

@@ -0,0 +1,328 @@
+;;
+;; Lazier, a "compiler" from lambda calculus to Lazy K.
+;; Copyright 2002 Ben Rudiak-Gould. Distributed under the GPL.
+;;
+;; Usage examples:
+;;
+;; > (lazy-def '(myprog input) '(cdr (cdr input))) ; drops first two bytes of input
+;; > (lazy-def 'myprog '(o cdr cdr))	; equivalent definition
+;;
+;; > (laze 'myprog)
+;; ((s ((s i) (k (k i)))) (k (k i)))
+;;
+;; > (print-as-cc (laze 'myprog))
+;; S(SI(K(KI)))(K(KI))
+;;
+;; > (print-as-unlambda (laze 'myprog))
+;; ``s``si`k`ki`k`ki
+;;
+;; > (print-as-iota (laze 'myprog))
+;; ***i*i*i*ii***i*i*i*ii*ii**i*i*ii**i*i*ii*ii**i*i*ii**i*i*ii*ii
+;;
+;; > (print-as-jot (laze 'myprog))
+;; 111111100011111110001111111110000011110011110011111111100000111100111100
+;; 11111111100000
+;;
+;; > (lazy-def '(f x y z) '(x (y z)))			; \
+;; > (lazy-def 'f '(lambda (x y z) '(x (y z))))		; | equivalent
+;; > (lazy-def 'f '(lambda (x) (lambda (y) ...)))	; /
+;;
+;; > (laze '(f arg1 arg2))
+;; ((s (k arg1)) arg2)
+;;
+;; > (print-as-unlambda (laze '(f arg1 arg2)))
+;; ``s`k[arg1][arg2]
+;;
+
+
+; lazy-def.
+
+(define lazy-defs '())
+
+(define (lazy-def name body)
+  (set! lazy-defs
+        (cons (if (pair? name)
+                  (cons (car name)
+                        (curry-lambda (cdr name) (curry body)) )
+                  (cons name (curry body)) )
+              lazy-defs )))
+
+(define (lazy-def-lookup name)
+  (assv name lazy-defs) )
+
+
+; Currying.
+
+(define (curry expr)
+  (cond ((not (pair? expr)) expr)
+        ((eq? (car expr) 'lambda)
+         (curry-lambda (cadr expr) (curry (caddr expr))) )
+        (else
+         (curry-app (map curry expr)) )))
+
+(define (curry-lambda vars body)
+  (if (null? vars)
+      body
+      `(lambda (,(car vars)) ,(curry-lambda (cdr vars) body)) ))
+
+(define (curry-app lst)
+  (let iter ((sofar (car lst))
+             (togo (cdr lst)) )
+    (if (null? togo)
+        sofar
+        (iter (list sofar (car togo)) (cdr togo)) )))
+
+
+; Macro expansion.
+
+(define (expr-dispatch expr leaf appl lamb)
+  (if (pair? expr)
+      (if (eq? (car expr) 'lambda)
+          (lamb (caadr expr) (caddr expr))
+          (appl (car expr) (cadr expr)) )
+      (leaf expr) ))
+
+(define (expand-macros expr)
+  (let helper ((expr expr) (exclude '()) (stack '()))
+    (expr-dispatch expr
+     (lambda (leaf)
+       (cond ((memv leaf exclude) leaf)
+             ((memv leaf stack)
+              (display "Recursion within lazy-defs detected: ")
+              (display (cons leaf stack))
+              (newline)
+              (error) )
+             (else
+              (let ((def (lazy-def-lookup leaf)))
+                (if def
+                    (helper (cdr def) exclude (cons leaf stack))
+                    leaf )))))
+     (lambda (f g)
+       (list (helper f exclude stack) (helper g exclude stack)) )
+     (lambda (var body)
+       `(lambda (,var) ,(helper body (cons var exclude) stack)) ))))
+
+
+; Replace ((lambda (var) body) value) with body[value/var] if:
+;
+;   - value is a symbol, or
+;   - var appears only once in body and value contains no
+;     more than one free variable which is not in body.
+;
+; I'm not sure if the first of these is ever needed -- it may
+; always be handled by the other optimizations -- but it's easy
+; to check for.
+
+(define (apply-lambdas expr)
+  (let ((top-level-free-vars (free-vars expr)))
+    (let self ((expr expr))
+      (expr-dispatch expr
+       (lambda (leaf) leaf)
+       (lambda (f g)
+         (let ((f: (self f))
+               (g: (self g)) )
+           (expr-dispatch f:
+            (lambda (leaf) (list f: g:))
+            (lambda (f:: g::) (list f: g:))
+            (lambda (var body)
+              (if (or (not (pair? g:))
+                      (and (<= (count-occurrences var body) 1)
+                           (not (more-than-one-additional
+                                 (free-vars g:)
+                                 (append top-level-free-vars (free-vars f:)) ))))
+                  (var-subst var g: body)
+                  (list f: g:) )))))
+       (lambda (var body)
+         `(lambda (,var) ,(self body)) )))))
+
+(define (add-prime var)
+  (string->symbol (string-append (symbol->string var) ":")) )
+
+(define (var-subst var value template)
+  (if (eqv? var value)
+      template
+      (let loop ((template template))
+        (expr-dispatch template
+         (lambda (leaf)
+           (if (eqv? var leaf) value leaf) )
+         (lambda (f g)
+           (list (loop f) (loop g)) )
+         (lambda (v body)
+           (if (eqv? var v)
+               template
+               (do ((template-vars (free-vars template))
+                    (value-vars (free-vars value))
+                    (v: v (add-prime v:)) )
+                 ((and (not (memv v: template-vars))
+                       (not (memv v: value-vars)) )
+                  `(lambda (,v:)
+                     ,(loop (var-subst v v: body)) )))))))))
+
+(define (more-than-one-additional a b)
+  (let loop ((a a) (last-sym (cons #f #f)))
+    (cond ((null? a) #f)
+          ((memv (car a) b)
+           (loop (cdr a) last-sym) )
+          ((or (pair? last-sym)		; no last symbol
+               (eqv? last-sym (car a)) )
+           (loop (cdr a) (car a)) )
+          (else #t) )))
+
+(define (free-vars expr)
+  (let loop ((expr expr) (bound ()))
+    (expr-dispatch expr
+      (lambda (leaf)
+        (if (memv leaf bound)
+            ()
+            (list leaf) ))
+      (lambda (f g)
+        (append (loop f bound) (loop g bound)) )
+      (lambda (var body)
+        (loop body (cons var bound)) ))))
+
+(define (contains-free-variable param template)
+  (expr-dispatch template
+   (lambda (leaf)
+     (eqv? param leaf) )
+   (lambda (f g)
+     (or (contains-free-variable param f)
+         (contains-free-variable param g) ))
+   (lambda (var body)
+     (and (not (eqv? param var))
+          (contains-free-variable param body) ))))
+
+(define (count-occurrences param template)
+  (expr-dispatch template
+   (lambda (leaf)
+     (if (eqv? param leaf) 1 0) )
+   (lambda (f g)
+     (+ (count-occurrences param f) (count-occurrences param g)) )
+   (lambda (var body)
+     (if (eqv? var param)
+         0
+        (count-occurrences param body) ))))
+
+
+; Abstraction elimination.
+
+(define (unabstract-lambda var body)
+  (if (contains-free-variable var body)
+      (expr-dispatch body
+       (lambda (leaf) 'i)
+       (lambda (f g)
+         (if (and (eqv? var g) (not (contains-free-variable var f)))
+             f
+             `((s ,(unabstract-lambda var f)) ,(unabstract-lambda var g)) ))
+       (lambda (v b)
+         (unabstract-lambda var (unabstract body)) ))
+      (list 'k body) ))
+
+(define (unabstract code)
+  (expr-dispatch code
+   (lambda (leaf) leaf)
+   (lambda (f g)
+     (list (unabstract f) (unabstract g)) )
+   (lambda (var body)
+     (unabstract-lambda var (unabstract body)) )))
+
+
+; Reduces expressions involving the S, K, I combinators where this
+; results in a shorter expression. Usually results in only a small
+; benefit.
+
+(define (apply-ski expr)
+  (if (not (pair? expr))
+      expr
+      (let ((lhs (apply-ski (car expr)))
+            (rhs (cadr expr)) )
+        (cond ((eq? lhs 'i)		; Ix -> x
+               (apply-ski rhs) )
+              ((and (pair? lhs)		; Kxy -> x
+                    (eq? 'k (car lhs)) )
+               (cadr lhs) )
+              ((and (pair? lhs)		; Sxyz -> xz(yz) when x or y is K_
+                    (pair? (car lhs))
+                    (eq? 's (caar lhs)) )
+               (let ((z rhs)
+                     (y (cadr lhs))
+                     (x (cadar lhs)) )
+                 (if (or (and (pair? x) (eq? (car x) 'k))
+                         (and (pair? y) (eq? (car y) 'k)) )
+                     (apply-ski `((,x ,z) (,y ,z)))
+                     (list lhs (apply-ski rhs)) )))
+              (else
+               (list lhs (apply-ski rhs)) )))))
+
+
+; This converts expressions of the form ((x z) (y z)) to (s x y z).
+; If z is just a symbol, then this change makes no difference to
+; Unlambda output, always reduces the size of CC output (I think),
+; and can either increase or reduce the side of Iota and Jot output.
+; Currently the change is made only when z is not just a symbol.
+;
+; Like apply-ski, this gives only a small benefit in most cases.
+
+(define (unapply-s expr)
+  (expr-dispatch expr
+   (lambda (leaf) leaf)
+   (lambda (f g)
+     (let ((f: (unapply-s f))
+           (g: (unapply-s g)) )
+       (if (and (pair? f:)
+                (pair? g:)
+                (pair? (cadr f:))
+                (equal? (cadr f:) (cadr g:)) )
+           `(((s ,(car f:)) ,(car g:)) ,(cadr f:))
+           (list f: g:) )))
+   (lambda (var body)
+     `(lambda (,var) ,(unapply-s body)) )))
+
+
+; Putting it all together.
+
+(define (laze code)
+  (unapply-s (apply-ski (unabstract (apply-lambdas (expand-macros (curry code)))))) )
+
+
+; Printing it out.
+
+(define (print-as-cc lazified-code)
+  (let self ((code lazified-code))
+    (expr-dispatch code
+     (lambda (leaf)
+      (if (memq leaf '(i k s))
+          (display (char-upcase (string-ref (symbol->string leaf) 0)))
+          (begin
+            (display "[")
+            (display leaf)
+            (display "]") )))
+     (lambda (f g)
+      (self f)
+      (if (pair? g) (display "("))
+      (self g)
+      (if (pair? g) (display ")")) )
+     (lambda (var body)
+      (error "Can't print lambdas as CC!") )))
+  (newline) )
+
+
+(define (print-as-generic aply k s i)
+  (lambda (lazified-code)
+    (let self ((code lazified-code))
+      (expr-dispatch code
+       (lambda (leaf)
+        (cond ((eq? leaf 'i) (display i))
+              ((eq? leaf 'k) (display k))
+              ((eq? leaf 's) (display s))
+              (else (display "[") (display leaf) (display "]")) ))
+       (lambda (f g)
+        (display aply)
+        (self f)
+        (self g) )
+       (lambda (var body)
+        (error "Can't print lambdas as Lazy code!") )))
+    (newline) ))
+
+(define print-as-unlambda (print-as-generic "`" "k" "s" "i"))
+(define print-as-iota (print-as-generic "*" "*i*i*ii" "*i*i*i*ii" "*ii"))
+(define print-as-jot (print-as-generic "1" "11100" "11111000" "11111111100000"))

data/examples/prelude.scm

@@ -0,0 +1,86 @@
+;; Some commonly useful macros for Lazier.
+;;
+;; There must not be any circular definitions here
+;; (e.g. a definition containing its own name). If
+;; you need recursion, you'll have to roll your own.
+;;
+;; Unfortunately, sometimes these functions have
+;; more than one form, and the one which is best for
+;; inlining is longer when not inlined. I know that
+;; this is the case for and, or, and list-of. In all
+;; three cases I picked the form preferable for
+;; inlining.
+
+;;; logic
+(lazy-def #t		'(lambda (x y) x))
+(lazy-def #f		'(lambda (x y) y))
+(lazy-def '(if p x y)	'(p x y))
+(lazy-def '(not p)	'(if p #f #t))
+(lazy-def '(and p q)	'(if p q #f))
+(lazy-def '(or p q)	'(if p #t q))
+
+;;; lists
+(lazy-def '(cons x y)	'(lambda (f) (f x y)))
+(lazy-def '(car list)	'(list #t))
+(lazy-def '(cdr list)	'(list #f))
+(lazy-def ()		'(lambda (f) #t))
+(lazy-def '(null? list)	'(list (lambda (x y) #f)))
+(lazy-def '(nth n lst)	'(car ((n cdr) lst)))
+(lazy-def '(list-ref lst n)	'(nth n lst))
+
+;;; Church numerals (see also prelude-numbers.scm)
+(lazy-def '(1+ a)	'(lambda (f) (lambda (x) (f ((a f) x)))))
+(lazy-def 'succ		'1+)
+(lazy-def 0		'(lambda (f) (lambda (x) x)))
+(lazy-def 1		'(lambda (f) f))
+(lazy-def 2		'(1+ 1))
+(lazy-def 4		'((lambda (x) (x x)) 2))
+(lazy-def 256		'((lambda (x) (x x)) 4))
+(lazy-def '(+ a)	'(a 1+))
+(lazy-def '(* a b)	'(lambda (f) (a (b f))))
+(lazy-def '(^ a b)	'(b a))
+(lazy-def '(ifnonzero n x y)	'((n (k x)) y))
+
+(lazy-def '(= a b)
+ '(nth b ((a (cons #f))
+          (cons #t (list-of #f)) )))
+(lazy-def '(!= a b)
+ '(nth b ((a (cons #t))
+          (cons #f (list-of #t)) )))
+
+; the following neat <= function is stolen from the Unlambda page
+(lazy-def '(if<= m n x y)	'((m ^ (k x)) (n ^ (k y))))
+(lazy-def '(if> m n x y)	'(if<= m n y x))
+(lazy-def '(if>= m n x y)	'(if<= n m x y))
+(lazy-def '(if< m n x y)	'(if<= n m y x))
+
+
+;;; miscellaneous
+
+(lazy-def 'end-of-output '(lambda (f) 256))
+
+(lazy-def 'list-from
+ '((lambda (x) (x x))
+   (lambda (self n)
+     (cons n (self self (1+ n))) )))
+
+; functional composition (same as *)
+(lazy-def '(o f g)	'(lambda (x) (f (g x))))
+
+(lazy-def '(list-of elt)
+ '(Y (cons elt)) )
+
+(lazy-def '(Y f)
+ '((lambda (x) (x x))
+   (lambda (self)
+     (f (self self)) )))
+
+; The following definition of the Y combinator is taken from
+; "Kolmogorov Complexity in Combinatory Logic" by John Tromp
+; (http://www.cwi.nl/~tromp/cl/CL.ps). It is shorter by itself,
+; but longer when applied. Interestingly, there is no way (that
+; I found) to produce this from a lambda expression using
+; Lazier. Specifically, Lazier can't figure out that
+; (lambda (y) (x (w y x))) is equivalent to SS(Sw)(Kx).
+
+;(lazy-def 'Y '(S S K (S (K (S S (S (S S K)))) K)))

data/examples/prime.lazy

@@ -0,0 +1,20 @@
+ K
+ (SII(S(K(S(S(K(SII(S(S(KS)(S(K(S(KS)))(S(K(S(S(KS)(SS(S(S(KS)K))(KK)))))
+ (S(S(KS)(S(KK)(S(KS)(S(S(KS)(S(KK)(S(KS)(S(S(KS)(S(KK)(SII)))
+ (K(SI(KK)))))))(K(S(K(S(S(KS)(S(K(SI))(S(KK)(S(K(S(S(KS)K)(S(S(KS)K)I)
+ (S(SII)I(S(S(KS)K)I)(S(S(KS)K)))))(SI(K(KI)))))))))(S(KK)K)))))))(K(S(KK)
+ (S(SI(K(S(S(S(S(SSK(SI(K(KI))))(K(S(S(KS)K)I(S(S(KS)K)(S(S(KS)K)I))
+ (S(K(S(SI(K(KI)))))K)(KK))))(KK))(S(S(KS)(S(K(SI))(S(KK)(S(K(S(S(KS)K)))
+ (SI(KK))))))(K(K(KI)))))(S(S(KS)(S(K(SI))(SS(SI)(KK))))(S(KK)
+ (S(K(S(S(KS)K)))(SI(K(KI)))))))))(K(K(KI))))))))))(K(KI)))))(SI(KK)))))
+ (S(K(S(K(S(K(S(SI(K(S(K(S(S(KS)K)I))(S(SII)I(S(S(KS)K)I)))))))K))))
+ (S(S(KS)(S(KK)(SII)))(K(SI(K(KI)))))))(SII(S(K(S(S(KS)(S(K(S(S(SI(KK))
+ (KI))))(SS(S(S(KS)(S(KK)(S(KS)(S(K(SI))K)))))(KK))))))(S(S(KS)
+ (S(K(S(KS)))(S(K(S(KK)))(S(S(KS)(S(KK)(SII)))(K(S(S(KS)K)))))))(K(S(S(KS)
+ (S(K(S(S(SI(KK))(KI))))(S(KK)(S(K(SII(S(K(S(S(KS)(S(K(S(K(S(S(KS)(S(KK)
+ (S(KS)(S(K(SI))K))))(KK)))))(S(S(KS)(S(KK)(S(K(SI(KK)))(SI(KK)))))
+ (K(SI(KK))))))))(S(S(KS)(S(K(S(KS)))(S(K(S(KK)))(S(S(KS)(S(KK)(SII)))
+ (K(SI(K(KI))))))))(K(K(SI(K(KI)))))))))(S(K(SII))(S(K(S(K(SI(K(KI))))))
+ (S(S(KS)(S(KK)(SI(K(S(K(S(SI(K(KI)))))K)))))(K(S(K(S(SI(KK))))
+ (S(KK)(SII)))))))))))(K(SI(K(KI))))))))(S(S(KS)K)I)
+ (SII(S(K(S(K(S(SI(K(KI)))))K))(SII)))))

data/examples/reverse.lazy

@@ -0,0 +1,4 @@
+````sii``s`k`s``s`ks``s`kk``s`k````sii```sii``s``s`kski``s`k`sikk
+``s`k`s`k`s``s``si`kk`k``s`k`sik``s`k`s`k`s`kk``s``s`ks``s`k`s`ks
+``s``s`ks``s`kk``s`ks``s`kk``sii`k``s`k`s``s`ks``s`k`si```ss`si`kk
+``s`kkk`k`k``si`k`ki`k```sii```sii``s``s`kski

data/examples/reverse.scm

@@ -0,0 +1,12 @@
+(load "lazier.scm")
+(load "prelude.scm")
+
+(lazy-def 'rev
+ '((lambda (f) (f end-of-output))
+     ((lambda (x) (x x))
+      (lambda (self dst src)
+        (if>= (car src) 256
+              dst
+              (self self (cons (car src) dst) (cdr src)) )))))
+
+(print-as-unlambda (laze 'rev))