Blogger后台截图留恋

由于Blogger比Gmal更早一些，所以帐号就不是Gmail的帐号了。
这个后台界面挺让人怀念的，毕竟用了很长时间，被GPlus了真讨厌呢。
有些是草稿，这个貌似之前说到过了，没想到挺占屏幕的。
没写过什么有价值的东西，都是自言自语胡思乱想的东西。
以前blogger和youtube都是可以很方便就能上的站点呢。
当初google还不强推什么googleplus这个整合地令人讨厌的东西呢。
当初墙还对ssl无奈呢，当初网页不是css布局，科技发展真是飞快呀。
当初知道窗口原来还可以用标题栏拖动位置，还真是吃了一惊呢。
当初还对着键盘敲着dir，然后进wps，然后打字打字打字只会打字呢。
回忆真是无趣，明明未来将获得更美好的东西，明明回忆是蕴含着——
希望，财富，信念，憧憬，活力的的过去时光，
何必总以未来的没有到来而让回忆就总染上了橘红色的悲伤气氛呢。

所谓“永恒”呢，或许它不是历史长河中注定的一尘不变的遗忘，而是在过去与将来的种种的不相干的事物之中呈现出来的一致面。一份由过去的经验与财富给当前留下的踏实感，一份由未来可以继续传递下去的憧憬和希望，这些都是由“永恒”所连接起的美好回忆与期盼的那一份璀璨纽带。

一种Scheme语言中基于消息传递的面向对象机制 上 -- 语言机制

以下代码是单纯为了试一试在Scheme里面使用使用面向对象机制而写。
大致可行不过仍需完善，利用更多常见的使用情况还需要单独地特别考虑一下。

代码贴在这里格式乱掉了。。。

其实OO有很多中实现方式，这里主要是使用闭包了。
闭包有天然的作用域可以作为访问控制
----
http://pastebin.com/ifbtVEPS

;#lang r5rs
;(define error display)
;;;一种Scheme语言中基于消息传递的面向对象机制 上 -- 语言机制 - Closure
;;;面向对象的机制的实现方式很都多种，常见的比如基于向量和隐藏this指针的。
;;;这里是基于程序语言中的闭包特性来实现的，尝试了面向对象机制中的一些常见情况。
;;;参考1 OCaml http://caml.inria.fr/pub/docs/u3-ocaml/ocaml-objects.html
;;;参考2 SICP http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-17.html
;;;参考3 R5RS http://www.schemers.org/Documents/Standards/R5RS/HTML/
;;;查找对象方法的时间复杂度依赖所用实现的case语句的实现方式，若有优化则为O(1)。


;;;========================= 定义部分 ============================

;;;function send
;;;向对象发送消息
;;;type = closure * symbol * object list -> object
;;;example. (send pair 'set-car! 1) == (set-car! pair 1)
(define (send object method . arguments)
(cond ((object method)
=>(lambda (x) (apply x arguments)))
(else (error "method missing"))))
;;;function interface
;;;检验对象是否实现方法，注意方法名一致不能保证方法的语义正确
;;;type = symbol list -> (closure -> boolean)
;;;example. sequence? == (interface 'car 'cdr)
(define (interface . methods)
(lambda (object)
(let loop ((methods methods))
(cond ((null? methods) #t)
((not (object (car methods))) #f)
(else (loop (cdr methods)))))))
;;;functon coerce
;;;将对象绑定的若干方法表示为列表，用于调用泛型函数使用
;;;type = symbol list -> procedure list
;;;example. (coerce 'car 'cdr)
(define (coerce . methods)
(map (lambda (method)
(lambda (object . arguments) (apply send object method arguments)))
methods))
;;;function method
;;;从对象链中查找方法
;;;type = symbol * closure list -> (procedure | false)
;;;example. ((method 'car pair)) == (send pair 'car)
(define (method symbol . objects)
(let loop ((protos objects))
(cond ((null? protos) #f)
(((car protos) symbol) => (lambda (x) x))
(else (loop (cdr protos))))))
;;;macro object
;;;创建对象
;;;syntax = (object (prototypes ...) ((method (arguments ...) body ...) ...))
;;;example. (send (object () ((one () 1)))) 'one) == 1
(define-syntax object
(syntax-rules ()
((_ (prototypes ...) ((method-name (arguments ...) body ...) ...))
(lambda (m)
(case m
((method-name) (lambda (arguments ...) body ...)) ...
(else (apply method m (list prototypes ...))))))))
;;;macro thunk
;;;用于延迟绑定
;;;syntax = (thunk object)
;;;example. (thunk 0)
(define-syntax thunk
(syntax-rules () ((_ x) (lambda () x))))
;;;;macro object2
;;;上述“macro object”的 rich 版本
;;;syntax = (object2 self (prototype-news ...) ((slot value) ...) ((method (arguments ...) body ...) ...) init ...)
;;;example. <404>
(define-syntax object2;define
(syntax-rules ()
((_ self (prototype-news ...) ((slot value) ...) ((method (arguments ...) body ...) ...) init ...)
(letrec ((slot value) ...
(self
(lambda (m)
(case m
((method) (lambda (arguments ...) body ...)) ...
(else (let loop ((protos (list (prototype-news (lambda () self)) ...)))
(cond ((null? protos) #f)
(((car protos) m) => (lambda (x) x))
(else (loop (cdr protos))))))))))
init ... self))))
;;;object top-object2
;;;用于继承树的根节点
(define (top-object2 this)
(object2 self () () ((init () (this)))))
;;;function new
;;;用来构造一个对象
(define (new class . arguments)
(define self (apply send (class (thunk self)) 'init arguments))
self)
;;;========================= 示例部分 ============================

;;;* 示例一 Pair::mcons
;;;该示例用来演示如何创建一个对象
;;;定义A
(define (mcons0 x y)
(lambda (m)
(case m
((car) (lambda () x))
((cdr) (lambda () y))
((set-car) (lambda (z) (set! x z)))
((set-cdr) (lambda (z) (set! x z)))
((->pair) (lambda ()(cons x y)))
(else #f))))
;;;定义B
(define (mcons x y)
(object ()
((car () x)
(cdr () y)
(set-car (z) (set! x z))
(set-cdr (z) (set! y z))
(->pair () (cons x y)))))
;;;泛型
(define (mcar mpair)
((mpair 'car)))
(define (mcdr mpair)
((mpair 'cdr)))
(define (set-mcar mpair obj)
((mpair 'set-car) obj))
(define (set-mcdr mpair obj)
((mpair 'set-cdr) obj))
(define (mpair->pair mpair)
((mpair '->pair)))
;;;使用
(let example-1 ()
(define x (mcons 1 2))
(display (mcdr x))
(newline))

;;;* 示例二 sequence
;;;该示例用来演示接口和泛型的使用
(define sequence? (interface 'car 'cdr))
(define (mlist . objects)
(if (null? objects) '()
(mcons (car objects) (apply mlist (cdr objects)))))
(define (for-each0 p lst)
(cond ((null? lst) '())
(else (p (car lst)) (for-each p (cdr lst)))))
(define (mfor-each p lst)
(cond ((null? lst) '())
(else (p (mcar lst)) (mfor-each p (mcdr lst)))))
(define (generic-for-each prod lst car cdr)
(cond ((null? lst) '())
(else (prod (mcar lst)) (generic-for-each prod (mcdr lst) car cdr))))
(define (mrange start end step)
(letrec ((self (object()
((car () start)
(cdr () (let ((x (+ (send self 'car) step)))
(if (cond ((> step 0) (<= start x end))
((< step 0) (>= start x end))
(else (error "mrange")))
(mrange x end step) '())))))))
self))
(let example-2 ()
(define x (mlist 1 2 3 4 5))
(mfor-each display x)
(display (sequence? x))
;(mfor-each display (mrange 0 10 2))
;(generic-for-each display (mrange 0 10 2) mcar mcdr)
(apply generic-for-each display (mrange 0 -10 -3) (coerce 'car 'cdr))
(newline))

;;;* 示例三 slots
;;;该示例用来演示构造器和私有成员
(define (box x)
(letrec ((value '())
(self (object()
((ref () value)
(set! (x) (set! value x))
(add! (x) (send self 'set! (+ x (send self 'ref))))))))
(set! value x)
self))
(let example-3 ()
(define x (box 1))
(display (send x 'ref))
(send x 'set! 2)
(display (send x 'ref))
(send x 'add! 2)
(display (send x 'ref))
(newline))

;;;* 示例四 inheritance
;;;该示例用来演示扩充一个类
(define (mlist2 . objects)
(define super (apply mlist objects))
(define self
(object (super)
((for-each (prod) (apply generic-for-each prod self (coerce 'car 'cdr))))))
self)
(let example-4 ()
(define x (mlist2 1 2 3 4 5))
(mfor-each display x)
(send x 'for-each display)
(newline))

;;;* 实例五 virtual/override
;;;该示例用来演示模板方法模式
(let example-5 ()
(define (hello name)
(letrec((self
(object ()
((name () (name))
(say () (for-each display (list "hello " (send self 'name) "!\n")))))))
self))
(send (hello (lambda () "world0")) 'say)
(define (hello-world)
(define super (hello (lambda () (send self 'name))))
(define self (object (super) ((name () "world1"))))
self)
(send (hello-world) 'say)
(define (hello2 this)
(object ()
((name () "")
(say () (for-each display (list "hello " (send (this) 'name) "!\n"))))))
(define (hello-world2)
(define self
(object
((hello2 (thunk self)))
((name () "world2"))))
self)
(send (hello-world2) 'say)
(define (hello-world3)
(define self
(object2 self (top-object2 hello2) ()
((name () "world3"))))
self)
(send (hello-world3) 'say)
(define (hello-world4 this)
(define self
(object2 self (top-object2 hello2) ()
((name () "world4"))))
self)
(send (new hello-world4) 'say)
(newline))

;;;待续 一种Scheme语言中基于消息传递的面向对象机制 下 -- 使用模式


-----小改动，直接放在下面了----
不过话说这样更像Java而不是OCaml了。。。

(define-syntax object3;define
(syntax-rules (using method)
((_ ((method-name (arguments ...) body ...) ...))
(lambda (m)
(case m
((method-name) (lambda (arguments ...) body ...)) ...
(else #f))))
((_ super class using (traits ...) self ((slot value) ...) method ((method-name (arguments ...) body ...) ...))
(letrec ((super (class (lambda () self)))
(slot value) ...
(self
(lambda (m)
(case m
((method-name ) (lambda (arguments ...) body ...)) ...
(else (let loop ((protos (list super (traits (lambda () self)) ...)))
(cond ((null? protos) #f)
(((car protos) m) => (lambda (x) x))
(else (loop (cdr protos))))))))))
self))
((_ super class self ((slot value) ...) method ((method-name (arguments ...) body ...) ...))
(_ super class using () self ((slot value) ...) method ((method-name (arguments ...) body ...) ...)))
((_ super class self method ((method-name (arguments ...) body ...) ...))
(_ super class using () self () method ((method-name (arguments ...) body ...) ...)))
))
(define (root this)
(object3 ((init () (this)))))
(define (new class . arguments)
(define self (class (thunk self)))
(apply send (class (thunk self)) 'init arguments)
self)
(define (hello-world6 this)
(object3 super root using (hello2) self () method
((init () (send super 'init))
(name () "world6")
(say1 () (send (this) 'say)))))
(send (new hello-world6) 'say1)

-----
这样下去，干脆定义一个define-class算了。。。
用super表示父类（只有一个父类）this表示子类的对象，self表示当前类的对象。
这样好像把问题弄得复杂一下子就全部放在表面的问题。
由于用的是R5RS的“高级”“卫生”宏/语法，所以功能上有较多约束，不过有这些约束写起来还是更清爽了一些。
----
补充，感觉还是让object语法“小”一些比较好，多父类的判断可以移到语法宏的外面。
此外，多个原型也可以在子类中选择的调用，即不止一个spuer代表某个原型吧。
恩，其实OCaml里的对象是作为一种结构来实现的，要类型的话让闭包返回类型的联合也成吧。
嘛，这里也没多说清楚是怎么回事情，不过就是再补充一下了。

堆文的恶趣味

曾一直有断断续续地写些篇幅较短的小说作为娱乐，文字多为含含糊糊的叙述描写，风格大多只是为了体现某些方面趣味，内容有时语无伦次。
现在想这种趣味不能使得写出的文字有什么质量，不过缺失这种趣味的话，又觉得没什么自己来写的必要了。
既然定位于自娱自乐了，那么发扬之前的趣味来继续扩展一些，并学习一点新的趣味增添其中，还是一件蛮有趣味的事情吧。


* 趣味一 信息流动

即严格地在文本的阅读顺序中控制读者对整个故事知道什么，以怎样的顺序知道哪些事实，以及不同的事实之间存在着何种关联。
这就像有的侦探小说或者电影在观众的脑海里留下许多零散的画面片段，但是又巧妙的串联在一起，使得故事呈现出一种立体感。


* 趣味二 情节和叙述两条线索

故事情节本身是一条线索，而故事表现出来的是另一条线索，即叙事线和情节严格的分为两条线来处理。
叙事线本身也是一个有开端有发展有结局的故事，不过这个故事是作为叙述来使用的，而故事本身仍然是真正的故事情节本身。
通常来说可以用“寻找”“回忆”“失忆”“表现/真相”“历史/现实”这样的行为动机来构成表面的叙事线索。
一般让读者在读完整个故事后，能够在自己的脑海中补完一条连续的情节线出来，这个时候让叙事线淡化。


* 趣味三 故事的情节以设定来代替叙事

这个是关于情节构思方面的，即在构思的时候注重整理故事中的各个事件间的关联和关系，之间的影响以及是关于主题或话题的哪个方面的观点和视角。
并不一定要说情节就是构思发生的某个故事那样的，而是说情节本身是一种事实一种为了内容的需要而产生的一种设定。
文本故事性和趣味性可以通过叙事线来加强，而真正要讲述的故事本身是一多角度立体感的存在。


* 趣味四 人物的行为动机和人物间的影响

整个叙述过程之中，一直围绕着人物的自身行动的动机来展开，即由于人物自身的某种目的来进行行动来构成故事。
通常可以众多人物各自的行动都作为动机来推动叙事，并且人物之间的互动会使得各自的行动的动机发展并互相产生影响。
这种人物自身的动机的发展，是用来交代真正的情节线的一个很重要的手段，并且人物间的互动也是很主题之间相关的。


* 趣味五 叙事按照场景来划分，简化结构

按照场景来划分，每个场景有固定的发生的环境（固定的也可以是运动的，是整体即可），有场景参与的人物。
每个场景考虑交代了那些事实，又对叙事起到了怎样的推动作用，整个故事文本便通过这样若干场景以某种较为简单的结构构成。
本身已经已经在叙事线和情节线上够折腾的了，所以以场景构成的叙事线就一定要简单明了，并尽可能的简化。


* 趣味六 人物细腻的情感

故事的主题与话题是一方面，是作为文本的内容存在。而叙述的表现力是主要注重在人物的情感方面，包括人物对于自身，对于他人，对于现实，对于曾经所发生过的事情的看法观点态度情绪等等方面来作为故事所展现的风景的载体。


* 趣味七 世界观和历史观

整个故事的发生环境，简单的说就是非现实世界的日常故事。
即发生的环境可以是架空的，可以是科幻或奇幻，以及适合于适合于情节的在某种规则制约下的世界。不过就情节本身而言，要尽可能的呈现出一种属于日常的平平常常的故事那样的故事。
背景是明显虚构的，但是要让故事本身有种真实的在这个背景下发生着的样子，人物有各自的信仰和社会角色，而不是一个单薄的存在。
这个世界有其过去发生过去的事情，人们知道的事情，将来要面对的事情。每个人物也有过去的故事，这个过去的会成为他面对他人时的一个要素。
不同人物的过去现在以及未来都有交织的可能性，这种交织和发展，成为了故事的一个重要的叙事方式。
到底人物线怎么使用，是平行还是主次还是轮换还是其他的混合方式，这在实际运用中有发挥的余地。


* 趣味八 景色和对话

景色和对话都是很有表现力的情节叙述方式，不过要避免因为使用得不得当而造成地情节不明了或叙述的错乱。
景色和对话都是很适合让人物敞开心扉讲述属于他自己的故事的这样一种场景，用一种敞开心扉的态度来让人物和观众都作为一种读者的立场存在。
情节和对话也都是很容易用来推动情节的，侧重于用景色和对话来讲述真正的情节线即可。运用对话中的情绪和对话参与者间关于事实的互动来推动叙述。


* 趣味九 人物和读者的立场

让叙事线里的主角和读者都置于去获得整个故事的一种身份的这样一种一致的立场上。
明确在叙事之中考虑不同的人物各自找到什么以及读者知道什么，这样的信息与事实的传递会影响到整个故事的叙事过程中的每个人物（包括读者）的立场和动机。
当然不能限定死了读者的身份是怎样的，需要给读者自身存在感容纳和参与的众多余地。叙事线和情节线是一个方面，不过读者的整个阅读过程也是重要的体验与参与的过程，并同时有着旁观和亲历者的双重身份。这也是之前划分出单独的叙事线出来的一个理由所在。


* 趣味十 人物的性格刻画

这是需要的，很是需要的。有抽象的说是某类属性的人物，也有具体说是经历的哪些事情认识哪些人物以及对它们都有什么身份和态度来构成的一个人物。
不过性格特征明显一些的话人物就要容易辨认得多，这样也让情节的叙述明朗许多。
虽然个人很想在淡化情节和运用设定来展现情感方面寻找些许趣味，不过人物方面不小心就路人了的感觉。


* 趣味十一 节奏和音乐的氛围

其实就是指氛围了，在表面平淡的场景之中，有一种持续的氛围所笼罩，通常是抒情性的，还是不错的。


* 趣味十二 以故事来讲述对故事的看法

比如这里对于文本的趣味说了好些个人的喜好，其实这些喜好是可以通过一个具体的小说来展现出来，而不是这里通过文字的形式来说它是什么。
也就是说，故事文本是用来讲述对故事或者对于主题的一个多方面的审视的存在。既在以某种叙事方式讲述着一个故事，并同时以这样的一个故事表达着对于故事本身以及对于故事的叙述的方式的的一种看法。


* 趣味十三 故事的主题

这个通常老套一点就行了。比如成长友谊感情什么听起来乐观有趣鼓舞人心的的东西都可以。


* 趣味十四 短篇形式的篇幅

一个单独的完整的小故事即可，视角小些篇幅和情节都简化指留明了的主线相关物，然后故事也要有立体感。


* 其他的补充

看需要在补充吧。以上内容并没有好好的构思，只是想到什么然后就列为一点写下来了，也不知太片面或者考虑的不周全。
既然是作为一篇随手写写记录记录的东西，自己明知要改动的话可以让内容在明了和完整些许吧。
不过这里仅仅是流水的记录，记录下当前先想到的一些趣味的可能性，然后就不再继续，就暂且写到这里了吧。


-----


叙述之间从高潮部分插入，既故事一开始就是某个事件正在高潮的部分。然后再把故事具体的展开。这样先尽可能把把故事涉及的话题的全貌展示出来，然后再具体地增加立体感。