Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse code

*** empty log message ***

  • Loading branch information...
commit ee36fac4ca4f41d80050f5ebbc58883d01c94b1b 1 parent ac062c9
authored November 22, 2008

Showing 2 changed files with 143 additions and 138 deletions. Show diff stats Hide diff stats

  1. 277  THOUGHTS
  2. 4  gimpmode.muse
277  THOUGHTS
... ...
@@ -1,136 +1,141 @@
1  
-
2  
-
3  
-* This is actually the first time I realised how a mixin might be what I need: 
4  
-
5  
-  You have an interactive, console-like buffer, and multiple source
6  
-  buffers in which to edit text. There is a plethora of commands,
7  
-  functions and variables that you'd like to make available in both
8  
-  modes.  Say we want some keys to perform certain actions in both
9  
-  modes, but the console mode is derived from - say - comint-mode and
10  
-  the text buffer mode is derived from lisp-mode.  
11  
-
12  
-add constants to font-locking
13  
-
14  
-step inside for breakpoints ... 
15  
-
16  
-need pattern matching I guess...
17  
-
18  
-lambda 
19  
-define
20  
-let
21  
-let*
22  
-letrec 
23  
-letrec*
24  
-define-macro
25  
-do
26  
-dolist
27  
-
28  
-(lambda ()
29  
-	.....)
30  
-==>
31  
-(db 
32  
-  (lambda ()
33  
-    (db-recurse ....)))
34  
-
35  
-
36  
-(define (fun args*)
37  
-  body*)
38  
-==>
39  
-(db (define (fun args*)
40  
-  (db-recurse body*)))
41  
-
42  
-(let loop? (())
43  
-     ...)
44  
-==>
45  
-(db (let loop (())
46  
-  (db-recurse body*)))
47  
-
48  
-(letrec (())
49  
-   body*)
50  
-==>
51  
-(db (letrec (())
52  
-  (db-recurse body*)))
53  
-
54  
-(do ((var init step)*)
55  
-    (test)
56  
-  (body))
57  
-==>
58  
-(db (do ((var (db-recurse init) (db-recurse step)) *)
59  
-    	((db-recurse test) (db result))
60  
-  (db-recurse body*)))
61  
-
62  
-
63  
-Actually, I do not think instructing beforehand is good, better do it
64  
-lazily: let fud-break give you the option to step inside, upon which
65  
-all immediate subforms that can handle it are instructed with a
66  
-fud-break spec.
67  
-
68  
-So, on fud-break + step-inside:
69  
-
70  
-(fud-break "" 
71  
-	   (let ((behold 1))
72  
-	   	1 (mapcar (lambda () ..) '(129 304)))) => 
73  
-
74  
-(let ((behold (fud-break "" 1)))
75  
-     (fud-break 1)	 
76  
-     (fud-break (mapcar (lambda () ..) '(129 304)))) ;lazy
77  
-
78  
-(define (fud-instruct sxp)
79  
-	 (mapcar 
80  
-	 (lambda (sxp)
81  
-	 	 )))
82  
-
83  
-
84  
-thus:
85  
-
86  
-(let ((in-let #f))
87  
-    (mapcar (lambda (th)
88  
-	      (cond ((memq th '(let))
89  
-		     (begin
90  
-		       (set! in-let #t)
91  
-		       th))
92  
-		    (in-let
93  
-		     (if (symbol? th) th
94  
-			 (begin
95  
-			   (set! in-let #f)
96  
-			   (mapcar (lambda (th)
97  
-				       (list (car th)
98  
-					     (fud-breakify (cadr th)))) th))))
99  
-		    (else
100  
-		     (fud-breakify th))))
101  
-	  '(let loop ((behold 4))
102  
-	     1
103  
-	     (mapcar (lambda (b) (+ n 19)) '(129 304)))))
104  
-
105  
-(define (fud-instruct-1 thunk)
106  
-  (let ((in-let #f)
107  
-	(in-lambda #f)
108  
-	(num 0))
109  
-    (mapcar (lambda (th)
110  
-	      (set! num (+ 1 num))
111  
-	      (cond ((and (= num 1)
112  
-			  (memq th '(let)))
113  
-		     (set! in-let #t)
114  
-		     th)
115  
-		    (in-let		;special let rule
116  
-		     (if (symbol? th) th
117  
-			 (begin
118  
-			   (set! in-let #f)
119  
-			   (mapcar (lambda (th)
120  
-				     (list (car th)
121  
-					   (fud-breakify (cadr th)))) th))))
122  
-		    ((and (= num 1)
123  
-			  (memq th '(lambda)))
124  
-		     (set! in-lambda #t)
125  
-		     'lambda)
126  
-		    (in-lambda		;simple lambda rule
127  
-		     (set! in-lambda #f)
128  
-		     th)
129  
-		    (else
130  
-		     (fud-breakify th))))
131  
-	    thunk)))
132  
-
133  
-ranking system for completions according to number of times chosen/being part of the
134  
-language.
135  
-
136  
-
  1
+
  2
+
  3
+* This is actually the first time I realised how a mixin might be what I need: 
  4
+
  5
+  You have an interactive, console-like buffer, and multiple source
  6
+  buffers in which to edit text. There is a plethora of commands,
  7
+  functions and variables that you'd like to make available in both
  8
+  modes.  Say we want some keys to perform certain actions in both
  9
+  modes, but the console mode is derived from - say - comint-mode and
  10
+  the text buffer mode is derived from lisp-mode.  
  11
+
  12
+
  13
+; (modify-coding-system-alist 'process "ypsilon" '(utf-8 . utf-8))
  14
+
  15
+  the text buffer mode is derived from lisp-mode.  
  16
+
  17
+add constants to font-locking
  18
+
  19
+step inside for breakpoints ... 
  20
+
  21
+need pattern matching I guess...
  22
+
  23
+lambda 
  24
+define
  25
+let
  26
+let*
  27
+letrec 
  28
+letrec*
  29
+define-macro
  30
+do
  31
+dolist
  32
+
  33
+(lambda ()
  34
+	.....)
  35
+==>
  36
+(db 
  37
+  (lambda ()
  38
+    (db-recurse ....)))
  39
+
  40
+
  41
+(define (fun args*)
  42
+  body*)
  43
+==>
  44
+(db (define (fun args*)
  45
+  (db-recurse body*)))
  46
+
  47
+(let loop? (())
  48
+     ...)
  49
+==>
  50
+(db (let loop (())
  51
+  (db-recurse body*)))
  52
+
  53
+(letrec (())
  54
+   body*)
  55
+==>
  56
+(db (letrec (())
  57
+  (db-recurse body*)))
  58
+
  59
+(do ((var init step)*)
  60
+    (test)
  61
+  (body))
  62
+==>
  63
+(db (do ((var (db-recurse init) (db-recurse step)) *)
  64
+    	((db-recurse test) (db result))
  65
+  (db-recurse body*)))
  66
+
  67
+
  68
+Actually, I do not think instructing beforehand is good, better do it
  69
+lazily: let fud-break give you the option to step inside, upon which
  70
+all immediate subforms that can handle it are instructed with a
  71
+fud-break spec.
  72
+
  73
+So, on fud-break + step-inside:
  74
+
  75
+(fud-break "" 
  76
+	   (let ((behold 1))
  77
+	   	1 (mapcar (lambda () ..) '(129 304)))) => 
  78
+
  79
+(let ((behold (fud-break "" 1)))
  80
+     (fud-break 1)	 
  81
+     (fud-break (mapcar (lambda () ..) '(129 304)))) ;lazy
  82
+
  83
+(define (fud-instruct sxp)
  84
+	 (mapcar 
  85
+	 (lambda (sxp)
  86
+	 	 )))
  87
+
  88
+
  89
+thus:
  90
+
  91
+(let ((in-let #f))
  92
+    (mapcar (lambda (th)
  93
+	      (cond ((memq th '(let))
  94
+		     (begin
  95
+		       (set! in-let #t)
  96
+		       th))
  97
+		    (in-let
  98
+		     (if (symbol? th) th
  99
+			 (begin
  100
+			   (set! in-let #f)
  101
+			   (mapcar (lambda (th)
  102
+				       (list (car th)
  103
+					     (fud-breakify (cadr th)))) th))))
  104
+		    (else
  105
+		     (fud-breakify th))))
  106
+	  '(let loop ((behold 4))
  107
+	     1
  108
+	     (mapcar (lambda (b) (+ n 19)) '(129 304)))))
  109
+
  110
+(define (fud-instruct-1 thunk)
  111
+  (let ((in-let #f)
  112
+	(in-lambda #f)
  113
+	(num 0))
  114
+    (mapcar (lambda (th)
  115
+	      (set! num (+ 1 num))
  116
+	      (cond ((and (= num 1)
  117
+			  (memq th '(let)))
  118
+		     (set! in-let #t)
  119
+		     th)
  120
+		    (in-let		;special let rule
  121
+		     (if (symbol? th) th
  122
+			 (begin
  123
+			   (set! in-let #f)
  124
+			   (mapcar (lambda (th)
  125
+				     (list (car th)
  126
+					   (fud-breakify (cadr th)))) th))))
  127
+		    ((and (= num 1)
  128
+			  (memq th '(lambda)))
  129
+		     (set! in-lambda #t)
  130
+		     'lambda)
  131
+		    (in-lambda		;simple lambda rule
  132
+		     (set! in-lambda #f)
  133
+		     th)
  134
+		    (else
  135
+		     (fud-breakify th))))
  136
+	    thunk)))
  137
+
  138
+ranking system for completions according to number of times chosen/being part of the
  139
+language.
  140
+
  141
+
4  gimpmode.muse
@@ -164,11 +164,11 @@ The features the client mode (as opposed to the truly inferior mode) currently l
164 164
  - tracing.
165 165
  - scheme functions =display=, =write= and any derivatives do not work. For these exact reasons, the FU Debugger does not work in this mode.
166 166
 
167  
-Note: behaviour when using both modes together is unspecified (what a lovely fall-back that word is...) and unsupported (although I do use it when developing the client mode the trick is to first run =M-x run-gimp=, start the server, and then run =M-x gimp-cl-connect=).
  167
+Note: behaviour when using both modes together is unspecified (what a lovely fall-back that word is...) and unsupported (although I do use it when developing the client mode. The trick is to first run =M-x run-gimp=, start the server, and then run =M-x gimp-cl-connect=).
168 168
 
169 169
 Note that on any system gimp-mode is perfectly capable of performing quite well `off-line', as it reads in most data through the use of caches. Stuff it cannot do unconnected (i.e. evaluation, and some echoing and completion that are dependent on evaluation) it will simply ignore. If not, that is a bug and should be filed as such (=M-x gimp-report-bug=).
170 170
 
171  
-2. I have not written many script-fu files to test this mode on, two wit: two, one of which is =emacs-interaction.scm=  that comes with Gimp Mode (for the curious: the [[http://registry.gimp.org/node/6226][other one]] makes a selection of sun rays).
  171
+2. I have not written many script-fu files to test this mode on, to wit: two, one of which is =emacs-interaction.scm=  that comes with Gimp Mode (for the curious: the [[http://registry.gimp.org/node/6226][other one]] makes a selection of sun rays).
172 172
 
173 173
 3. There is no way currently to recover from non-returning forms, such an infinite loop, save for killing the process altogether.  I'd love to find a way to deal with this.  In this regard, the client mode is the better choice, as you are able to spawn several servers and just re-connect from emacs.
174 174
 

0 notes on commit ee36fac

Please sign in to comment.
Something went wrong with that request. Please try again.