经过这一段时间对概念文字，递归函数，lambda演算和组合子逻辑的研究，我发现了一种新的表示方法，这种表示法，可以通过生成上下文，来控制符号的含义，这个基本的思想可以追溯到哲学对于概念的思考，我们的文字和自然语言，都具有上下文，用一个符号指代在上文中出现的概念，那么这个符号本身就是上下文相关的，在编程语言中，因为符号无法被重用，会导致冲突，但是，我注意到有一些编程语言，比如著名的APL和J语言，具有上下文，它使用了隐式符号，来避免了这种冲突，但是我在研究smalltalk的时候，也发现它具有生成新对象的语义，这个新的对象，不就是一个语义嘛，当我想到这里的时候，顿时觉得，用函数生成具有新的上下文的函数，不就是一个新的对象，一个新的概念，而且我们可以使用范畴来控制它的语义，也就是集合的运算，来指定符号的范围，这样可以大大减少新符号的使用，而且，我们的语义更加精确，因为集合的明确抽象，可以避免模糊的语义，一切函数都可以进行集合推断，从而判断它的类型，这不就是最基本的逻辑推理吗？要么定义范围，要么定义内涵。而且可以运用某些测试函数来自动推理范围，这个我还在研究当中。下面给出一个人类推理的过程。
一类物体的大量现象 => 一般的类 => 根据某些性质判断类型 => 得出普遍的性质。
《九章算术》也写道：“事有相推，各有攸归，故枝条虽分而本干知，发其一端而已”。
这里面涉及到充分条件，必要条件的确定，我们就不细说了，但是这个过程无疑是对的。
我们的编程语言具有这样的能力，首先，我们可以生成新的上下文。
1+ 1 = 2
1 + 1 = 1+ 1 = 2
//注意，这里的1 + 1后面两个字符表示“加1”，“1”这个概念和“+”这个概念生成了“加1”这个概念。
这样无限地递归下去。
true 1 2 = 1
false 1 2 = true 2 = 2
首先我们的true把第一个元素拿出来，false先生成一个true，然后直接取出来。
其他的具体就不描述了，下面直接上代码。
(define (array x)
(define (gen-compare x c n)
(if (null? x) '()
(if (c (car x) n)
(cons (car x) (gen-compare (cdr x) c n))
(gen-compare (cdr x) c n))))
(define (gen-add x add n res)
(if (null? x)
(if (null? n) (array (reverse res))
(gen-add x add (cdr n) (cons (car n) res)))
(gen-add (cdr x) add n (cons (car x) res))))
(define (qst arr)
(if (arr = null?) null-arr
((qst ((arr cdr) <= (arr car))) +
((array (list (arr car))) +
(qst ((arr cdr) > (arr car)))))))
(lambda (f . n)
(cond
((compare > f) (array (gen-compare x f (car n))))
((eq? f +) (gen-add x + ((car n) =) '()))
((eq? f car) (car x))
((eq? f cdr) (array (cdr x)))
((eq? f sort) (qst (array x)))
((eq? f =)
(if (null? n)
x
(if (eq? (car n) null?)
(null? x))))
(else 'err))))
(define c (array '(1 3 5 7 9)))
(define d (array '(2 4 6 8 10)))
(define f (array '(1 7 8 2 4)))
((c > 2) =)
((c + d) =)
((c + (d + (d + c))) =)
(define null-arr (array '()))
(c = null?)
((f sort) =)
(null-arr =)
(null-arr = null?)
(define (set x)
(define (belong-to? x n)
(if (null? x) #f
(if (eq? (if (procedure? n) (eval (car x) user-initial-environment) (car x)) n) #t
(belong-to? (cdr x) n))))
(define (add-set all self n res)
(if (null? (self =))
(if (null? (n =)) (set (((array res) sort) =))
(add-set all self (n cdr)
(if (all < (n car)) (cons (n car) res) res) ))
(add-set all (self cdr) n (cons (self car) res))))
(define (include? self n)
(if (null? (n =)) #t
(if (self < (n car)) #f
(include? self (n cdr)))))
(define self
(lambda (f . n)
(cond
((eq? f +) (add-set self self (car n) '()))
((eq? f >) (belong-to? x (car n)))
((eq? f <) (not (belong-to? x (car n))))
((eq? f >=) (include? self (car n)))
((eq? f <=) (not (include? self (car n))))
((eq? f =) x)
((eq? f car) (car x))
((eq? f cdr) (set (cdr x) ))
(else 'err))))
self)
(define a (set '(1 2 3)))
(a >= (set '(1 4)))
((a + (set '(2 3 4))) =)
(((set '(1 2 3 6 9 10)) + (set '(2 5 10 13 27))) =)
(a > 1)
(a < 4)
(define compare (set '(> < <= >=)))
(compare > <=)
这里分别定义了两个类，一个是array类，一个是set类，它们虽然具有很多完全相同的符号，但是因为函数生成了新的语义，也就是新的函数和上下文，所以它们根本不会冲突，这样的编写方式非常优雅。
