<Xach>
earl-ducaine: it's possible (though depends on your situation) that a read macro could cause the problem.
<Xach>
it sounds like a missing ) to me.
<Xach>
For example: (read-from-string "(1 2" nil :eof) => error
<Xach>
EOF error, in fact
je4i has joined #lisp
<earl-ducaine>
Xach: Hmmm, interesting. I am doing something a bit hairy. I'm catching missing package and symbol errors, fishing them out of the condition, and then restarting the read from the top of the file.
<Xach>
the READ-LIST in the stack trace is what suggests it strongly to me.
<earl-ducaine>
Xach: so, lot of opportunities to for exactly that type of error. Thanks!
clothespin__ has joined #lisp
clothespin has quit [Read error: Connection reset by peer]
Lord_of_Life_ has joined #lisp
clothespin has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
clothespin__ has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<earl-ducaine>
Xach: I can confirm. You were exactly right: missing right parentheses.
scymtym has quit [Remote host closed the connection]
scymtym has joined #lisp
Fare has joined #lisp
<Bike>
huh, i see, "Eof-value is returned if eof-error-p is false and end of file is reached before the beginning of an object."
<Bike>
so if you're in the middle of an object you still get the error
<Bike>
oh, says it in "exceptional situations" to, about this exact situation
oxum has quit [Ping timeout: 258 seconds]
shka_ has quit [Quit: Konversation terminated!]
<pjb>
Bike: yep. Some code review is in order…
AnimalCl` has quit [Ping timeout: 258 seconds]
Lycurgus has quit [Quit: Exeunt]
EvW has quit [Ping timeout: 245 seconds]
oxum has joined #lisp
raghavgururajan has joined #lisp
lavaflow has quit [Ping timeout: 258 seconds]
jonatack has joined #lisp
shka_ has joined #lisp
shangul has joined #lisp
Kundry_Wag has joined #lisp
AnimalCl` has joined #lisp
jonatack_ has joined #lisp
jonatack has quit [Ping timeout: 268 seconds]
AnimalCl` has quit [Ping timeout: 258 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
oxum has quit [Ping timeout: 260 seconds]
raghavgururajan has quit [Read error: Connection reset by peer]
shangul has quit [Ping timeout: 260 seconds]
fookara has quit [Remote host closed the connection]
william1_ has quit [Ping timeout: 260 seconds]
Fare has quit [Ping timeout: 265 seconds]
bl0rpy has joined #lisp
bl0rpy has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
lucasb has quit [Quit: Connection closed for inactivity]
oxum has joined #lisp
Fare has joined #lisp
jonatack_ has quit [Read error: Connection reset by peer]
misterwhatever has joined #lisp
brown121407 has joined #lisp
bitmapper has joined #lisp
brown121408 has quit [Ping timeout: 260 seconds]
EvW1 has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
oxum has quit [Remote host closed the connection]
jmercouris has joined #lisp
oxum has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
AnimalCl` has joined #lisp
oxum has quit [Ping timeout: 260 seconds]
wsinatra has quit [Quit: WeeChat 2.7]
random-nick has quit [Ping timeout: 258 seconds]
AnimalCl` has quit [Ping timeout: 260 seconds]
jonatack_ has joined #lisp
kscarlet has joined #lisp
oxum has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Fare has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
dddddd has joined #lisp
misterwhatever has quit [Quit: misterwhatever]
oxum has quit [Ping timeout: 265 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
jackhill has quit [Ping timeout: 246 seconds]
jackhill has joined #lisp
random-nick has joined #lisp
Fare has joined #lisp
wheelsucker has quit [Remote host closed the connection]
jmercouris has quit [Ping timeout: 260 seconds]
trebor_home has joined #lisp
Fare has quit [Ping timeout: 268 seconds]
AnimalCl` has joined #lisp
raghavgururajan has joined #lisp
oxum has joined #lisp
gabiruh has joined #lisp
bitmapper has quit []
Fare has joined #lisp
hdasch has joined #lisp
shangul has joined #lisp
terpri has joined #lisp
AnimalCl` has quit [Read error: Connection reset by peer]
AnimalCl` has joined #lisp
AnimalCl` has quit [Read error: Connection reset by peer]
AnimalCl` has joined #lisp
remexre has joined #lisp
EvW1 has quit [Ping timeout: 248 seconds]
jonatack_ has quit [Quit: jonatack_]
jonatack has joined #lisp
AnimalCl` has quit [Ping timeout: 240 seconds]
oxum has quit [Ping timeout: 240 seconds]
Fare has quit [Ping timeout: 258 seconds]
X-Scale has quit [Ping timeout: 250 seconds]
Lycurgus has joined #lisp
EvW has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
wsinatra has joined #lisp
nika has quit []
clothespin has quit [Ping timeout: 260 seconds]
oxford has joined #lisp
AnimalCl` has joined #lisp
brettgilio has quit [Quit: Quit]
brettgilio has joined #lisp
oxum has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
AnimalCl` has quit [Ping timeout: 260 seconds]
brown121408 has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
slyrus has joined #lisp
Lycurgus has quit [Quit: Exeunt]
count3rmeasure has quit [Remote host closed the connection]
buffergn0me has joined #lisp
Kundry_Wag has joined #lisp
sloanr has joined #lisp
hiroaki_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
clothespin_ has joined #lisp
<drmeister>
Folks - are there any quicklisp systems that define their own READTABLE class? I know of ECLECTOR - but are there any others?
<phoe>
One would need to implement their own reader to implement their own readtables, especially since you can't portably subclass the class CL:READTABLE.
<phoe>
So I'd bet at least $3 that, no, there are none, or at least none in widespread use.
ggole has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
<drmeister>
Ok, thank you.
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_W_ has joined #lisp
AnimalCl` has joined #lisp
<drmeister>
I agree with you - I just thought I would toss the question out there.
* phoe
doubles his bet to $6.
<drmeister>
We need to be able to support eclector readtables from within clasp's C++ code and if I'm going to do that I want to be able do it more generally if necessary.
<drmeister>
But it doesn't look like it is necessary.
<phoe>
Likely unnecessary. You'd need to support madmen who launch into the unknown seas to implement their own portable Lisp reader.
<drmeister>
My kinda madpersons.
<phoe>
Mad, as in, it's not like eclector doesn't exist now.
<phoe>
drmeister: your question implies the inevitable existence of TRIVIAL-LISP-READER that abstracts over various Lisp readers available - the implementation-defined one, eclector, and then the hypothetical new portable one.
<phoe>
And these are dangerous thoughts, I tell ya.
oxum has quit [Ping timeout: 268 seconds]
<Bike>
could just elevate the protocl part of eclector into a standard package, like gray and sequence
<Bike>
it pretty much covers everything
<phoe>
see, I told you these are dangerous thoughts
<drmeister>
Hail Cthulhu!
<phoe>
now we're going to have as many Lisp readers as we have unit test frameworks
<Bike>
well we already have like one per implementation.
<phoe>
Bike: I mean portable librarified ones
<phoe>
...and we're likely going to create another three or four test frameworks to test these portable readers
<Bike>
there aren't librarified version of gray or sequence, are there?
<Bike>
like in terms of implementing streams themselves...
<phoe>
well, hm
<phoe>
sequences are hard to define portably without direct support from the implementation
<phoe>
same with streams
<phoe>
the Lisp reader is somewhat different as it can be "bolted on" to the rest of the system as a library, not unlike LOOP or FORMAT
oxum has joined #lisp
<phoe>
obviously it greatly complicates compilation and such so no one does that, but in theory one can think of a reader as a library - that's the foundation of eclector
EvW has quit [Ping timeout: 245 seconds]
<Bike>
sure.
<Bike>
we might have modules in the language. imagine
* phoe
grabs a shovel to dig #'REQUIRE and #'PROVIDE back out of their grave
<Bike>
i mean, there's not much reason to implement your own reader if there's already a protocol, tho.
<Bike>
it's like implementing your own version of FIND or something
<Bike>
i can think of reasons you'd want to, but they're hardly common
<phoe>
ayup
<phoe>
the usual reason I can imagine is where the implementation-provided one is deficient in some way, such as extensibility or what not
<drmeister>
Bike: You just added seqPackage.* files to clasp - right?
<Bike>
yes.
<phoe>
but #'FIND is kinda well defined and pretty simple
<Bike>
the reader is also well defined. the algorithm is laid out in the standard in nauseating detail.
<drmeister>
Ok. Adding three new files for one package is annoying me. Ah - the sins of my youth coming back to haunt me.
<Bike>
i think only one of the headers was actually necessary. the other one's blank.
<Bike>
like, basically blank
<White_Flame>
of course, the implementation-provided versions of FIND et al can also optimize to the :test, :key etc parameters easier than doing it yourself
<drmeister>
The reader algorithm was the first thing that I implemented in clasp. It was a long train trip from Boston to Philadelphia and I sketched the state machine diagram...
cosimone has joined #lisp
oxum has quit [Ping timeout: 260 seconds]
gravicappa has quit [Ping timeout: 260 seconds]
cosimone has quit [Client Quit]
AnimalCl` has quit [Ping timeout: 260 seconds]
sloanr has quit [Quit: sloanr]
sloanr has joined #lisp
sloanr1 has joined #lisp
sloanr has quit [Ping timeout: 265 seconds]
Kundry_W_ has quit [Remote host closed the connection]
sloanr has joined #lisp
Kundry_Wag has joined #lisp
sloanr2 has joined #lisp
sloanr1 has quit [Ping timeout: 260 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
sloanr2 is now known as sloanr1
sloanr has quit [Ping timeout: 260 seconds]
sloanr1 is now known as sloanr
Kundry_Wag has quit [Ping timeout: 260 seconds]
Lycurgus has joined #lisp
buffergn0me has quit [Ping timeout: 260 seconds]
bitmapper has joined #lisp
buffergn0me has joined #lisp
johnjay has joined #lisp
AnimalCl` has joined #lisp
Krystof has quit [Ping timeout: 250 seconds]
Krystof has joined #lisp
AnimalCl` has quit [Read error: Connection reset by peer]
AnimalCl` has joined #lisp
sloanr has quit [Quit: sloanr]
sloanr has joined #lisp
sloanr1 has joined #lisp
cosimone has joined #lisp
X-Scale has joined #lisp
buffergn0me has quit [Ping timeout: 260 seconds]
sloanr has quit [Ping timeout: 260 seconds]
sloanr1 is now known as sloanr
Guest73624 has quit [Changing host]
Guest73624 has joined #lisp
AnimalCl` has quit [Ping timeout: 268 seconds]
clothespin_ has quit [Ping timeout: 252 seconds]
madage has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
pfdietz has joined #lisp
AnimalCl` has joined #lisp
mathrick has quit [Ping timeout: 268 seconds]
oxum has joined #lisp
terpri has quit [Quit: Leaving]
AnimalCl` has quit [Ping timeout: 268 seconds]
<markasoftware>
when making my own "language" in lisp, is the normal way to define some (parse) function that uses (macrolet) to define a whole bunch of macros then just execute the &body statements?
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
<markasoftware>
(admittedly, parse is not the right name)
madage has joined #lisp
ahungry has joined #lisp
grobe0ba_ is now known as grobe0ba
Kundry_Wag has quit [Remote host closed the connection]
grobe0ba has quit [Ping timeout: 250 seconds]
<aeth>
markasoftware: Use destructuring-bind if you can get away with it. This encourages using plist tails and parsing with &key. A hypothetical easy-to-parse LOOP would look like this: (do-loop (:for i :from 1 :to 10) (:do (print i)))
<aeth>
markasoftware: Notice how '(:for i :from 1 :to 10) is easier to parse than loop's ":for i :from 1 :to 10" or "for i from 1 to 10" (it permits both)
<markasoftware>
ah, that would be a nice world to live in
<aeth>
This is because every symbol is a keyword so there's no need to intern, and the tail can be parsed with a plist.
<markasoftware>
thank!
grobe0ba has joined #lisp
<aeth>
s/with a plist/as a plist with &key in destructuring-bind/
raghavgururajan has quit [Read error: Connection reset by peer]
<aeth>
you're welcome
sloanr1 has joined #lisp
sloanr has quit [Ping timeout: 260 seconds]
sloanr has joined #lisp
slyrus_ has joined #lisp
sloanr1 has quit [Ping timeout: 258 seconds]
grobe0ba has quit [Read error: Connection reset by peer]
slyrus has quit [Ping timeout: 268 seconds]
grobe0ba has joined #lisp
<aeth>
in case I was unclear, in my example (:for i :from 1 :to 10) would be (i :from 1 :to 10) by the time the macro deals with it because it would determine which branch to enter based on the CAR (in this case, :for) and then it would be parsed with (destructuring-bind (variable &key from to ...) list ...)
<aeth>
e.g. (destructuring-bind (variable &key from to) `(i :from 1 :to 10) (values variable from to))
<aeth>
and pretty much all of the logic can go into functions as long as they're wrapped in EVAL-WHEN or in a separate file from the DEFMACRO, which helps to keep things simple
oxum has quit [Ping timeout: 260 seconds]
slyrus__ has joined #lisp
grobe0ba_ has joined #lisp
slyrus_ has quit [Ping timeout: 268 seconds]
AnimalCl` has joined #lisp
grobe0ba has quit [Ping timeout: 260 seconds]
grobe0ba_ is now known as grobe0ba
AnimalCl` has quit [Ping timeout: 265 seconds]
<pfdietz>
One thing I'd ask for in a macro: if E is a subform of a macro form M, then E should also occur in the macroexpansion of M. This is not always the case (ITERATE violates this).
<pfdietz>
By "subform" I mean a lisp form, something that is intended to be evaluated.
<aeth>
pfdietz: can you be more specific?
Kundry_Wag has joined #lisp
oxum has joined #lisp
earl-ducaine has quit [Ping timeout: 268 seconds]
<Bike>
seems like a pretty specific definition to me
lavaflow has joined #lisp
<Bike>
means you don't reconstruct forms or anything, which makes it harder to work out source info and probably other things
vlatkoB has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Quit: Exeunt]
FreeBirdLjj has joined #lisp
je4i has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
jackhill has quit [Quit: leaving]
ahungry has quit [Remote host closed the connection]
jackhill has joined #lisp
earl-ducaine has joined #lisp
earl-ducaine has quit [Client Quit]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
<phoe>
pfdietz: you mean Lisp forms that ITERATE treats as Lisp code, or Lisp forms that it treats as its clauses?
clothespin_ has joined #lisp
<phoe>
Because the latter aren't meant to be evaluated - they're just metadata for the iterator sprinkled all over the iteration body.
<phoe>
Alas, the former need to be reconstructed, even if just to remove all that aforementioned metadata.
<aeth>
Bike: sorry, that was poorly worded
<aeth>
pfdietz: where does ITERATE violate this?
<aeth>
I'm not really too aware of ITERATE's details
<LdBeth>
That’s why hygienic macro is invented
clothespin_ has quit [Ping timeout: 268 seconds]
oxum has quit [Ping timeout: 258 seconds]
<phoe>
LdBeth: is iterate unhygienic though?
<phoe>
I don't think it's an issue of accidental symbol shadowing
<LdBeth>
phoe: no, but hygienic macro can identify “keyword” and “expression”
<LdBeth>
My recommendation is avoid messing with symbol macros for parsing
oxum has joined #lisp
<phoe>
LdBeth: don't think that iterate is playing with symbol macros either
<pfdietz>
Hmm. I think I misremembered. ITERATE does allow the subforms to occur, but macroexpands some of them itself.
<LdBeth>
There’re some parsing libraries can parse lists
<pfdietz>
(in its walker)
<phoe>
I think it codewalks instead
clothespin__ has joined #lisp
<MichaelRaskin>
It codewalks, but in an a bit weird way
<LdBeth>
s symobol d
<pfdietz>
And that would be fine. What I wanted was to use the macroexpand hook to capture all the subforms of a form, to identify what form in the expansion each corresponds to.
<aeth>
I don't like codewalkers. They mess with refactoring things into helper functions. If you have to embed Lisp in a DSL, it should have one entry point and no exit point imo. So once you get into the Lisp code, the Lisp shouldn't be codewalked for the macro again. Sure, embed (+ 1 1) but then don't crawl through (+ 1 1) looking for (my-macro-again ...)
<pfdietz>
What iterate did do was break COVER (which plays a game of shadowing symbols like CL:IF with new versions COVER:IF, which ITERATE does not recognize.)
<aeth>
Imo, if you must do something like a codewalker, see if you can design your macro can be used recursively instead because then people who use lots of helper functions can still use it, no codewalker required.
<pfdietz>
AETH: I want code walkers for intrusive tooling, for example for coverage and mutation testing, not for use in deployed code.
<pfdietz>
This would be tooling one could apply to someone elses code.
oxum has quit [Ping timeout: 265 seconds]
<MichaelRaskin>
A lot of time, a macrolet would be enough instead of a true codewalker
<MichaelRaskin>
And even though codewalking is impossible to do perfectly, people often do it way worse than it should be done
<pfdietz>
Why is it impossible to do perfectly?
<pfdietz>
(I guess it depends on what you mean by "perfectly")
<pfdietz>
(and what you mean by codewalking)
<MichaelRaskin>
Well, whatever is enought to produce macroexpand-all
<pfdietz>
Ok, I don't understand why that's impossible.
pilne has quit [Quit: Light travels faster then sound, which is why some people appear bright, until you hear them speak]
vap1 has joined #lisp
pilne has joined #lisp
<MichaelRaskin>
Well, my definition of perfectness includes being able to start inside a lexical environment getting it as an &environment parameter of a macros
EvW has joined #lisp
cosimone has quit [Remote host closed the connection]
<MichaelRaskin>
And not using implementation-specific functions, because hu.dwim.walker already did that, and ended up bitrotting as implementations changed
cosimone has joined #lisp
<MichaelRaskin>
In that case there is a combination of weird macrolet forms that will fool the code walke
<pfdietz>
Ah. So the problem is that as you descend into macrolets and symbol-macrolets, you need to be able to consider those along with the environment you started with?
<MichaelRaskin>
Yes
vaporatorius has quit [Ping timeout: 265 seconds]
<pfdietz>
Why can't you just have your own env type, which has a field for that surrounding real env type? And write your own macroexpand-1 that works on that new env type (invoking cl:macroexpand-1 if it has to).
<MichaelRaskin>
Basically you are obliged to pass an updated environment to all the macro subforms,and if they expect something from the original environment with a name you cannot obtain, and something additionally defined in the code you have walked, there is a problem
<MichaelRaskin>
Because the macro you macroexpand-1 is in the end a function that expects a single environment parameter which can be passed to the implementation's macroexpand-1
<pfdietz>
Ah! You don't get to control which macroexpand-1 that macro function is called. Ok.
<pfdietz>
is calling
<MichaelRaskin>
Yes
<pfdietz>
It's not just the macroexpand-1 in the walker, it's the other calls to it out "in the world".
<MichaelRaskin>
On the other hand, this level of complexity is not what people like to debug, either
<pfdietz>
And I assume you also looked into getting around this with the macroexpand hook.
<MichaelRaskin>
Well, not for long
<MichaelRaskin>
I mean, you cannot guaranteed _anything_ about the hook's fate
<MichaelRaskin>
You expand one macros, and its macro-function completely reconfigures the hook
Guest73624 has quit [Read error: Connection reset by peer]
<pfdietz>
Ok.
Guest73624 has joined #lisp
<MichaelRaskin>
If your code walking needs are limited, you could offload the environment handling back to the compiler
<MichaelRaskin>
(Agnostic Lizard supports this mode)
AnimalCl` has joined #lisp
<MichaelRaskin>
But well, the problem with (non-implementation-version-tied) code walkers is that they typically do not reach the level where horrible macrolet/macroexpand juggling breaks them
<MichaelRaskin>
Relatively benign things (that Agnostic Lizard handles easily) break many code walkers for arcane reasons
clothespin_ has joined #lisp
trebor_home has quit [Ping timeout: 248 seconds]
oxum has joined #lisp
vs has quit [Ping timeout: 258 seconds]
bars0 has quit [Remote host closed the connection]
haziz94 has joined #lisp
<haziz94>
Newbie question. How do I display the result (eg numerical calculation) of a short program that is loaded from file? The program evaluates correctly but just reports true (T) as the result, without giving me the numerical result it evaluates to.
clothespin__ has quit [Ping timeout: 265 seconds]
<phoe>
haziz94: (print result)
<phoe>
but, if the returned value is T, then it might not work the way you intended
<White_Flame>
typically, you load function definitions from a file, then call them from the REPL which will display the returned values of the function you call
bars0 has joined #lisp
<White_Flame>
if you have toplevel forms that are not inside DEFUNs, they will run, but their output will not be printed automatically
sloanr1 has joined #lisp
clothespin_ has quit [Ping timeout: 245 seconds]
<phoe>
haziz94: actually post it here - I need to crash for the night
<phoe>
someone should be able to take a look
<haziz94>
phoe: Your answer does give me the response I am looking for.
<phoe>
haziz94: yay!
<haziz94>
Thanks!
sloanr has quit [Ping timeout: 268 seconds]
<White_Flame>
the function LOAD returns T, which might be what you're seeing
sloanr has joined #lisp
<White_Flame>
(if it loads successfully)
<pfdietz>
MichaelRaskin: I get the feeling you explained all that to me before. If so, I apologize for not remembering.
<haziz94>
White_Flame You are probably correct. I maybe seeing the evaluation of LOAD.
<haziz94>
I am using slime via emacs if it matters.
<White_Flame>
(load "blah.lisp") => T
<White_Flame>
yeah, slime is the right way
AnimalCl` has quit [Ping timeout: 268 seconds]
<White_Flame>
if you're editing your functions in another buffer, the C-c C-k will compile & load the entire file into the lisp image, then you can call its functions
sloanr1 has quit [Ping timeout: 260 seconds]
<White_Flame>
you shouldn't need to manually (load ...) files from within SLIME
<White_Flame>
C-c C-c will evaluate the single expression under the cursor, if you want to reload a singular edited DEFUN instead of the entire file
<White_Flame>
there are some good SLIME cheatsheets out there that you can search for
torbo has joined #lisp
<markasoftware>
If I want + and * to have different definitions in a macro body, is (subst) my best bet?
<markasoftware>
or should i try to "unlock" the common-lisp package, whatever that means, then use flet or macrolet?
<White_Flame>
or you could be in a different package that shadows COMMON-LISP:+ or doesn't import it
<no-defun-allowed>
Hm, I would think those are special variables and so you could bind them with LET, but those names are hard to look up.
<White_Flame>
+ and * are also REPL variables, so LET is free to bind them. Just not its fdefinition
<Bike>
they are special variables, and binding them as special varaibles is fine, but they're also functions and binding them as functions is not fine.
reepca has joined #lisp
<markasoftware>
what's a repl variable?
<grobe0ba>
a variable set in the Read-Eval-Print-Loop?
<haziz94>
Another newbie question. I am aware of MAPCAR, and can write a short DEFUN that will recursively add all integers in a list, but is there a prebuilt addition function that will add all numbers in a list?
<White_Flame>
variables that the REPL itself manages. * is the prior returned value, ** is the return value before that, etc
<grobe0ba>
or pertaining to it in some way
<phoe>
they're variables, except they are convenience variables set by the REPL for your use
<phoe>
haziz94: (reduce #'+ list)
<Bike>
haziz94: you can (apply #'+ list) or (reduce #'+ list).
<markasoftware>
eh, i guess adding a letter before my custom + isn't so hard
<White_Flame>
I would also like to point to #clschool, which is intended for newbie questions (although this channel is easier to find)
<White_Flame>
since sometimes the answers here will assume you already know a whole lot more ;)
<haziz94>
Thanks.
sloanr1 has joined #lisp
<haziz94>
White_Flame : I did try to log into #clshool, but unlike #lisp, it is not allowing me to post. I also use IRC fairly infrequently so I maybe doing something wrong. #lisp let me login and post immediately however. I tried with both the web client as well as Thunderbird acting as an IRC client. I can also use Pidgin.
<aeth>
is your name registered? a while ago, freenode was hit by a spammer for months and months
<aeth>
so a lot of channels have anti-spam measures
<aeth>
#clschool is actually the replacement to a channel that had no active operators and so had to be abandoned because of the spam
paul0 has joined #lisp
sloanr has quit [Ping timeout: 268 seconds]
sloanr1 has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: Quit.]
haziz94 has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]