torbo has quit [Remote host closed the connection]
shangul has joined #lisp
nicklaf has joined #lisp
nicklaf has left #lisp [#lisp]
mathrick has quit [Ping timeout: 252 seconds]
mathrick has joined #lisp
john2x has quit [Ping timeout: 258 seconds]
meepdeew has quit [Remote host closed the connection]
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
mindCrime_ has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
quazimodo has joined #lisp
zotan has quit [Ping timeout: 252 seconds]
zotan has joined #lisp
mrcom has quit [Quit: Leaving]
john2x has joined #lisp
igemnace_ is now known as igemnace
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
john2x has quit [Ping timeout: 258 seconds]
john2x has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
ebrasca has quit [Remote host closed the connection]
orivej has joined #lisp
lavaflow_ has quit [Ping timeout: 258 seconds]
refpga has joined #lisp
dddddd has quit [Remote host closed the connection]
cropcircle has joined #lisp
esrse has joined #lisp
refpga has quit [Read error: Connection reset by peer]
ym555 has quit [Quit: leaving...]
Bike has quit [Quit: Lost terminal]
mindCrime_ has quit [Ping timeout: 258 seconds]
jack_rabbit has quit [Ping timeout: 252 seconds]
caltelt_ has joined #lisp
caltelt_ has quit [Remote host closed the connection]
caltelt_ has joined #lisp
jack_rabbit has joined #lisp
shangul has quit [Ping timeout: 246 seconds]
ckonstanski has joined #lisp
caltelt has quit [Ping timeout: 258 seconds]
mindCrime_ has joined #lisp
elderK has quit [Quit: Connection closed for inactivity]
mindCrime_ has quit [Ping timeout: 258 seconds]
vlatkoB has joined #lisp
Necktwi has quit [Read error: Connection reset by peer]
torbo has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
anewuser has joined #lisp
lavaflow_ has joined #lisp
lavaflow_ is now known as lavaflow
pankajgodbole has joined #lisp
torbo has quit [Remote host closed the connection]
ricekrispie has joined #lisp
ricekrispie2 has quit [Ping timeout: 244 seconds]
<beach>
Good morning everyone!
<Josh_2>
Morning beach :)
makomo has joined #lisp
meepdeew has joined #lisp
GoldRin has quit [Ping timeout: 244 seconds]
CrazyEddy has quit [Ping timeout: 268 seconds]
john2x has quit [Ping timeout: 255 seconds]
Jesin has quit [Ping timeout: 258 seconds]
CrazyEddy has joined #lisp
Jesin has joined #lisp
shangul has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
gabbiel has joined #lisp
<gabbiel>
Hey guys, I'm trying to create this 2 macros called "synonymize-macro" and "synonymize-function"
<gabbiel>
they basically create synonyms for existing macros and functions
<gabbiel>
e.g. (synonymize-function plus +)
dale has quit [Quit: dale]
<gabbiel>
I'm trying to really make it a synonym, i.e. have the new synonyms inherit documentation and arglists
<gabbiel>
documentation is easy, but arglist is the troublemaker here
<no-defun-allowed>
er, if you copy the function won't it have the same lambda list?
<gabbiel>
I thought of using trivial-args, and then processing the return value of the arglist function in the trivial-args package
<no-defun-allowed>
eg (setf (fdefinition 'bar) (fdefinition 'foo)) worked here, copied function and documentation
<gabbiel>
hmm, let me try that
mingus has joined #lisp
<gabbiel>
wow thanks, I didn't know about that
<pillton>
I am surprised there isn't support for this in the reader.
<gabbiel>
looks like it works great for functions, but not for macros, it gives errors
<pillton>
There is function-lambda-expression as well.
<no-defun-allowed>
macro-function instead of fdefinition
<gabbiel>
nice, that saved me so much trouble
<gabbiel>
on a similar note, I also have a macro called funmacro, which turns a function into a macro
<gabbiel>
I should rephrase: it defines a macro that does what function does
<gabbiel>
I don't think I can use fdefinition/macro-function here
<gabbiel>
is the only option here to use trivial-args:arglist ?
<shka_>
why you would want such macro?
<gabbiel>
so I don't have to quote args
<gabbiel>
sounds dumb, but I have this function I use for my hobby which uses only lists and its annoying to have to quote a bunch of lists
<shka_>
hm, ok
<shka_>
i don't understand but that's fine
<gabbiel>
I also wrote a macro "nq" which doesn't define anything, but calls a function with args quoted, maybe I should use that, but idk, funmacro is useful because it also allows for defining with anonymous functions
<gabbiel>
no-defun-allowed: It seems special operators aren't covered
campy_fellow has quit [Ping timeout: 252 seconds]
mingus has quit [Ping timeout: 258 seconds]
campy_fellow has joined #lisp
JohnMS_WORK has joined #lisp
<gabbiel>
no-defun-allowed: is there a function akin to fdefinition/macro-function for special operators?
<no-defun-allowed>
can't do that
<pillton>
You can install a macro instead.
<gabbiel>
I can do that, but then the synonym properties would go away
meepdeew has quit [Remote host closed the connection]
<gabbiel>
I noticed that fdefinition returns a "closure" object
<pillton>
I am skeptical about your synonym anyhow. You are only considering the function namespace.
<gabbiel>
I can use defparameter for variables
<pillton>
Classes, types?
<gabbiel>
for now, only functions and macros, if I ever needed classes, I'd do it then
<gabbiel>
as for types, isn't there a deftype
campy_fellow has quit [Ping timeout: 255 seconds]
<gabbiel>
classes seem complicated, I haven't even read the art of the metaobject protocol
<gabbiel>
or the other book teaching CLOS, forgot the name
campy_fellow has joined #lisp
<gabbiel>
quick question, I learned I have to do (eval-when (compile load execute) ...) when I need to use macros within the same file. if I macro that away, will it eval-when, or wont it do anything as its a macro?
<gabbiel>
thought it wouldn't work, but it did, weird
Arcaelyx has quit [Ping timeout: 255 seconds]
cosimone has joined #lisp
meepdeew has joined #lisp
cosimone1 has joined #lisp
shangul has quit [Ping timeout: 268 seconds]
cosimone1 has quit [Client Quit]
karlosz has quit [Quit: karlosz]
<gabbiel>
gnite everyone
gabbiel has quit [Quit: ERC (IRC client for Emacs 26.1)]
karlosz has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
cosimone has joined #lisp
<splittist>
gmorn
cosimone has quit [Client Quit]
cropcircle has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
anewuser has quit [Quit: anewuser]
shangul has joined #lisp
schweers has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
cosimone has quit [Quit: WeeChat 2.3]
shangul has quit [Ping timeout: 258 seconds]
shidima has joined #lisp
scymtym has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
meepdeew has quit [Remote host closed the connection]
aerique has joined #lisp
karlosz has quit [Quit: karlosz]
p9fn has joined #lisp
campy_fellow has quit [Read error: Connection reset by peer]
campy_fellow has joined #lisp
shangul has joined #lisp
arkaitz has joined #lisp
arkaitz has quit [Client Quit]
oni-on-ion has joined #lisp
john2x has joined #lisp
shidima has quit [Remote host closed the connection]
manualcrank has quit [Quit: WeeChat 1.9.1]
wigust- has joined #lisp
wigust has quit [Ping timeout: 258 seconds]
igemnace has quit [Ping timeout: 246 seconds]
zotan has quit [Ping timeout: 250 seconds]
zotan has joined #lisp
crystalball has joined #lisp
ggole has joined #lisp
crystalball has quit []
igemnace has joined #lisp
crystalball has joined #lisp
crystalball has quit [Client Quit]
quazimodo has quit [Ping timeout: 258 seconds]
quazimodo has joined #lisp
_whitelogger has joined #lisp
v88m has quit [Ping timeout: 268 seconds]
john2x has quit [Remote host closed the connection]
shangul has quit [Ping timeout: 245 seconds]
<afidegnum>
should i run that in sline ?
<no-defun-allowed>
in slime, run (load "~/Downloads/quicklisp.lisp") or wherever
<afidegnum>
ok
Nilby has joined #lisp
shangul has joined #lisp
<pjb>
afidegnum: you cannot install quicklisp in emacs. emacs implements emacs lisp. quicklisp is written in Common Lisp.
<afidegnum>
ok
<pjb>
afidegnum: there was a (partial) Common Lisp implemented in emacs lisp, but it bit rot since introduction of lexical bindings in emacs lisp. You might want to work on it, it's emacs-cl. Then a port of quicklisp to emacs-cl would be envisageable.
<pjb>
afidegnum: slime is a kind if IDE letting you develop CL programs using emacs as an editor and user interface for the CL debugger, the CL repl, the CL inspector, etc. So indeed, you could install quicklisp using the CL you access thru slime. But it would be simplier to start at the terminal with quicklisp, since quicklisp also has tools to install slime.
<afidegnum>
so how is the quicklisp terminal like ?
<afidegnum>
i m currently using Portacle,
<afidegnum>
how do i install libraries in portacle?
<pjb>
Ah,sorry, I don't know anything about portacle. Shouldn't everything be already installed and available with it?
<afidegnum>
how do i find out if quicklis is installed on portacle?
<jdz>
afidegnum: Type (find-package "QUICKLISP") in the REPL.
<afidegnum>
it returned NIL
<no-defun-allowed>
yeah, you'd have quicklisp in portacle
<pjb>
Is quicklisp already installed in your home director? Is there a file ~/quicklisp/setup.lisp ?
<pjb>
(load #P"~/quicklisp/setup.lisp") is all that is required to load quicklisp if it's already installed. You could add this form to your rc file.
<jdz>
Portacle homepage says it comes with Quicklisp.
<afidegnum>
there was a typo. but it works,
<afidegnum>
i was able to locate qucilisp
hhdave has joined #lisp
shangul has quit [Ping timeout: 258 seconds]
longshi has joined #lisp
<oni-on-ion>
agh that derailed quickly
<oni-on-ion>
he had slime going in emacs, can install quicklisp there.
<oni-on-ion>
"you cant install it in emacs" is quite a thing to say
momofarm has joined #lisp
<flip214>
is there a way to tell zpng to initialize the image to white?
longshi has quit [Quit: WeeChat 2.4]
longshi has joined #lisp
shangul has joined #lisp
afidegnum has quit [Ping timeout: 258 seconds]
<Nilby>
Just set the pixels, e.g: (loop for i from 0 below (length (zpng:image-data image)) do (setf (aref (zpng:image-data image) i) #xff))
<flip214>
Nilby: yes, of course that's possible.
<flip214>
but array allocation is likely to write some "sane" value into all pixels anyway, so why write twice?
<Nilby>
I suppose you could make the array yourself and give it an :initial-element of #xff.
cosimone has joined #lisp
<Nilby>
It looks like you could supply it with (make-instance 'zpng:png ... :image-data)
cranes has quit [Quit: leaving]
cranes has joined #lisp
gbiesiad has joined #lisp
campy_fellow has quit [Read error: Connection reset by peer]
campy_fellow has joined #lisp
v88m has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
cosimone has joined #lisp
gbiesiad has quit [Client Quit]
JohnMS_WORK has quit [Read error: Connection reset by peer]
JohnMS_WORK has joined #lisp
Kundry_Wag has joined #lisp
mingus has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
<flip214>
Nilby: correct.
<flip214>
still, it looks like a very common use-case to me, so IMO the library should support that.
<flip214>
Xach: ^^
<Nilby>
I like the simplicity of the library. Also transparent black is my favorite "sane" value.
Lord_of_Life has quit [Ping timeout: 258 seconds]
eabarbosa has quit [Ping timeout: 250 seconds]
<Nilby>
But it's true it's not obvious the best way to pre-set the image data.
Lord_of_Life has joined #lisp
eabarbosa has joined #lisp
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
<pjb>
oni-on-ion: I'm sorry, but I always assume people mean what they say. Not my fault if they're not able to say what they mean.
<pjb>
(If they were able to say what they mean, they wouldn't have to say it in the first place anyways).
<oni-on-ion>
true.. that catches me a lot in real life. i take everything face-value irl
Jesin has quit [Ping timeout: 246 seconds]
kajo has joined #lisp
Kundry_Wag has joined #lisp
paule32 has joined #lisp
<paule32>
hello
<paule32>
i have to say sorry, for the missunderstandings
<dim>
pjb: being able to say what you mean is a very rare gift, or only happens to people who never ever try to say anything complex, or open themselves to talking about their emotions and perceptions, so maybe try to be more a human than an english compiler?
Kundry_Wag has quit [Ping timeout: 244 seconds]
<dim>
anyway that's off-context, my backlog doesn't show me the relevant conversation, but I still though it's important to say that
eabarbosa has quit [Remote host closed the connection]
<paule32>
dim: i you point to me, .. i have a disscusion, and with my poor slengsh, and i was banned in #clschool
<oni-on-ion>
dim, i needed to hear that as well, ty
heisig has joined #lisp
<jackdaniel>
paule32: I saw quite a few discussions with you and what I've noticed is that you ignore given advices, so while I'm not on #clschool I can guess where the ban may come from
<paule32>
hello jackdaniel
<jackdaniel>
hello
<paule32>
the problem is, you (all) give me advices, and i tried to transform in do it your (me) self, so i am a little bit lame, and waste some time in playing with lisp, in this time, an other lisper give me hints, and as i was not answer, the lispers are wait and wait on reply of me, but i have some times no part back informations (most of things i am in a newbie
<jackdaniel>
the thing is that you ask for advice, then you reject it and person who spend time trying to educate you, well, wasted their time
heisig has quit [Quit: Leaving]
heisig has joined #lisp
<jackdaniel>
(and you reject it based on nothing, so it doesn't make really sense) - I'm saying it in good faith that you will try to reconsider this attitude (and I have nothing more to say on this topic)
<paule32>
how i said, my second problem is in understand and reply correct sentences...
igemnace_ has joined #lisp
igemnace has quit [Ping timeout: 258 seconds]
campy_fellow has quit [Read error: Connection reset by peer]
campy_fellow has joined #lisp
igemnace_ is now known as igemnace
cosimone has quit [Quit: WeeChat 2.3]
Kundry_Wag has joined #lisp
<moldybits>
(defun f (&rest keys) (apply #'g keys)) ; this works, but how could i specify the key parameters properly for f, and then only apply them to g if they were set? (defun f (&key a b c) ...)
campy_fellow has quit [Ping timeout: 258 seconds]
<moldybits>
i can combine key and rest, iirc, but that'd mess up the signature :s
campy_fellow has joined #lisp
<no-defun-allowed>
well, use (defun f (&rest r &key a b c) (apply #'g r))
Kundry_Wag has quit [Ping timeout: 246 seconds]
<moldybits>
yeah, but is there a nice way of doing it without the &rest r part
<Xach>
moldybits: no-defun-allowed is supercorrect
<Xach>
it is the best option
<no-defun-allowed>
that is the nice way
<moldybits>
it feels a bit leaky :s now you know i'm wrapping something, probably :p
<no-defun-allowed>
it was surprising to me when i learnt about it, but it is correct CL surprisingly
<moldybits>
i really like that it's possible :)
<no-defun-allowed>
ngl, it is a bit leaky just copying keyword arguments like that to me
<pjb>
(defun f (&rest keys &key a b c) (declare (ignore a b c)) (apply #'g keys))
<Nilby>
The real trouble comes when you have default values. :(
<pjb>
Nilby: depends if the default values are the same in f than in g.
samlamamma has joined #lisp
<pjb>
If they're not, then indeed, you need to pass the keywords.
<pjb>
(defun g (&key (a 0) (b 0) (c 0)) (list a b c)) (defun f (&key (a 1) (b 1) (c 1)) (g :a a :b b :c c) #|different defaults|#) (list (g) (f)) #| --> ((0 0 0) (1 1 1)) |#
<Nilby>
Which unfortunately happens more than I would like, even with standard functions.
<Nilby>
The sequence functions in particular.
<pjb>
(defun f (&rest keys &key a b c) (declare (ignore a b c)) (apply #'g keys)) (list (g) (f)) #| --> ((0 0 0) (0 0 0)) |#
shangul has quit [Remote host closed the connection]
<moldybits>
oh, well. this works. thanks no-defun-allowed and pjb!
<White_Flame>
the nuclear option would be to use a macro instead, which forces the syntax onto g right at the call site
<Nilby>
Thank goodness everything can be fixed with macros!
<jackdaniel>
even the most beautiful program may be "fixed" with macros ,)
fivo has joined #lisp
<Nilby>
jackdaniel: Maybe that's why I seem to need to start with something ugly to make any improvement.
<Nilby>
jackdaniel: But I actually don't like when I have to do that.
<jackdaniel>
Nilby: that was a joke. the point was that macros often obfuscate the code making it hard to read
<Nilby>
Perfect lambda list re-passing of complicated defaulting, etc, aguments seems like a little bit of glitch in CL.
<Nilby>
jackdaniel: I agree.
moei has joined #lisp
hjudt has quit [Quit: leaving]
<no-defun-allowed>
The beautiful programs are ugly too.
<jackdaniel>
sometimes something is and sometimes something isn't, what means that something may be something different than something ,-)
<jackdaniel>
that sometimes something may be*
<Nilby>
Now, I'm wondering how (call-next-method) works.
<jackdaniel>
from the programmer or implementation perspective?
<moldybits>
i want to be able to access slots as groups, for example the slots `x' and `y' as `position'. i wrote a macro that works but i wonder if it could be done better. for one, i'm not sure how to think about :before methods ...
<Nilby>
From the implementation.
<no-defun-allowed>
The method dispatcher picks the next applicable method in the same generic function, calls it, and returns its value(s).
<samlamamma>
moldybits: What's a `group'?
<jackdaniel>
it could have been implemented by means of local functions, but afair there is some code walking involved to eliminate unnecessary closures
<Nilby>
Now I see: walk-method-lambda
<jackdaniel>
you may look at PCL implementation
<jackdaniel>
(portable common lisp - base for sbcl's and ecl's implementation of CLOS module)
<White_Flame>
portable common loops?
longshi has quit [Ping timeout: 258 seconds]
<Nilby>
I think I wish for a funcall-like-me or something, that works semi-magically like call-next-method.
<jackdaniel>
White_Flame: yes, you are right, sorry
<shka_>
Nilby: could you please summarize what are you trying to do?
<flip214>
Nilby: If I understand you correctly, you want to pass the same argument to another function?
<mfiano>
Keep in mind you may experience different behavior across implementations by changing the arguments for the next applicable method. The safety level determines whether it will error or not, and different implementations have different default safety levels. CCL is more strict than SBCL in this regard for example.
<moldybits>
samlamamma: something like (defclass point () ((x :accessor x :initarg :x) (y :accessor y :initarg :y))) (make-slots-group point (x y) position vector elt) (position (make-instance 'point :x 1 :y 2)) => #(1 2)
<flip214>
How about &rest, or a compiler-macro, or (for debugging only) using TRACE?
<Nilby>
Yes, but getting every nuance of argument defaulting, supplied-p-parameters, etc, exactly correct.
<Nilby>
shka_: I'm not really trying to do it, just thinking about it. I usually use an "ugly" macro workaround if I have to.
<shka_>
Nilby: ok, so i would start by defining separate mechanism to handle lambda lists
<shka_>
probabbly as a objects
<flip214>
Nilby: (APPLY #'fn rest-arguments) should do the trick, as fn has to parse keyword arguments out anyway
<shka_>
if function wants to invoke other function, it may introspect lambda list of the function it is about to invoke
<shka_>
if it is compatible, call directly
<shka_>
otherwise, do extra magic
<shka_>
but i don't recommend doing this
<shka_>
overcomplicated
<Nilby>
shka_: That's interesting, I suppose one could make a "defun" that does that, similar to the code walking of defmethod to get call-next-method right.
<samlamamma>
moldybits: So (defmethod position ((point point)) (with-slots (x y) point (apply #'vector x y))) ?
<Nilby>
flip214: That works most of the time, but if you have arguments that weren't suppiled and got defaulted, then the are passed to the next function with the default values, instead of being not supplied.
<shka_>
Nilby: i would not bother with advance macro-magic, instead i would build object oriented protocol around funcallable objects
<shka_>
and some thin syntax sugar with macros on top
<shka_>
and voila, you can stuff all your extra informations into funcallable objects
<shka_>
next, i would add something like "invoke" that would actually attempt to introspect whatever it is about to funcall
<shka_>
but again, i think that it is very complicated and expensive solution to very hypothetical problem
<Nilby>
shka_: That sounds like a cool idea, and is indeed like the MOP. But so far I'm not bothered enought by it to do so.
<shka_>
yeah, exactly
<shka_>
anyway, my point is that you can literally embedd almost anything in the CL, and it may not need to be super extra macro heavy
<Nilby>
Maybe someday we'll have a CL which every function is a method and is just as fast.
<shka_>
just start with protocol
<Nilby>
Right, I like the protocol idea.
Necktwi has joined #lisp
<jackdaniel>
Nilby: there is work on that. Fast Generic Dispatch by Robert Strandth to improve runtime dispatch, inlined generic functions to resolve dispatch at compilation time, implementations may have optimizations for simple methods (which doesn't involve too much hacks)
amerlyq has joined #lisp
<mfiano>
I would also like to mention specialization-store for compile-time generic dispatch, even allowing specialization on optional/keyword arguments
<moldybits>
samlamamma: yeah, pretty much.
<Nilby>
Yes, similar to Dylan's "sealing" of types and functions.
alca has quit [Ping timeout: 245 seconds]
<Nilby>
sbcl has sb-ext:freeze-type, but maybe it could have freeze-class ?
alca has joined #lisp
crystalball has joined #lisp
<Nilby>
mfiano: I hope someday I'll have my code working well enough that specialization-store would help. It looks cool.
shangul has joined #lisp
crystalball has quit []
<shka_>
heisig actually works on something like java final
<shka_>
and it works
<shka_>
somehow, don't ask me how, i am not wizard enough to understand this
<shka_>
:|
Bike has joined #lisp
alca has quit [Ping timeout: 245 seconds]
alca has joined #lisp
esrse has quit [Ping timeout: 258 seconds]
dddddd has joined #lisp
nanoz has joined #lisp
longshi has joined #lisp
caltelt_ has quit [Ping timeout: 258 seconds]
eabarbosa has joined #lisp
amerlyq has quit [Quit: amerlyq]
kajo has quit [Ping timeout: 250 seconds]
<flip214>
Nilby: if some arguments weren't supplied, your &rest won't have them, and so they'll not passed on either
campy_fellow has quit [Ping timeout: 264 seconds]
campy_fellow has joined #lisp
libertyprime has quit [Quit: leaving]
kajo has joined #lisp
LiamH has joined #lisp
cosimone has joined #lisp
Lycurgus has joined #lisp
caltelt has joined #lisp
campy_fellow has quit [Ping timeout: 246 seconds]
samlamamma has quit [Remote host closed the connection]
<Nilby>
flip214: Thank you. But I've decided to just do (defmacro nil (&rest x) `(lambda ,@x)) and write the rest of my code using only quasi-quote.
<heisig>
Xach: Do you have a script that checks whether a project is well formed (license, description etc.)?
<heisig>
If so, could you add something like ql:rate-system?
<heisig>
Or would you accept such a feature if I implement it?
<Xach>
heisig: rate-system?
<Xach>
what is that for?
<heisig>
Something that library authors can run before submitting their project to quicklisp-projects.
<dlowe>
ql:validate-system maybe
anewuser has joined #lisp
<Xach>
heisig: i think of the word "rate" as giving a subjective rating of quality
<heisig>
Yes, "rate" is a bad term for this concept.
<shka_>
validate would be certainly a better word
<Xach>
i am in favor of the general idea
<Xach>
i need :license, :author, and :description. some form of README file is not checked but would be useful to highlight.
<shka_>
sounds like something relativly easy to do
<heisig>
One could also include some other community guidelines, e.g., how the :author argument should be formatted to make Quickref happy.
oni-on-ion has quit [Remote host closed the connection]
lavaflow has quit [Ping timeout: 258 seconds]
<heisig>
Xach: Should I hack a prototype and make a PR on quicklisp-client? Or should such a style guide be moved to a separate library?
<Xach>
heisig: I think it is suitable for quicklisp-client. I think it best to keep it extremely simple: check an asdf system for those three fields
gxt has quit [Ping timeout: 250 seconds]
q9929t has joined #lisp
caltelt has quit [Ping timeout: 245 seconds]
JohnMS has joined #lisp
minion has quit [Disconnected by services]
wxie has quit [Quit: wxie]
zcid- has joined #lisp
nckx- has joined #lisp
dru1d_ has joined #lisp
Arcaelyx has joined #lisp
vlatkoB_ has joined #lisp
amer has joined #lisp
jxy_ has joined #lisp
grewal_ has joined #lisp
cross_ has joined #lisp
shka__ has joined #lisp
logicmoo has joined #lisp
Ekho- has joined #lisp
Lord_Nightmare2 has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
amerlyq has quit [*.net *.split]
heisig has quit [*.net *.split]
Nilby has quit [*.net *.split]
sauvin has quit [*.net *.split]
ckonstanski has quit [*.net *.split]
vlatkoB has quit [*.net *.split]
lnostdal has quit [*.net *.split]
Lord_Nightmare has quit [*.net *.split]
v0|d has quit [*.net *.split]
grewal has quit [*.net *.split]
nckx has quit [*.net *.split]
wooden__ has quit [*.net *.split]
jxy has quit [*.net *.split]
HDurer has quit [*.net *.split]
zcid has quit [*.net *.split]
jasom has quit [*.net *.split]
dru1d has quit [*.net *.split]
gabot has quit [*.net *.split]
micro has quit [*.net *.split]
zcid- is now known as zcid
Lord_Nightmare2 is now known as Lord_Nightmare
nckx- is now known as nckx
JohnMS_WORK has quit [*.net *.split]
quazimodo has quit [*.net *.split]
dmiles has quit [*.net *.split]
libre-man has quit [*.net *.split]
Ekho has quit [*.net *.split]
eMBee has quit [*.net *.split]
shka_ has quit [*.net *.split]
cpape has quit [*.net *.split]
buhman has quit [*.net *.split]
kqr has quit [*.net *.split]
cross has quit [*.net *.split]
thornAvery has quit [*.net *.split]
isoraqathedh has quit [*.net *.split]
thijso has quit [*.net *.split]
brandonz has quit [*.net *.split]
Younder has quit [Remote host closed the connection]
shangul has quit [Remote host closed the connection]
shangul has joined #lisp
irdr has quit [Remote host closed the connection]
irdr has joined #lisp
heisig has joined #lisp
lnostdal has joined #lisp
sauvin has joined #lisp
libre-man has joined #lisp
kqr has joined #lisp
buhman has joined #lisp
gabot has joined #lisp
jasom has joined #lisp
brandonz has joined #lisp
lavaflow has joined #lisp
sjl_ has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
heisig has quit [Quit: Leaving]
Necktwi has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
dale has quit [Quit: dale]
anewuser has quit [Ping timeout: 244 seconds]
skidd0 has joined #lisp
<skidd0>
is there an (in-system) or (use-system)?
milanj has joined #lisp
Kundry_Wag has joined #lisp
<beach>
What would they do?
jprajzne has quit [Quit: Leaving.]
<Lycurgus>
like in-package but bigger
<skidd0>
^ yes
<skidd0>
interns all the stuff from a whole system
<Lycurgus>
in practice people do stuff with *features*
<beach>
skidd0: That's called (asdf:load-system ....).
<pjb>
(in-package "FOO")
<skidd0>
beach: but then do i still need to prefix symbols from that system?
<pjb>
A system may define 0, 1 or more packages.
Necktwi has joined #lisp
<pjb>
A system may mutate 0, 1 or more packages already existing.
<pjb>
skidd0: symbols can only be qualified by packages.
<beach>
skidd0: You should.
<pjb>
Systems are irrelevant to lisp objects.
<pjb>
They only serve to organize source files.
pankajgodbole has quit [Ping timeout: 258 seconds]
<skidd0>
i see
<pjb>
You NEED to qualify symbols with a package where they are accessible, when they're not accessible in the current package.
<pjb>
You can make them accessible in a package, by using a package that export them, or by importing them directly.
<Lycurgus>
a CL thing that dealt with implementations from more than an install perspective would be nice
<pjb>
What do you mean?
shifty has quit [Ping timeout: 258 seconds]
dale has joined #lisp
isoraqathedh has joined #lisp
<beach>
skidd0: I find the code much clearer when every symbol except the ones from the current package and from the COMMON-LISP package has an explicit package marker.
<skidd0>
i've been doing that in my source code
<dlowe>
which is why local package nicknames are nice
<skidd0>
but to play around with stuff in dev, i'm looking for a way to be lazy
<dlowe>
because then you can provide package markers that are short and understandable
ebrasca has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<skidd0>
and not need to 'my-package::some-in-dev-func
<skidd0>
but rather, (some-in-dev-dunc)
<Bike>
you could use-package those packages (from cl-user), and then unuse them later.
<Bike>
though thath won't help with unexported symbols.
<beach>
It would seem that the probability of a conflict would be huge.
<Bike>
eh, depends on the packages
<skidd0>
ah, that's my problem then. i was wondering why use-package wasn't finding the symbols
<skidd0>
not exported
<Lycurgus>
"few people have the imagination for reality" - a goethe quote just seen as an opening quote on a movie
kajo has quit [Ping timeout: 264 seconds]
Josh_2 has quit [Ping timeout: 258 seconds]
v0|d has joined #lisp
v88m has quit [Ping timeout: 246 seconds]
elinow has joined #lisp
<schweers>
I wish package local nicknames were in the standard
gbiesiad has joined #lisp
<jackdaniel>
schweers: they are adopted in four implementations already (sbcl, ccl, ecl and abcl)
<schweers>
In a way that one can use them portably between the four?
<schweers>
Also I didn’t know they were that widespread. I only new about sbcl and ccl.
<jdz>
Don't they all implement the same CDR?
v88m has joined #lisp
<jdz>
Now I'm wondering if there even is such a CDR...
<schweers>
I cannot find any
<jdz>
My guess is that SBCL's interface is good and small enough and is the one implemented in other implementations.
hjudt has joined #lisp
<jackdaniel>
there is no cdr
<jackdaniel>
other three implementations adopted a specification from sbcl
<jackdaniel>
so they should be compatible (+/- bugs / later additions in sbcl)
<schweers>
Apparently clasp also supports this.
<jackdaniel>
in ecl it is in develop branch (I've added it *after* 16.1.3 release)
<schweers>
so this seems to be about as portable and stable as MOP, right?
<skidd0>
well so that import-export is exporting all the external symbols of the packages
<skidd0>
i see
<pjb>
skidd0: yes, because I actually define a com.inforamtimago.pjb package, export them from here, and use this package in cl-user.
ebzzry has joined #lisp
Ekho- is now known as Ekho
<ebzzry>
Xach: ping
<ebzzry>
Xach: you may already be aware that the certificate chain of quicklisp.org is incomplete. just a reminder.
<ebzzry>
the certificate will also expire in 6 days
cosimone has joined #lisp
khisanth_ has joined #lisp
kajo has joined #lisp
v0|d has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
v0|d has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
Kundry_Wag has quit [Ping timeout: 252 seconds]
edgar-rft has quit [Quit: Leaving]
d4ryus has joined #lisp
gbiesiad has joined #lisp
housel has quit [Ping timeout: 245 seconds]
<flip214>
Xach: how about giving zpng an easy way to initialize a new image to white/black/transparent, directly via the MAKE-INSTANCE call?
<flip214>
"easy" as in "it's not required to calculate dimensions of an array, allocate and/or set it"
<flip214>
"easy" as in (make-instance 'zpng:png :canvas-is :black)
elinow has quit [Read error: Connection reset by peer]
v88m has quit [Remote host closed the connection]
v88m has joined #lisp
longshi has quit [Ping timeout: 245 seconds]
igemnace has quit [Quit: WeeChat 2.4]
igemnace has joined #lisp
Josh_2 has joined #lisp
Kundry_Wag has joined #lisp
<Josh_2>
I have this sammich maker which I made for exercise 2.3 from PAIP https://plaster.tymoon.eu/view/1393#1393 I was wondering how I would make selection of specific types of fillings based on some rulesfor example if I have cheese then I don't want meat etc
v88m has quit [Remote host closed the connection]
Nilby has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
schjetne has quit [Ping timeout: 250 seconds]
<sjl_>
bug report: horseradish is misspelld
<sjl_>
(it is my favorite condiment)
<Josh_2>
Sorry :P
nanoz has quit [Ping timeout: 245 seconds]
rippa has joined #lisp
varjag has joined #lisp
v88m has joined #lisp
jkordani has joined #lisp
LiamH has quit [Quit: Leaving.]
Lycurgus has quit [Quit: Exeunt]
varjag has quit [Ping timeout: 245 seconds]
v88m has quit [Ping timeout: 245 seconds]
pfdietz has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
<gaze___>
hey I think I'm misunderstanding something very basic about quoting. When something is quoted, does the reader go "inside" the quote and convert anything inside the quote into a reference to something, or is a quoted list just... a list of words and nothing else?
<beach>
gaze___: when the reader sees the ' character, it recursively calls itself to read what follows.
<beach>
gaze___: It then returns the list (quote <the-result-of-the-recursive-read>)
q9929t has quit [Quit: q9929t]
<gaze___>
if I have a (defun x (...) ...) ... (quote x), is there now a reference to x hanging around, or is it just the name "x" hanging around?
<gaze___>
egh I'm not phrasing this right
<beach>
Your question has nothing to do with the reader.
charh has quit [Remote host closed the connection]
<gaze___>
oh, sorry
<beach>
Oh, maybe it does.
<beach>
Yes, the two occurrences of x refer to one and the same symbol.
<gaze___>
okay then let's say I have (defun x (...) ...) ... (quote x y)
campy_fellow has quit [Ping timeout: 264 seconds]
<gaze___>
where y isn't... anything
<beach>
Well, that happens to be illegal code.
<beach>
gaze___: Read is going to create the symbol y in the current package, or return the existing symbols if it does exist.
<Bike>
(quote (x y)) will evaluate to a list of symbols. whether those symbols name functions is immaterial.
FreeBirdLjj has quit [Remote host closed the connection]
<gaze___>
okay I think we're getting closer to what I want to know... what exactly is a symbol then? does a symbol have to point to something or is a symbol just a name?
<beach>
A symbol is an object that contains slots.
<Bike>
it's just a name.
<beach>
Among others, one slot contains the string that names the symbol.
varjag has joined #lisp
<beach>
gaze___: What do you mean by "point to something"?
gbiesiad has quit [Quit: gbiesiad]
<gaze___>
I'm trying to think about how the GC marks things
<fivo>
beach: Hey, I have a question concerning this piece of code.
<beach>
gaze___: Common Lisp uses what I call "uniform reference semantics", which means that it is as if every object is represented by a reference, or a pointer.
<fivo>
beach: it's probably a bit of a fuzzy question
<Josh_2>
fivo: my opinion is that is pretty code
<beach>
fivo: Go ahead.
<fivo>
I am using the notation from the commands in that file
<gaze___>
well, the GC is gonna mark stuff that stuff points to, right?
<beach>
gaze___: Indeed.
<fivo>
Wouldn't it be somehow possible annotate R with the source locations before the macroexpand
<gaze___>
if a symbol is mentioned in a quote, then is that symbol considered "pointed to"?
<fivo>
And then reconstruct all T' after that
<beach>
gaze___: Yes, it is referred to by the list that the reader returns, as I told you.
<fivo>
s/all/all of/
<gaze___>
AHHH ok!
<beach>
fivo: Let me check the notation...
varjag has quit [Ping timeout: 245 seconds]
<beach>
fivo: No, because the macroexpander takes a raw Common Lisp list, without any annotations.
<fivo>
I am not sure I make sense, but essentially annotate every subexpression of R with source location and then somehow do the macroexpansion
<fivo>
ok so one would need to write some special macroexpander
<fivo>
?
<beach>
fivo: The macroexpander would not know what to do with those annotations.
<beach>
fivo: Yes, and that has been suggested in fact.
<fivo>
beach: I am just asking if it is not possible at all
<Bike>
gaze___: whether it's quoted doesn't matter. (list 'x) '(x) (list (find-symbol "X" "WHATEVER-PACKAGE")) are all forms that return lists that refer to the symbol (so the GC would follow through)
gbiesiad has joined #lisp
<fivo>
beach: I admit probably difficult
<beach>
fivo: It is possible to write such a macroexpander.
schweers has quit [Ping timeout: 252 seconds]
<beach>
fivo: scymtym has suggested using an interpreter for the body of the macroexpander.
<beach>
fivo: Maybe he can help you with the details if you are interested.
<fivo>
beach: ok should I ping him tomorrow?
<beach>
I think he is still around.
<gaze___>
gotcha. Okay. I gotta run. Thanks for the help!
<scymtym>
leaving now
<beach>
Oh. OK.
Kundry_Wag has quit [Remote host closed the connection]
<Bike>
an interpreter...?
<beach>
As I recall, yes.
<Bike>
i'm kind of curious how this goes
<fivo>
me too
Kundry_Wag has joined #lisp
<beach>
The main difficulty is that anyone can define a macro, so the body of the macro can't be turned into normal code, because then it would operate on raw Common Lisp expressions.
Kundry_Wag has quit [Remote host closed the connection]
<beach>
So you would have to interpret or compile that code in a way that, when it operates on CONSes, like with CAR, CDR, CONS, it would instead have to emit the corresponding operation for the CST.
nanoz has joined #lisp
campy_fellow has joined #lisp
<beach>
I am not sure I understand how it would be possible in general.
<beach>
I mean, a macro expander can call any Common Lisp code to transform the argument.
<beach>
I think it would be best that scymtym explained it himself.
<Josh_2>
Is anyone able to offer some advise on me problem?
<Josh_2>
I can just move on It's no biggy, I was just curious
hhdave has quit [Ping timeout: 245 seconds]
varjag has joined #lisp
karlosz has joined #lisp
dkmueller has joined #lisp
campy_fellow has quit [Ping timeout: 258 seconds]
varjag has quit [Ping timeout: 244 seconds]
manualcrank has joined #lisp
<jgkamat>
if any of you guys use the next browser, please update to the latest version, older versions had an RCE exploit
campy_fellow has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
longshi has joined #lisp
gbiesiad has joined #lisp
<grewal_>
Josh_2: It gets complicated if you want to stick to maintaining a grammar.
<grewal_>
A simple way would be to have, e.g., (meat-filling (cheese) (meat)). And then change your rules to choose one of them.
cosimone has quit [Quit: WeeChat 2.3]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
<grewal_>
Doing something like that quickly blows up the number of rules you have, so you might want to create a shortcut like (filling (2 *) (spread veg sauces herbs meat-filling)) where (2 *) means choose any 2,3,..., or all of the following items
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
<_death>
there's no need to constrain the specification to a "grammar".. you can just describe what you want in the most direct way and have an "engine" interpret it to provide the required outputs.. if performance becomes an issue you can then tweak the specification, add a compilation stage, etc.
<aeth>
I mean, really, it goes full circle when someone ports that to Parenscript because it's more functional than the actual left-pad
<no-defun-allowed>
Just wait until everyone depends on it.
<aeth>
no-defun-allowed: unfortunately, I can't just remove it from Quicklisp without warning once half of Quicklisp indirectly depends on it and instantly break everyone's code
<no-defun-allowed>
rip
longshi has quit [Ping timeout: 252 seconds]
<aeth>
It really does seem like a dead joke 3 years later. And in a few years, no one will get the joke.
<Xach>
i find it pretty dumb but i don't judge that kind of thing when it comes to adding
cropcircle has quit [Read error: No route to host]
notzmv has joined #lisp
<aeth>
It's a 3 years old April Fools project that got almost no attention on April Fools 3 years ago.
Xaleth has joined #lisp
Xaleth has left #lisp ["WeeChat 2.2"]
<aeth>
In 2017, I did a functional Brainfuck for April Fools, which I think is more useful than trivial-left-pad. I didn't do any jokes for 2018 or 2019 because I think the Internet has kind of killed April Fools Day in general. I didn't even go on the web at all last April 1st.
longshi has joined #lisp
Bike has quit []
_leb has quit []
LiamH has quit [Quit: Leaving.]
Lord_of_Life_ has joined #lisp
longshi has quit [Ping timeout: 248 seconds]
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
stux|RC has quit [Ping timeout: 245 seconds]
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
caltelt has joined #lisp
lumm has quit [Quit: lumm]
shifty has joined #lisp
sjl_ has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: WeeChat 2.3]
moei has quit [Quit: Leaving...]
mindCrime_ has joined #lisp
mindCrime_ has quit [Ping timeout: 258 seconds]
mindCrime has joined #lisp
libertyprime has joined #lisp
wxie has joined #lisp
nirved has quit [Read error: Connection reset by peer]
rpg has quit [Ping timeout: 244 seconds]
pillton has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
Bike has joined #lisp
nowhereman has quit [Ping timeout: 246 seconds]
nowhereman has joined #lisp
rpg has joined #lisp
pierpal has joined #lisp
wxie has quit [Quit: wxie]
pierpal has quit [Ping timeout: 248 seconds]
<rpg>
Does anyone know if there's a library that would do pattern-matching or unification specifically for hash-tables or property lists? I.e., structures with named components?
<rpg>
This does not seem like rocket science, but it seems like something someone might well have done before.
<Bike>
optima can do that, i think?
hugotty has quit [Quit: ZNC 1.6.5+deb1+deb9u1 - http://znc.in]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rpg has joined #lisp
<rpg>
Bike: I imagine it could, yes. I'd like unification better than pattern matching, though, if I can get it.
<Bike>
oh, yeah, i don't think optima does that
<rpg>
cl-unification doesn't really do unification, because of its templates, so it's not a symmetrical operation like unification.
rpg has quit [Client Quit]
rpg has joined #lisp
<rpg>
I'm really just looking for the ability to unify something that's like a hash-table, or a python dictionary...
<rpg>
that's a lot less demanding than trying to do unification for all of CL like CL-Unification.
<White_Flame>
yeah, it's not rocket science, but it is a bit more involved than matching positional lists/tuples, so it's a bit more rare
<rpg>
I think the trickiest bit is that one needs a path language for the results. E.g., if you unify a dictionary with no entry for :x with a dictionary that has an entry for :x which itself has an entry for :y, that is 'foo, then the resulting binding set must have a way of representing the path :x -> :y -> 'foo
<White_Flame>
I don't think the binding results of unification would be any different