Re: beginner el form

Re: beginner el form

[Johan Bockgård]

Adam <nospam@example.com> writes:

> I am looking for a file in which I can incrementally create an
> emacs-lisp program, will much trial and error, where screes of text
> can be printed as a result if necessary, and the minibuffer is just
> not big enough.

C-u C-x C-e inserts the result in the buffer.

You may also want to try M-x ielm.

-- 
Johan Bockgård

Re: beginner el form

[B.T. Raven]

"Adam" <nospam@example.com> wrote in message
news:d2pp0t$ven$1@lust.ihug.co.nz...
>
> At the top of the "Programming in Emacs Lisp", before and around the
section
> Practicing Evaluation, examples are given for the novice to evaluate
by c-x
> c-e.  And this does produce the result in the minibuffer or echo
section
> below.
>
> My question is, How should create a buffer in which the results will
be
> echoed in the buffer, like in a lisp-evaluation-mode ?
>
> In particular, what extension whould this file/buffer be called.
Presumeably
> name.el where expressions are evaluated by highlighted and evaluated
by c-x
> c-e  but then doesn't this required the major-mode to be changed every
time
> the file/buffer is opened ?
>
> I am looking for a file in which I can incrementally create an
emacs-lisp
> program, will much trial and error, where screes of text can be
printed as
> a result if necessary, and the minibuffer is just not big enough.
>
> Now, if some setup *---interactive-mode---* stuff could be included at
the
> top of that buffer, then that would be ideal. Perhaps it is an
> "self-evaluating form" that I really need.
>
> Any suggestions or comments appreciate.
>
>

I assume that you know that the **scratch** buffer  is set up
automatically in lisp interaction mode. You can convert any buffer to
this mode by simply invoking M-x lisp-interaction-mode while in the
buffer. I think you could make this your default mode by putting
 '(default-major-mode (quote lisp-interaction-mode))
into your .emacs with Options>Customize>Specific Option, etc.

Ed

Re: beginner el form

[Steinar Børmer]

Adam wrote:

| I am looking for a file in which I can incrementally create an
| emacs-lisp program, will much trial and error, where screes of text
| can be printed as a result if necessary, and the minibuffer is just
| not big enough.
| 
| Now, if some setup *---interactive-mode---* stuff could be included at
| the top of that buffer, then that would be ideal. Perhaps it is an
| "self-evaluating form" that I really need.

The *scratch* buffer is ideal for this.  Simply write, and when point is
at the end of a sexp, press `C-j' and the whole thing is evaluated in
the same buffer.

-- 
SB

Re: beginner el form

[Thien-Thi Nguyen]

Adam <nospam@example.com> writes:

> I was just looking for a file that would switch into
> that mode when loaded.  And thought that could be
> done by an entry in the top few lines.

create a file ~/tmp/play (for example) w/ the contents:

  ;;; -*-lisp-interaction-*-

then kill that buffer and C-x C-f the file normally.
it should be in lisp interaction mode.

see also: local variables, major modes, variable
`auto-mode-alist', command `eval-expression'.

thi

Re: beginner el form

[Albert Reiner]

[Thien-Thi Nguyen <ttn@glug.org>, Mon, 04 Apr 2005 10:04:54 +0200]:
> create a file ~/tmp/play (for example) w/ the contents:
> 
>   ;;; -*-lisp-interaction-*-
> 
> then kill that buffer and C-x C-f the file normally.

or use M-x normal-mode RET

Albert.

beginner el form

[Adam]

At the top of the "Programming in Emacs Lisp", before and around the section
Practicing Evaluation, examples are given for the novice to evaluate by c-x
c-e.  And this does produce the result in the minibuffer or echo section
below. 

My question is, How should create a buffer in which the results will be
echoed in the buffer, like in a lisp-evaluation-mode ? 

In particular, what extension whould this file/buffer be called. Presumeably
name.el where expressions are evaluated by highlighted and evaluated by c-x
c-e  but then doesn't this required the major-mode to be changed every time
the file/buffer is opened ? 

I am looking for a file in which I can incrementally create an emacs-lisp
program, will much trial and error, where screes of text can be printed as
a result if necessary, and the minibuffer is just not big enough. 

Now, if some setup *---interactive-mode---* stuff could be included at the
top of that buffer, then that would be ideal. Perhaps it is an
"self-evaluating form" that I really need. 

Any suggestions or comments appreciate. 

Re: beginner el form

[Adam]

Thanks folks.  I've settled on a file with the .el extension, and in
lisp-interaction-mode. 

I was just looking for a file that would switch into that mode when loaded.
And thought that could be done by an entry in the top few lines. 

Still, we are up and running. 

Thanks again. 

Re: beginner el form

[Adam]

thanks Thi and Albert. 

Its slow for a novice learning to program in emacs-lisp.

So I have a big page for various forms, and intend to combine them into the
final big program. The Reference manual and Introduction are both good. c-j
is good. The backtrace error still a little baffling - but am enjoying it. 

A. 

Re: beginner el form

[Alan Wehmann]

You should have a *scratch* buffer automatically present.  That is in
the proper mode.

Adam <nospam@example.com> writes:

> At the top of the "Programming in Emacs Lisp", before and around the section
> Practicing Evaluation, examples are given for the novice to evaluate by c-x
> c-e.  And this does produce the result in the minibuffer or echo section
> below. 
>
> My question is, How should create a buffer in which the results will be
> echoed in the buffer, like in a lisp-evaluation-mode ? 
>
> In particular, what extension whould this file/buffer be called. Presumeably
> name.el where expressions are evaluated by highlighted and evaluated by c-x
> c-e  but then doesn't this required the major-mode to be changed every time
> the file/buffer is opened ? 
>
> I am looking for a file in which I can incrementally create an emacs-lisp
> program, will much trial and error, where screes of text can be printed as
> a result if necessary, and the minibuffer is just not big enough. 
>
> Now, if some setup *---interactive-mode---* stuff could be included at the
> top of that buffer, then that would be ideal. Perhaps it is an
> "self-evaluating form" that I really need. 
>
> Any suggestions or comments appreciate. 
>
>

-- 
Alan Wehmann
wehmann(nospam)@fnal.gov

Re: beginner el form

[Thien-Thi Nguyen]

Alan Wehmann <wehmann@fnal.gov> writes:

> You should have a *scratch* buffer automatically present.
> That is in the proper mode.

another way is to explictly create one:

C-x b hack RET
M-x lisp-interaction-mode RET

for example, below is some code that bundles this approach
in a convenient (and sometimes cathartic ;-) command.

thi

______________________________________
;;; give-me-a-scratch-buffer-now.el
;;;
;;; Rel:v-1-51
;;;
;;; Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,2004 Thien-Thi Nguyen
;;; This file is part of ttn's personal elisp library, released under GNU
;;; GPL with ABSOLUTELY NO WARRANTY.  See the file COPYING for details.

;;; Description: Find *scratch* buffer; put it in lisp-interaction-mode.
;;; Prefix arg guarantees new buffer.

;;;###autoload
(defun give-me-a-scratch-buffer-now (want-new)
  "Bring up *scratch* or younger siblings if prefixed."
  (interactive "P")

  (switch-to-buffer
   (if want-new
       (generate-new-buffer "*scratch*")
     "*scratch*"))
  (lisp-interaction-mode))

(provide 'give-me-a-scratch-buffer-now)

;;; give-me-a-scratch-buffer-now.el ends here

Re: beginner el form

[Thien-Thi Nguyen]

Adam <nospam@example.com> writes:

> If anyone has any better suggestions, for a novice tinkering
> away, they would be welcome.  Gleaning meaningful info from the
> debugger would seem to be a candidate for a newbie lesson.

probably the best suggestion is to accept and enjoy the state of
perpetual noviceness.  true, it is fun to get old and cranky but
it's also fun to get old and crazy.  you can't get crazy if you
know everything (or think you know everything ;-).

thi

Re: beginner el form

[Adam]

Yep. This originally was for an Elisp novice, to start putting together
components that could be cut+yanked and evaluated in part - in the one
buffer. Eventually "putting it all together" into the final form. 

As a novice - a little trial and error goes in to auditioning the various
functions. And much lookup in the Lisp manual. So, variously-working forms
sit side-by-side with better working ones, as we scratch our head and try
again. 

If anyone has any better suggestions, for a novice tinkering away, they
would be welcome.  Gleaning meaningful info from the debugger would seem to
be a candidate for a newbie lesson. 




Thien-Thi Nguyen wrote:

> Alan Wehmann <wehmann@fnal.gov> writes:
> 
>> You should have a *scratch* buffer automatically present.
>> That is in the proper mode.
> 
> another way is to explictly create one:
> 
> C-x b hack RET
> M-x lisp-interaction-mode RET
> 
> for example, below is some code that bundles this approach
> in a convenient (and sometimes cathartic ;-) command.
> 
[ ... ]

Re: beginner el form

[Tim X]

Adam <nospam@example.com> writes:

> Yep. This originally was for an Elisp novice, to start putting together
> components that could be cut+yanked and evaluated in part - in the one
> buffer. Eventually "putting it all together" into the final form. 
>
> As a novice - a little trial and error goes in to auditioning the various
> functions. And much lookup in the Lisp manual. So, variously-working forms
> sit side-by-side with better working ones, as we scratch our head and try
> again. 
>
> If anyone has any better suggestions, for a novice tinkering away, they
> would be welcome.  Gleaning meaningful info from the debugger would seem to
> be a candidate for a newbie lesson. 
>
>
Others have mentioned the scratch buffer and lisp interaction
mode. Another tool which is quite useful for beginners is ielm

,----[ C-h f ielm RET ]
| ielm is an interactive compiled Lisp function in `ielm'.
| (ielm)
| 
| Interactively evaluate Emacs Lisp expressions.
| Switches to the buffer `*ielm*', or creates it if it does not exist.
`----

Tim

-- 
Tim Cross
The e-mail address on this message is FALSE (obviously!). My real e-mail is
to a company in Australia called rapttech and my login is tcross - if you 
really need to send mail, you should be able to work it out!

Re: beginner el form

[Joe Corneli]

I (independently) wrote something called scrat.el that does
essentially what Thi's suggested code does, but just a little
different. (Its useful, but a little revision is pending to make it
more useful.)  Why blather about it?  To show you that this is a
pretty "universal" approach.

I don't have any "better suggestions" than tinkering with your code,
but one additional suggestion is the trace mechanism, which can be a
useful supplement to edebug.  I've recently found it helpful to trace
all the functions in a buffer (see trace-all.el).  I guess this also
implies the standard "break your functions up into smaller functions."

Re: beginner el form

[Tim X]

Adam <nospam@example.com> writes:

> Thi, I think I agree. 
>
> As an elisp novice, I'm dropping into it from time to time, and making
> progress with the elisp manual and introduction. Am spending most of my
> other time calling cmucl as a listener with c-x l and c-x c-e. The cmucl
> documentation is good, so am having fun. 
>
> The elisp and emacs learning curves are both steady, seems no way around
> that but for further quiet clicking away and reading. Or probably getting
> serious about a bigger but finite application. I know that I'm not getting
> any younger, so whether crazyness or crankiness manifests itself
> first . . . 
>
> Meantime I'm happy with emacs and cmucl, and am starting to "get" elisp. So
> thanks to all here on this rather civilized newsgroup. 
>
If your interested in Lisp as well as elisp, then you should also
check out SLIME, which I find to be a great lisp mode for emacs. Also,
for a good introductory book on Lisp, I'd highly recommend Practical
common Lisp by Peter Siebel. You can purchase the book, but its also
on-line at http://www.gigamonkeys.com/book/

Tim
-- 
Tim Cross
The e-mail address on this message is FALSE (obviously!). My real e-mail is
to a company in Australia called rapttech and my login is tcross - if you 
really need to send mail, you should be able to work it out!

Re: beginner el form

[Thien-Thi Nguyen]

Adam <nospam@example.com> writes:

> and no C-j. 

here is a (still incomplete) tutorial that uses `C-j':

http://www.glug.org/people/ttn/software/elisp-tutorial/

if you are feeling adventurous, you can infer where future tutorial
lessons will proceed from studying the tail end of gnugo.el:

http://www.glug.org/people/ttn/software/personal-elisp/standalone/

emacs (under vms) is kicking my ass at the moment (errant QIO and
AST faults) otherwise i'd be working on the tutorial.  the hope is
to get lesson04.el out sometime this year, M-x if-all-goes-well...

happy hacking,
thi

Re: beginner el form

[Adam]

Thi, I think I agree. 

As an elisp novice, I'm dropping into it from time to time, and making
progress with the elisp manual and introduction. Am spending most of my
other time calling cmucl as a listener with c-x l and c-x c-e. The cmucl
documentation is good, so am having fun. 

The elisp and emacs learning curves are both steady, seems no way around
that but for further quiet clicking away and reading. Or probably getting
serious about a bigger but finite application. I know that I'm not getting
any younger, so whether crazyness or crankiness manifests itself
first . . . 

Meantime I'm happy with emacs and cmucl, and am starting to "get" elisp. So
thanks to all here on this rather civilized newsgroup. 


Joe Corneli wrote:

> I (independently) wrote something called scrat.el that does
> essentially what Thi's suggested code does, but just a little
> different. (Its useful, but a little revision is pending to make it
> more useful.)  Why blather about it?  To show you that this is a
> pretty "universal" approach.

Novices are a little uncertain when starting off. The initial "scratch
buffer" appears as a temporary workspace. Saving as .. only then implies
some work has started. The initial scratch buffer is not the traditional
Hello World, although it can be.   

The FSF "An Introduction to Introduction Programming in Emacs Lisp" by
Robert Chassell uses C-x C-e exclusively, and no C-j. 

> I don't have any "better suggestions" than tinkering with your code,
> but one additional suggestion is the trace mechanism, which can be a
> useful supplement to edebug.  I've recently found it helpful to trace
> all the functions in a buffer (see trace-all.el).  I guess this also
> implies the standard "break your functions up into smaller functions."

Between my new cmucl experience, and the modes and () error checking of
emacs, this novice is making some progress. So thank you for all comments. 

A. 

Re: beginner el form

[Phillip Lord]

>>>>> "Adam" == Adam  <nospam@example.com> writes:

  Adam> As an elisp novice, I'm dropping into it from time to time,
  Adam> and making progress with the elisp manual and introduction. Am
  Adam> spending most of my other time calling cmucl as a listener
  Adam> with c-x l and c-x c-e. The cmucl documentation is good, so am
  Adam> having fun.


My advice is learn to use the debugger (edebug) straight away if you
have not already done so. I normally write lisp into a .el file,
evaluating and debugging as I go. The use of edebug is great and saves
an awful lot of test evaluation, as you can generally see what is
wrong pretty quickly. 

Cheers

Phil

Re: beginner el form

[Phillip Lord]

>>>>> "Adam" == Adam  <nospam@example.com> writes:

  Adam> Thanks Phil. All input-contributions welcome.

  Adam> I will look into edebug, its new to me. And sounds a little
  Adam> like the gdb thing for C that is so successful to this very
  Adam> day.


If you use gdb from within emacs, it's extremely likely. 

I don't use most of the functionality in edebug. Pretty much just the
step through, but I've found this to be enough for quite complex
debugging. 

Perhaps I should learn more of it, sometime. 

Cheers

Phil

Re: beginner el form

[Adam]

Thanks Phil. All input-contributions welcome. 

I will look into edebug, its new to me. And sounds a little like the gdb
thing for C that is so successful to this very day. 

So thanks for the tip,   Adam.  

>   Adam> As an elisp novice, I'm dropping into it from time to time,
>   Adam> and making progress with the elisp manual and introduction. Am
>   Adam> spending most of my other time calling cmucl as a listener
>   Adam> with c-x l and c-x c-e. The cmucl documentation is good, so am
>   Adam> having fun.
> 
> My advice is learn to use the debugger (edebug) straight away if you
> have not already done so. I normally write lisp into a .el file,
> evaluating and debugging as I go. The use of edebug is great and saves
> an awful lot of test evaluation, as you can generally see what is
> wrong pretty quickly.
> 
> Cheers
> 
> Phil