Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

*** empty log message ***

  • Loading branch information...
commit ee36fac4ca4f41d80050f5ebbc58883d01c94b1b 1 parent ac062c9
sharik authored
Showing with 143 additions and 138 deletions.
  1. +141 −136 THOUGHTS
  2. +2 −2 gimpmode.muse
View
277 THOUGHTS
@@ -1,136 +1,141 @@
-
-
-* This is actually the first time I realised how a mixin might be what I need:
-
- You have an interactive, console-like buffer, and multiple source
- buffers in which to edit text. There is a plethora of commands,
- functions and variables that you'd like to make available in both
- modes. Say we want some keys to perform certain actions in both
- modes, but the console mode is derived from - say - comint-mode and
- the text buffer mode is derived from lisp-mode.
-
-add constants to font-locking
-
-step inside for breakpoints ...
-
-need pattern matching I guess...
-
-lambda
-define
-let
-let*
-letrec
-letrec*
-define-macro
-do
-dolist
-
-(lambda ()
- .....)
-==>
-(db
- (lambda ()
- (db-recurse ....)))
-
-
-(define (fun args*)
- body*)
-==>
-(db (define (fun args*)
- (db-recurse body*)))
-
-(let loop? (())
- ...)
-==>
-(db (let loop (())
- (db-recurse body*)))
-
-(letrec (())
- body*)
-==>
-(db (letrec (())
- (db-recurse body*)))
-
-(do ((var init step)*)
- (test)
- (body))
-==>
-(db (do ((var (db-recurse init) (db-recurse step)) *)
- ((db-recurse test) (db result))
- (db-recurse body*)))
-
-
-Actually, I do not think instructing beforehand is good, better do it
-lazily: let fud-break give you the option to step inside, upon which
-all immediate subforms that can handle it are instructed with a
-fud-break spec.
-
-So, on fud-break + step-inside:
-
-(fud-break ""
- (let ((behold 1))
- 1 (mapcar (lambda () ..) '(129 304)))) =>
-
-(let ((behold (fud-break "" 1)))
- (fud-break 1)
- (fud-break (mapcar (lambda () ..) '(129 304)))) ;lazy
-
-(define (fud-instruct sxp)
- (mapcar
- (lambda (sxp)
- )))
-
-
-thus:
-
-(let ((in-let #f))
- (mapcar (lambda (th)
- (cond ((memq th '(let))
- (begin
- (set! in-let #t)
- th))
- (in-let
- (if (symbol? th) th
- (begin
- (set! in-let #f)
- (mapcar (lambda (th)
- (list (car th)
- (fud-breakify (cadr th)))) th))))
- (else
- (fud-breakify th))))
- '(let loop ((behold 4))
- 1
- (mapcar (lambda (b) (+ n 19)) '(129 304)))))
-
-(define (fud-instruct-1 thunk)
- (let ((in-let #f)
- (in-lambda #f)
- (num 0))
- (mapcar (lambda (th)
- (set! num (+ 1 num))
- (cond ((and (= num 1)
- (memq th '(let)))
- (set! in-let #t)
- th)
- (in-let ;special let rule
- (if (symbol? th) th
- (begin
- (set! in-let #f)
- (mapcar (lambda (th)
- (list (car th)
- (fud-breakify (cadr th)))) th))))
- ((and (= num 1)
- (memq th '(lambda)))
- (set! in-lambda #t)
- 'lambda)
- (in-lambda ;simple lambda rule
- (set! in-lambda #f)
- th)
- (else
- (fud-breakify th))))
- thunk)))
-
-ranking system for completions according to number of times chosen/being part of the
-language.
-
-
+
+
+* This is actually the first time I realised how a mixin might be what I need:
+
+ You have an interactive, console-like buffer, and multiple source
+ buffers in which to edit text. There is a plethora of commands,
+ functions and variables that you'd like to make available in both
+ modes. Say we want some keys to perform certain actions in both
+ modes, but the console mode is derived from - say - comint-mode and
+ the text buffer mode is derived from lisp-mode.
+
+
+; (modify-coding-system-alist 'process "ypsilon" '(utf-8 . utf-8))
+
+ the text buffer mode is derived from lisp-mode.
+
+add constants to font-locking
+
+step inside for breakpoints ...
+
+need pattern matching I guess...
+
+lambda
+define
+let
+let*
+letrec
+letrec*
+define-macro
+do
+dolist
+
+(lambda ()
+ .....)
+==>
+(db
+ (lambda ()
+ (db-recurse ....)))
+
+
+(define (fun args*)
+ body*)
+==>
+(db (define (fun args*)
+ (db-recurse body*)))
+
+(let loop? (())
+ ...)
+==>
+(db (let loop (())
+ (db-recurse body*)))
+
+(letrec (())
+ body*)
+==>
+(db (letrec (())
+ (db-recurse body*)))
+
+(do ((var init step)*)
+ (test)
+ (body))
+==>
+(db (do ((var (db-recurse init) (db-recurse step)) *)
+ ((db-recurse test) (db result))
+ (db-recurse body*)))
+
+
+Actually, I do not think instructing beforehand is good, better do it
+lazily: let fud-break give you the option to step inside, upon which
+all immediate subforms that can handle it are instructed with a
+fud-break spec.
+
+So, on fud-break + step-inside:
+
+(fud-break ""
+ (let ((behold 1))
+ 1 (mapcar (lambda () ..) '(129 304)))) =>
+
+(let ((behold (fud-break "" 1)))
+ (fud-break 1)
+ (fud-break (mapcar (lambda () ..) '(129 304)))) ;lazy
+
+(define (fud-instruct sxp)
+ (mapcar
+ (lambda (sxp)
+ )))
+
+
+thus:
+
+(let ((in-let #f))
+ (mapcar (lambda (th)
+ (cond ((memq th '(let))
+ (begin
+ (set! in-let #t)
+ th))
+ (in-let
+ (if (symbol? th) th
+ (begin
+ (set! in-let #f)
+ (mapcar (lambda (th)
+ (list (car th)
+ (fud-breakify (cadr th)))) th))))
+ (else
+ (fud-breakify th))))
+ '(let loop ((behold 4))
+ 1
+ (mapcar (lambda (b) (+ n 19)) '(129 304)))))
+
+(define (fud-instruct-1 thunk)
+ (let ((in-let #f)
+ (in-lambda #f)
+ (num 0))
+ (mapcar (lambda (th)
+ (set! num (+ 1 num))
+ (cond ((and (= num 1)
+ (memq th '(let)))
+ (set! in-let #t)
+ th)
+ (in-let ;special let rule
+ (if (symbol? th) th
+ (begin
+ (set! in-let #f)
+ (mapcar (lambda (th)
+ (list (car th)
+ (fud-breakify (cadr th)))) th))))
+ ((and (= num 1)
+ (memq th '(lambda)))
+ (set! in-lambda #t)
+ 'lambda)
+ (in-lambda ;simple lambda rule
+ (set! in-lambda #f)
+ th)
+ (else
+ (fud-breakify th))))
+ thunk)))
+
+ranking system for completions according to number of times chosen/being part of the
+language.
+
+
View
4 gimpmode.muse
@@ -164,11 +164,11 @@ The features the client mode (as opposed to the truly inferior mode) currently l
- tracing.
- scheme functions =display=, =write= and any derivatives do not work. For these exact reasons, the FU Debugger does not work in this mode.
-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=).
+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=).
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=).
-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).
+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).
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.
Please sign in to comment.
Something went wrong with that request. Please try again.