<moon-child>
beach: in your fast generic dispatch paper, why do you use two words instead of one for a general instance? I don't quite see the rationale; and it increases memory use and indirection
<moon-child>
and if you were to use two words, why not make the stamp be the first word and place the class in the rack? That way you can prefetch the rack before beginning the dispatch process, and only need to wait for one memory access
loskutak has joined #lisp
Nilby has joined #lisp
<saturn2>
engblom: i think there are mixed opinions on iterate, some people like it and some don't
mindCrime has joined #lisp
<phoe>
engblom: this tutorial is shit
<phoe>
these examples do not even compile
<phoe>
please abandon ship and use something that actually works, e.g. PCL
<engblom>
phoe: I know, that is why I asked if someone here is responsible for it. I wanted to PM that person with corrections
<phoe>
engblom: the footer of that webpage has hints
<phoe>
doesn't look like it's updateable.
<engblom>
phoe: I stumbled upon it when trying to find a clean and simple construct that allows me to first bind variables and then repeat until condition is met. (do ...) seems to check the condition before the loop, so it does not do what I want.
varjag has joined #lisp
<phoe>
engblom: you could try LOOP for that
<phoe>
(loop for x in '(1 3 5 7 8 9 11 13 15) do (print x) when (evenp x) do (loop-finish))
psilotorp has joined #lisp
<engblom>
phoe: I am searching for the equivalent of (loop [x "foo" y "bar] (do-something-with x y) (when something (recur)))
psilotorp has quit [Ping timeout: 245 seconds]
<moon-child>
what do you mean by (when something (recur))?
<phoe>
engblom: (loop with x = "foo" with y = "bar" unless something (do ...))
<engblom>
moon-child: That was Clojure, and I am searching for how to do it in CL. So something cleaner than (let (()) (loop .... (return)))
<phoe>
oh wait, RETURN aborts the looping altogether
<phoe>
you want something that breaks the loop or just a single iteration?
<engblom>
phoe: I am searching for a way to bind a few variables and then at least once do the iteration, but keep iterating until a condition is met (which is coming from actually reading some information and got nothing to do with the loop variables)
<phoe>
that's what I wrote above, (loop ... when ... do (loop-finish))
<engblom>
Okay, thanks!
<phoe>
execute that example in the CL REPL and see that after the even number nothing else is printed, the iteration is terminated
<moon-child>
you can also do (loop with ... do ... until ...)
<flip214>
TAGBODY for the win! No, in reality I'm an ITERATE user.
<engblom>
moon-child: Thank you, that was what I was looking for!
<phoe>
moon-child: oh right, I actually didn't think about this one!
narimiran has joined #lisp
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
<pjb>
engblom: (loop with i = 0 while (< i 10) collect (incf i)) #| --> (1 2 3 4 5 6 7 8 9 10) |#
<pjb>
engblom: (with-input-from-string (*standard-input* "1 1 1 1 0") (loop with i = 0 while (plusp (read)) collect (incf i))) #| --> (1 2 3 4) |#
<beach>
engblom: I use LOOP for everything. I see no reason to use an external library when the standardized operator will do.
<moon-child>
pjb: the collect/do should be before the condition
<moon-child>
engblom wants the loop to always run at least once
<pjb>
engblom: or of course, if you want until: (with-input-from-string (*standard-input* "1 1 1 1 0") (loop with i = 0 collect (incf i) until (zerop (read)))) #| --> (1 2 3 4 5) |#
<pjb>
moon-child: right.
<beach>
moon-child: You have to be able to change the class and the instance contents without changing the identity.
<pjb>
engblom: Note you can move the while after: (with-input-from-string (*standard-input* "1 1 1 1 0") (loop with i = 0 collect (incf i) while (plusp (read)))) #| --> (1 2 3 4 5) |#
<pjb>
engblom: while/until is just whether you test the stop condition or it's negation.
<pjb>
engblom: You can also have while or until in the middle, or several of them.
<beach>
moon-child: The stamp and the class must evolve separately. The stamp is the unique number of the class as it was when the instance was created, and it is used to detect obsolete instances.
<moon-child>
beach: that shouldn't be an issue as long as you don't change the number of cells in the object
<engblom>
pjb: Thank you, now it makes more sense!
<pjb>
(with-input-from-string (*standard-input* "1 1 1 1 1 1 1 0") (loop with i = 0 while (plusp (read)) collect (incf i) while (plusp (read)) collect 0 while (plusp (read)))) #| --> (1 0 2 0 3) |#
<beach>
moon-child: But the number of cells change as a result of either change-class or class redefinition.
<engblom>
pjb: Many times I have looked at the clhs but very often I have trouble understanding it. Often I end up searching for examples instead. As I get more used to CL I hope to get better at reading clhs too
cranium_ has joined #lisp
imode has quit [Ping timeout: 268 seconds]
<beach>
moon-child: There is also an issue with threads. I want the rack to be self-contained, so that a thread that needs to modify the structure of a rack is obliged to allocate a new rack and assign it to the header using CAS.
<moon-child>
I see
frost-lab has quit [Quit: Ping timeout (120 seconds)]
<beach>
There has to be an indirection, but it might be possible to make it work with a single word. But then, the GC for the global heap allocates these headers and also CONS cells in a free list, so that they won't move. Because they are all the same size.
<pjb>
engblom: the trick when learning a programming language, is to write the examples oneself.
<pjb>
engblom: so you read a clhs page, and try examples at the REPL right awaya.
<pjb>
s/a./.
<pjb>
engblom: this is what I just did above with those loops…
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
<engblom>
beach: What is your opinion about alexandria?
mindCrime has quit [Ping timeout: 246 seconds]
<beach>
engblom: I have no opinion about it. I haven't used it much, but some of the libraries I use, use Alexandria as well, so I use it indirectly.
<pjb>
engblom: what is YOUR opinion about alexandria?
<engblom>
pjb: I am new to CL, so I do not have much opinion yet, but I found iota and when-let to be useful from alexandria, and later maybe I find something else there I would use too.
<pjb>
ok. So: useful.
<engblom>
pjb: I am mostly trying to find out what I in general accepted and not accepted so I do not develop bad habits from the beginning.
<pjb>
Don't worry.
<beach>
engblom: Alexandria is used a lot, so I think it must be fine.
silasfox has joined #lisp
<splittist>
beach: so is C (used a lot)
* splittist
realises he has been under a misapprehension about the ordering of unconditional and termination-test clauses in LOOP (and wonders how many over-complicated loops he can rewrite...)
<beach>
engblom: Alexandria is used a lot by some Common Lisp programmers that I respect a lot because they write maintainable and modular code, so I think it must be fine.
<splittist>
engblom: but Alexandria is great, in case you misunderstood me (:
sm2n has quit [Ping timeout: 240 seconds]
hiroaki has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
sm2n has joined #lisp
sm2n has quit [Excess Flood]
sm2n has joined #lisp
<shka_>
alexandria is perhaps the least controversial utility library there is
<shka_>
and implements a lot of functions that are used by almost everyone
<shka_>
like shuffle, hash-table-keys/hash-table-values and so one
silasfox has quit [Quit: WeeChat 3.1]
silasfox has joined #lisp
sm2n has quit [Ping timeout: 240 seconds]
silasfox has quit [Client Quit]
silasfox has joined #lisp
<engblom>
Then I will continue to use alexandria with good conscience.
long4mud_ has joined #lisp
long4mud has quit [Ping timeout: 252 seconds]
<shka_>
yes, i don't think anybody will ever criticize you for using the alexandria
long4mud has joined #lisp
long4mud_ has quit [Ping timeout: 240 seconds]
frost-lab has joined #lisp
karlosz has quit [Ping timeout: 260 seconds]
anticrisis has quit [Read error: Connection reset by peer]
frost-lab has quit [Ping timeout: 260 seconds]
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
dmiles_afk has joined #lisp
dmiles_afk has quit [Remote host closed the connection]
dmiles_afk has joined #lisp
hendursa1 has joined #lisp
pve has joined #lisp
Bourne has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
aartaka_d has joined #lisp
pve has quit [Ping timeout: 246 seconds]
heisig has joined #lisp
pve has joined #lisp
aartaka has quit [Ping timeout: 252 seconds]
frost-lab has joined #lisp
<jdz>
engblom: I see nobody has suggested PROG yet, so: (prog ((x "foo") (y "bar")) recur (do-something-with x y) (when something (go recur)) (return return-value))
sm2n has joined #lisp
<engblom>
jdz: Thanks!
sm2n_ has joined #lisp
sm2n has quit [Read error: Connection reset by peer]
edgar-rft has quit [Ping timeout: 265 seconds]
edgar-rft has joined #lisp
sm2n_ has quit [Remote host closed the connection]
sm2n has joined #lisp
<phoe>
oh boy, I see explicit control flow
<phoe>
PROG is useful for writing simple state machines
<phoe>
this includes iteration
sm2n_ has joined #lisp
sm2n has quit [Read error: Connection reset by peer]
TK__ has quit [Ping timeout: 245 seconds]
sm2n_ has quit [Remote host closed the connection]
<pjb>
But still with 5 or fewer entries, getf is faster than gethash, because gethash has to compute a sxhash, which is slow compared to 5 compare and 5 memory fetches…
Gromboli has quit [Ping timeout: 260 seconds]
surabax has joined #lisp
silasfox has quit [Quit: WeeChat 3.1]
kmeow has joined #lisp
botnet has quit [Ping timeout: 268 seconds]
jasom has quit [Ping timeout: 276 seconds]
housel has quit [Ping timeout: 276 seconds]
jlf has joined #lisp
housel has joined #lisp
jasom has joined #lisp
pbaille has quit [Quit: Leaving...]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
sm2n_ has joined #lisp
sm2n has quit [Read error: Connection reset by peer]
sm2n_ has quit [Read error: Connection reset by peer]
sm2n_ has joined #lisp
sm2n_ has quit [Read error: Connection reset by peer]
sm2n_ has joined #lisp
Bike has joined #lisp
pfdietz has quit [Ping timeout: 240 seconds]
<engblom>
If I want to know where the code I am running is stored, can I do it? In my case I want to find by code where the package is so I am able to give the full path to the settings directory inside of the package.
<engblom>
Right now I have it hardcoded with (defparameter ..)
<engblom>
Like this: (defparameter project-root "~/common-lisp/gpon")
<phoe>
you can locate ASDF systems
<phoe>
not individual packages
<phoe>
on my machine, (asdf:system-source-directory :phoe-toolbox) ;=> #P"/home/phoe/Projects/Lisp/phoe-toolbox/"
pjb has quit [Quit: rebooting macOS for update…]
silasfox has joined #lisp
<engblom>
phoe: Thanks
Dyedefra has joined #lisp
sm2n has joined #lisp
sm2n_ has quit [Ping timeout: 252 seconds]
silasfox has quit [Client Quit]
niflce has joined #lisp
sm2n has quit [Read error: Connection reset by peer]
hjudt has quit [Ping timeout: 252 seconds]
pjb has joined #lisp
sm2n_ has joined #lisp
sm2n_ has quit [Remote host closed the connection]
<engblom>
Besides first converting to string (with namestring) and then concatenating the directory I want, can I add to that path in a more elegant way?
sm2n_ has quit [Remote host closed the connection]
sm2n_ has joined #lisp
sm2n has joined #lisp
sm2n_ has quit [Ping timeout: 252 seconds]
oni-on-ion has joined #lisp
APic has joined #lisp
CrashTestDummy3 has joined #lisp
niflce has quit [Ping timeout: 252 seconds]
oni-on-ion has quit [Remote host closed the connection]
sm2n has quit [Ping timeout: 240 seconds]
CrashTestDummy2 has quit [Ping timeout: 240 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
CrashTestDummy has joined #lisp
<engblom>
I want to define a function that takes an optional argument. In case the argument is not given I want it to have a default value. The first part I know I can do with &optional, but how do I get the default value unless it is given? Can I do it directly in the function definition or do I need a separate if statement that checks if it is nil and then sets it to the default value?
<beach>
And you wouldn't check whether the parameter is NIL. You would use the SUPPLIED-P-PARAMETER instead as that page indicates.
oni-on-ion has joined #lisp
CrazyPython has joined #lisp
oni-on-ion has quit [Ping timeout: 245 seconds]
dbohdan has left #lisp [#lisp]
CrazyPyt_ has quit [Ping timeout: 260 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
<pjb>
beach: engblom: it's a little mischevious to say that there are statements in tagbody. They're just usual expressions whose values are ignored, just like most expressions in progn, prog1, prog2, prog, prog*, progv, locally, block, catch, unwind-protect, etc, etc, etc.
sauvin_ is now known as Sauvin
<pjb>
granted they used the non-terminal name /statement/, but that's all. Just to distinguish those expressions from the tags.
<pjb>
well, ok, prog and prog* use tagbody so they also have those expressions called /statement/…
<beach>
I couldn't really say something like "Common Lisp does not have `statements'", because of that non-terminal.
<beach>
Also, they are not arbitrary forms. They have to be compound forms.
<splittist>
tagbody; RETURN is referred to as a statement; PROG, PROG* also use 'statement' as a compound form; SETQ is referred to as the 'simple variable assignment statement of Lisp'... (:
<Nilby>
Maybe declarations are sort of like statements since they don't have value?
<pjb>
but declaratons are not evaluated.
<beach>
Nilby: No, such things are referred to as "expressions" and not "forms".
<pjb>
and cannot be: (locally (declare (special *f*)) (print 'hi) (declare (type integer *f*)) (print 'lo)) #| hi ERROR: While compiling an anonymous function : The DECLARE expression (declare (type integer *f*)) is being treated as a form, possibly because it's the result of macroexpansion. DECLARE expressions can only appear in specified contexts and must be actual subexpressions of the containing forms. |#
<pjb>
Note, it says FORM, not STATEMENT.
<pjb>
Expressions that return no values, such as (values) 1- are still called expressions, 2- are still expression in that they still produce a value if a value is expected: (list (values) (values) (values)) #| --> (nil nil nil) |# and 3- are still valid in any place an expression is valid. And therefore cannot be called statements.
<pjb>
The difference between statement vs. expression exist in languages where they are not interchangeable.
<pjb>
For example, in C, you cannot write: int a=0; b=if(a<0){return 3;}else{ return 4;} because if is a statement. (you have to write int a=0; b=(a<0)?3:4; since ?: is an operator for an expression.
<splittist>
(And GO is referred to as a statement, of course, which is where we started.)
<pjb>
GO is a special operator. A GO form such as (GO foo) is an expression. Even if it does not return, it is still an expression: it can be used anywhere an expression can.
<beach>
pjb: No, it can not. But it can be used anywhere a FORM can be used.
<splittist>
"[PROG and PROG*] permit use of the return statement, and they permit use of the go statement."
<splittist>
"statement" looks like one of those terms that was intended to be a glossary entry, but never made it in.
<beach>
Note to self: in WSCL define STATEMENT in the glossary, or eliminate the use of the term. If the term is retained, make sure it is used the same way everywhere.
<pjb>
expression n. 1. an object, often used to emphasize the use of the object to encode or represent information in a specialized format, such as program text. ``The second expression in a let form is a list of bindings.'' 2. the textual notation used to notate an object in a source file. ``The expression 'sample is equivalent to (quote sample).''
<pjb>
form n. 1. any object meant to be evaluated. 2. a symbol, a compound form, or a self-evaluating object. 3. (for an operator, as in ``<<operator>> form'') a compound form having that operator as its first element. ``A quote form is a constant form.''
<pjb>
beach: indeed, by these definition.
<pjb>
I used a more restrictive definition of expression = form, in the controverse expression vs. statement.
<Nilby>
so there's secretly a nil already sitting in every form?
<phoe>
in every form? what do you mean
<phoe>
missing values are coerced into NIL, there's no secret NILs anywhere
<phoe>
(multiple-value-bind (a b c d) (values) (list a b c d)) ;=> (NIL NIL NIL NIL)
<Nilby>
(values) is actually a value then i.e. a #<novalue> object
<phoe>
not really?
<Nilby>
how can one coerce a thing that doesn't exist?
<phoe>
in a simple way - conceptually, every function returns an implicit vector of values
<phoe>
most of the time, it is a vector of length 1
Jesin has joined #lisp
<phoe>
(values) returns a vector of length 0
<phoe>
and if you normally try to get a 1st element of a 0-length vector, that would be an error - instead, CL defines that to return NIL in case of missing values
<Nilby>
I know it's just a weird philosophical point, but "no values" is actually a value in a way.
<phoe>
not a first-class thing in CL though
<phoe>
unless you use MULTIPLE-VALUE-CALL, at which point you still operate on lists and not on "no values" objects
dilated_dinosaur has quit [Ping timeout: 240 seconds]
<Nilby>
we have accessor "values" for a thing which supposedly isn't there
mister_m_ has joined #lisp
<Nilby>
I find it interesting that (locally) -> nil
cranium_ has quit [Quit: Leaving]
<phoe>
it's just defined to be this way, same as (setq) and (progn) and what else
<phoe>
but we also have SETF for places, which aren't a first-class concept either
<pjb>
multiple values are implemented by storing them in registers, with a register holding the count of values.
<Nilby>
but I can accept that setf forms are a macro expansion to something with values
<pjb>
say, mv-count mv-0 mv-1 mv-2 …
dilated_dinosaur has joined #lisp
<pjb>
so when you write (setf x (values)) it does (funcall (function values)) (setf x (if (zerop mv-count) nil mv-0))
<pjb>
If you write (multiple-value-setq (x y z) (values 1 2)) it does (funcall (function values) 1 2) (setf x (if (zerop mv-count) nil mv-0) y (if (< mv-count 2) nil mv-1) z (if (< mv-count 3) nil mv-2))
<pjb>
it's not a vector or a list in the sense that it's not a lisp object, it's just registers. (But that can also be memory storage, when there are not enough registers), since the minimal value for multiple-values-limit is 20, and people are still buying processors without as many registers…
whosit has quit [Read error: Connection reset by peer]
<Nilby>
I know how it works both interpreted and compiled, but on an abstract level I feel like (values) is a hole in the logical consistency of Lisp.
whosit has joined #lisp
<beach>
Yeah, lets update the standard.
jnewton`` has joined #lisp
sm2n has joined #lisp
<pjb>
Nilby: that's the point of CL: it's full of inconsistency, so that it's compatible with existing code, and it let implementations easily be fast.
nlif[m] has joined #lisp
Guest95354 is now known as Duuqnd
<Nilby>
I love that CL has multiple values, it's very useful. (values) just feels like a weird Gödel-like thing in McCarthy's lovely universal function. Although I guess all the special operators are logically troublesome. Even quote is weird.
zaquest has quit [Quit: Leaving]
<beach>
Nilby: It is not a special case. That form returns 0 values. The general rule is that of more values are required by the caller than what the callee supplies, then the remaining values required are initialized to NIL.
<phoe>
Nilby: I wonder why it's weird
<phoe>
(values) is to (values 1 2 3) like (m-v-b (x) (values) ...) is to (m-v-b (a b c x) (values 1 2 3) ...)
<phoe>
you request more values than you have, so you get NIL for the missing ones
<beach>
Nilby: So if the caller wants one value and the callee does (values) when it returns, then NIL is what the caller gets.
<phoe>
doesn't matter if it's the 0th or the 1st or the 42th value (if your implementation permits 42 values)
<ebrasca>
Did someone try to run reddit1.0?
<phoe>
still seems consistent to me
<phoe>
ebrasca: I did, the official release doesn't build
<splittist>
As was pointed out before, it's a logical extension of the concept, like (+) (:
<phoe>
it needs some fixes and what else in order to even compile, and it doesn't run even after it compiles
zaquest has joined #lisp
<ebrasca>
phoe: Do you think it is good software? Or is it better to start from scrach?
<phoe>
ebrasca: reddit 1.0 is written like a quick hack, I'd definitely do a lot of refactoring on it if I ever wanted to use that codebase
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
renzhi has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jann1s has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
ebrasca has quit [Remote host closed the connection]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
bitmapper has joined #lisp
narimiran has quit [Ping timeout: 252 seconds]
surabax has quit [Quit: Leaving]
jnewton`` has quit [Ping timeout: 240 seconds]
wsinatra has quit [Quit: WeeChat 3.1]
peregu has joined #lisp
<White_Flame>
when paredit won't let you delete because it thinks there's an imbalanced parenthesis, how can you get it to show where that imbalance is?
<White_Flame>
I have a file that's mostly comments, and something in there is confusing paredit
<phoe>
I don't usually have that problem because I use rainbow-parens and I identify missing parens by color
<White_Flame>
I don't have any imbalances, and paredit thinks there are
<White_Flame>
not even the comments have imbalanced parens
<phoe>
huh! interesting
<White_Flame>
but I do use #| |#, which paredit doesn't handle well
<Nilby>
emacs sometimes up if you have something like the re "^(defun" in docstring or in a multi-line comment
<Nilby>
messes up
<White_Flame>
again, all parens are balanced, even in the comments. Paren balanced scope doesn't even traverse multiple lines
<White_Flame>
I want paredit to show me where it thinks the imbalance is, if possible
aeth has quit [Ping timeout: 260 seconds]
<Nilby>
It can't because it would have to fix it's own bug
eddof13 has joined #lisp
<White_Flame>
clearly there is a location where it transitions from "balanced" to "imbalanced"
<Nilby>
yes, but it's using regular expressions so it doesn't know wtf is actually going on
<White_Flame>
oh, well that sucks then
<Nilby>
it's only been screwing up for 40 years
<White_Flame>
heh
aeth has joined #lisp
<White_Flame>
regex is such a hack when used on larger things
<Nilby>
I've had to change my comment/docstring formmating until emacs stops failing
<phoe>
oh wait, I think I know what's the issue
niflce has quit [Ping timeout: 252 seconds]
<White_Flame>
hmm, yeah I think I just fixed it, too. change "|#" to ";;|#" and now it stops whining
<phoe>
do you have any lines in a docstring that begin with an open parenthesis?
<Nilby>
nice. fake it out with a double comment
<phoe>
I remember that this used to trip my emacs up
<White_Flame>
no. this is 100% comments, and no paren pair spans lines
<phoe>
but might be a different problem
<phoe>
OK, I see
<phoe>
but is ;;#| valid Lisp? like, does this properly start a multiline comment?
<White_Flame>
it's the ending multiline tag
masp has quit [Quit: Konversation terminated!]
<pjb>
phoe: nope. ; starts a single line comment. It doesn't matter what's on this line.
<pjb>
Nilby: the advice is to use \( when you have to put a parenthesis at the start of a line in docstrings.
<pjb>
"\(foo)" --> "(foo)"
<pjb>
Reader macros can imbalance paredit, which still uses emacs forward-sexp/backward-sexp instead of a CL lexer/parser.
oni-on-ion has joined #lisp
oni-on-ion has quit [Client Quit]
pve_ has quit [Quit: leaving]
psilotorp has quit [Remote host closed the connection]
peregu has quit [Ping timeout: 265 seconds]
jnewton`` has joined #lisp
jaquatix has joined #lisp
<engblom>
I know I have once before asked but I forgot: what is the difference between :use and #:use in defpackage?
jnewton`` has quit [Ping timeout: 252 seconds]
loskutak has quit [Ping timeout: 252 seconds]
<pjb>
engblom: :use is a defpackage option name. #:use is nothing.
<pjb>
notably, follow the links string designator, package designator.
jaquatix_ has joined #lisp
jaquatix has quit [Ping timeout: 260 seconds]
<engblom>
pjb: Thanks, I found the use of #:use but it must then be specific to mgl-pax:define-package, which is used in that file
<phoe>
that's not a standard CL operator so it is allowed to do whatever
akoana has joined #lisp
TK__ has quit [Ping timeout: 245 seconds]
shka_ has quit [Ping timeout: 265 seconds]
StuartMalcolm has quit [Ping timeout: 260 seconds]
hyp has joined #lisp
davisr_ has joined #lisp
jnewton`` has joined #lisp
davisr has quit [Ping timeout: 240 seconds]
<engblom>
I will have to use multiple return values. Does CL have destructuring as in Clojure? (meaning I can have something like (defun adding ((x y)) (+ x y)) and then call it with the result of a multivalue function)?
<phoe>
engblom: the usual way is to use multiple-value-call
aartaka_d has quit [Read error: Connection reset by peer]
<phoe>
destructuring and multiple values are separate concepts in CL
<Bike>
the things in defpackage are string designators, so symbols have no meaning beyond their symbol name, so #:f and :f are the same to defpackage
<Bike>
the only difference is that with #:f there will not be a symbol interned in the keyword package
kevingal has quit [Remote host closed the connection]
Oddity has quit [Ping timeout: 246 seconds]
<engblom>
I am sorry, but I can not comprehend that. What is the keyword package?
<Bike>
When you write :foo that is short for keyword:foo
<Bike>
keyword is a special package. all the symbols in it are constants with themselves as values. that's why if you put :foo in the repl you get :foo back.
<kagevf>
you can also do (multiple-value-call #'+ 1 2 3) ... m-v-c will take all the values of any forms ... it's like it does the (values ...) for you
<kagevf>
nice flexibility
<engblom>
Bike: :foo
<engblom>
Unknown top-level command: "foo".
<Bike>
uhhhhh, what implementation is that?
<engblom>
sbcl
<Bike>
are you in the debugger or something?
<Bike>
i just started a fresh sbcl in terminal and it did what i'd expect
<engblom>
No, I am not in the debugger
<engblom>
But I am inside of a package, if that matters?
<pjb>
yeah, sbcl debugger is a little psychopathic.
<Bike>
it shouldn't
<pjb>
This is why slime sldb was developped…
<Bike>
the repl is trying to interpret forms as commands for some reason
<Bike>
well, you can do (eval :foo), probably, to get the same idea
<engblom>
That works.
<pjb>
Well, (eval ':foo) to be sure.
<pjb>
Since eval is a function :foo would be evaluated before its value being passed to eval…