dialectic has quit [Remote host closed the connection]
dialectic has joined #lisp
frgo has joined #lisp
amerlyq has quit [Quit: amerlyq]
frgo has quit [Ping timeout: 245 seconds]
DaveLib has joined #lisp
<DaveLib>
hello i am running sbcl i am trying to compile a common lisp program i just downloaded : clfswm common lisp full screen window manager i just tried and got an error message last month i came to this channel and someone here solved it for me by giving me a single line lisp command to insert into the lisp spurce code i recall the issue was to add an item to a PATH variable since then my computer crashed and i lost my old files
<DaveLib>
i was wondering if someone here could find this solution again
<White_Flame>
I don't know about that specific error, but the first problem to solve is one of having good backups.
<DaveLib>
yes i reinstalled my os after the crash and this time i did a separate home partition so i can reinstall oif necessary without losing my personal files
<White_Flame>
git is nice for easily replicating project directories
<pjb>
DaveLib: wait a second, I'll just engage my telepathic debugging gear… hold on.
<DaveLib>
Thanks saturn2: i found the old solution in those logs i will try it again it worked for me last time
kdas_ has joined #lisp
kushal has quit [Ping timeout: 260 seconds]
frgo has joined #lisp
<stacksmith>
aeth: I wrote a macro 'with-' that automatically (or manually) creates package-local accessors to struct, class or foreign object instances and can prefix them on per-instance basis. It can use existing instances or create new ones (including temporary CFFI foreign objects). It can also combine multiple with- style macros, and bind single or multiple values. http://github.com/stacksmith/cl-with
<aeth>
elaborate
igemnace has quit [Remote host closed the connection]
<dialectic>
Lord almighty.
<stacksmith>
Well, it uses the same syntax for all slotted objects, and lets you, in a single statement, use any number of objects with different prefixes for slots...
<dialectic>
"One let to rule them all..."
frgo has quit [Ping timeout: 248 seconds]
<dialectic>
stacksmith: How do I use with-foo if it's in another package? I have to explicitly import?
<stacksmith>
(with- ( :foo ...))
<dialectic>
I think you misread that but that's ok
<stacksmith>
Oh, I see what you mean.
<dialectic>
That's not a bad tradeoff.
<stacksmith>
Yeah, it is a bit of a pain - if it starts with a symbol it assumes it's a binding, not a with- aggregation...
<stacksmith>
I tried a few different ways, but it is most natural to have the symbol in the first position be a binding... A list for multiple values. A keyword for with- macros.
<dialectic>
Just add one more clause. If it starts with a list and the CAR is QUOTE, it's like the keyword case.
<dialectic>
If you're doing a multiple-value-bind and one of your new bindings is the symbol QUOTE, you're a bad person.
<stacksmith>
Actually, the way it stands you always create bindings in *package*. So if you specify a symbol in another package it can always treat it as a with-... clause.
<stacksmith>
Unless that package is locked, I suppose.
<stacksmith>
Quote would work too.
igemnace has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
frgo has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<stacksmith>
dialectic: thanks, I will add the quote syntax.
<dialectic>
Haha. If you think it's useful.
frgo has quit [Ping timeout: 246 seconds]
<stacksmith>
I think it's useful. Anyway, I just did it. I don't ever want to look at this code again, and I can imagine a with-macro in another package situation... My idea of always using local bindings sucked - with :old you use existing bindings which could well be in another packege...
DaveLib has left #lisp ["ERC (IRC client for Emacs 26.2)"]
igemnace has quit [Remote host closed the connection]
wigust- has joined #lisp
wigust has quit [Ping timeout: 248 seconds]
dacoda has quit [Remote host closed the connection]
frgo has joined #lisp
Oladon has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
simplegauss has quit [Ping timeout: 244 seconds]
hdasch has quit [Ping timeout: 248 seconds]
eschatologist has quit [Excess Flood]
eschatologist has joined #lisp
simplegauss has joined #lisp
GoldRin has joined #lisp
dacoda has joined #lisp
igemnace has joined #lisp
kdas_ has quit [Ping timeout: 260 seconds]
cantstanya has quit [Ping timeout: 260 seconds]
kushal has joined #lisp
cantstanya has joined #lisp
dacoda has quit [Remote host closed the connection]
elderK has joined #lisp
dialectic has quit [Ping timeout: 245 seconds]
dacoda has joined #lisp
frgo has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
dialectic has joined #lisp
<beach>
Good morning everyone!
igemnace has quit [Quit: WeeChat 2.5]
dvdmuckle has quit [Quit: Bouncer Surgery]
dvdmuckle has joined #lisp
<elderK>
Good morning, beach!
frgo has joined #lisp
ggole has joined #lisp
frgo has quit [Ping timeout: 248 seconds]
makomo has quit [Ping timeout: 246 seconds]
dialectic has quit [Ping timeout: 244 seconds]
torbo has joined #lisp
akoana has left #lisp ["Leaving"]
frgo has joined #lisp
frgo has quit [Ping timeout: 258 seconds]
_whitelogger has joined #lisp
dialectic has joined #lisp
Tristam has quit [Ping timeout: 245 seconds]
_whitelogger has joined #lisp
frgo has joined #lisp
PuercoPop has quit [Quit: ZNC 1.6.3 - http://znc.in]
frgo has quit [Ping timeout: 248 seconds]
froggey has quit [Ping timeout: 245 seconds]
torbo has quit [Remote host closed the connection]
froggey has joined #lisp
igemnace has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
martylake_ has joined #lisp
martylake has quit [Ping timeout: 245 seconds]
frgo has joined #lisp
frgo_ has joined #lisp
frgo has quit [Read error: Connection reset by peer]
dialectic has quit [Ping timeout: 248 seconds]
Arcaelyx has quit [Ping timeout: 245 seconds]
frgo_ has quit [Ping timeout: 258 seconds]
Lycurgus has joined #lisp
ober has joined #lisp
_whitelogger has joined #lisp
<LdBeth>
Good afternoon
<LdBeth>
Oh, I missed the discussion on CLFSFM
orivej has quit [Ping timeout: 245 seconds]
frgo has joined #lisp
frgo has quit [Ping timeout: 248 seconds]
vlatkoB has joined #lisp
_whitelogger has joined #lisp
frgo has joined #lisp
martylake_ has quit [Ping timeout: 248 seconds]
equwal has quit [Ping timeout: 248 seconds]
ggole has joined #lisp
dacoda has joined #lisp
djeis[m] has joined #lisp
sigjuice has joined #lisp
nirved has joined #lisp
gko has joined #lisp
otwieracz has joined #lisp
jonh has joined #lisp
sciamano has joined #lisp
avicenna has joined #lisp
techquila has joined #lisp
CEnnis91 has joined #lisp
khrbt has joined #lisp
billstclair has joined #lisp
mulk has joined #lisp
drmeister has joined #lisp
housel has joined #lisp
pent has joined #lisp
chewbranca has joined #lisp
uplime has joined #lisp
grumble has joined #lisp
remexre has joined #lisp
no-defun-allowed has joined #lisp
Jachy has joined #lisp
iskander has joined #lisp
banjiewen has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
khisanth_ has quit [Ping timeout: 268 seconds]
mgsk has quit [Ping timeout: 272 seconds]
v88m has quit [Ping timeout: 248 seconds]
mgsk has joined #lisp
v88m has joined #lisp
antonv has joined #lisp
stacksmith has quit [Ping timeout: 258 seconds]
khisanth_ has joined #lisp
<Godel[m]>
Do any functions that fact calls need to be inside the eval-when?
<LdBeth>
Yes
<LdBeth>
Or already loaded into the environment when compiling the file
<LdBeth>
Since a compiler can ignore inline declarations
<Godel[m]>
I see. Thanks.
garbochock has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
antonv has quit [Ping timeout: 245 seconds]
Nikotiini has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
<no-defun-allowed>
Here is a silly question: does flet use lexical or dynamic binding?
<beach>
Lexical.
<no-defun-allowed>
Right, thanks.
<beach>
(FLET ((FUN (...) ...)) ...) is basically the same as (LET ((FUN (LAMBDA (...) ...)) ) ...) except that in the first case, FUN is in the function namespace, and in the second case, it is in the variable namespace.
frgo has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
Gotcha.
<LdBeth>
Is there a dynamic binding namespace for functions?
CloseToZero has joined #lisp
<beach>
Nope.
wxie has joined #lisp
fragamus has joined #lisp
<fragamus>
hi can macros write other macros
<LdBeth>
Yes
<beach>
fragamus: Sure, a macros is just a function that takes a form and returns another form.
<fragamus>
ok and the new macro can be used by code as part of the same compilation right
<beach>
fragamus: But your question is ambiguous. Do you mean that another macro is defined DURING THE EXPANSION of the first one, or BY THE EXPANDED FORM?
<fragamus>
during the expansion of the first one
<beach>
fragamus: You typically don't want to do that. It is best if macro functions are side-effect free.
<beach>
fragamus: It is probably best if you explain your use case.
<fragamus>
im writing a lisp
Nikotiini has joined #lisp
<fragamus>
so i must support the dynamic compilation of those side effect macros right
<LdBeth>
Usually there is a staging limitation, the reason is obvious: you cannot can a function not yet loaded into the environment
<LdBeth>
*can -> call
<beach>
fragamus: Is your implementation an implementation of Common Lisp?
<fragamus>
no
<beach>
Then you can do whatever you want.
<fragamus>
well i want it to conform to the spirit of common lisp
<beach>
fragamus: OK, so what do you mean by "dynamic compilation"?
<LdBeth>
I think fragamus over complicates the work
<fragamus>
once macro code gets generated dynamically, and some lisp code is generated also which refers to the new macro, then that is part of the expansion
<fragamus>
and so I need to compile that macro and run it as part of the expansion
<LdBeth>
fragamus: in Common Lisp, the compiler comes with the runtime
<LdBeth>
So you just have to call the compiler
<fragamus>
yeah ok
<fragamus>
thanks that seems clear now
<LdBeth>
If you’d like to make all the things “static” that’s not trivial. Although not completely impossible.
<fragamus>
ok
<beach>
fragamus: I agree with LdBeth. In Common Lisp, a macro definition (by DEFMACRO) is turned into a macro function that is compiled after the DEFMACRO form has been expanded.
<beach>
fragamus: When a macro call is encountered by the compiler, the compiler executes the macro function to obtain an expansion, and then compiles the expanded form instead.
<beach>
fragamus: It is that simple.
<fragamus>
ok that is simple
<fragamus>
the expansion subsumes the original
<beach>
Yes, and there is no "dynamic" compilation of the macro definition. It is done once when the macro definition is encountered.
<beach>
fragamus: In fact, DEFMACRO is itself a macro that expands to something like (setf (macro-function ...) (lambda (form environment) ...))
<fragamus>
and it can expand again if the expanded form calls another macro right
<beach>
Yes, the compiler keeps expanding until the form is no longer a macro form.
<fragamus>
ok that is clear now
<beach>
That is kind of implied by the fact that it compiles the expanded form in place of the macro form. It doesn't treat the expanded form any differently from other forms.
<fragamus>
it is very cool
<fragamus>
i have been working in other languages and I have always had lisp envy
<beach>
So you start by writing yourself a Lisp system that is not an implementation of Common Lisp?
<beach>
That's very ambitious.
<fragamus>
yeah
<fragamus>
because
<fragamus>
im so badass
<LdBeth>
fragamus: I’d recommend a minimal Lisp implementation standard called ISLISP
<fragamus>
the main thing I need is macros
<fragamus>
other languages with their syntactic sugar always have inferior macro systems
<fragamus>
thats why I vae always had lisp envy
frgo has joined #lisp
<LdBeth>
Or maybe you could lookup hygienic macro or other meta programming technology, even call by need evaluation that does some sort similar thing to macros
wxie has quit [Quit: wxie]
<fragamus>
I shall look into that
<Godel[m]>
About the read time evaluation macro, if the result of evaluation is a struct, sbcl says it doesn't know how to dump a struct (I'm not dumping a runtime image though). Is there a way to tell it how to dump it? Or is there a list of types it knows how to dump?
<LdBeth>
Göd.el: it’s a little hard to comprehend but you can search some tutorial thing about it
<aeth>
Godel[m]: in particular, the last example is helpful with a lot of structs
<aeth>
it often is really that simple
<fragamus>
sometimes people don't get why syntactic sugar causes problems. I need compelling reasoning to drive the point home
<fragamus>
they are like "whats wrong with our macro system it works fine"
<aeth>
syntactic sugar is great, I just don't want to wait until the next version of the language to get it (and in the case of CL, that would be quite the wait!)
<beach>
fragamus: Are you trying to convince someone else to use Lisp? It is nearly impossible to convince people, because there are very strong psychological forces involved.
<fragamus>
yeah
<LdBeth>
fragamus: it usually means the reader of your code have to spend extra time to understand how those syntax works if you didn’t design these properly or these are not well documented
<fragamus>
is the psychologhical force of stupidity part of it
<beach>
fragamus: No. It happens to very smart people too. Carol Dweck calls it a "fixed mindset". She has some good talk available on YouTube.
makomo has joined #lisp
zhlyg has joined #lisp
<LdBeth>
In the meantime, if that’s a well recognized thing (in the domain of problems you want to solve) that haven’t been introduced into the programming language, that should work reasonably fine
<aeth>
It takes a lot of time to master a programming language, which is a time investment people don't want to repeat, even if it's faster the more you do it.
<ck_>
I have less trouble understanding the absence of popularity of lisp than the popularity of other languages, like Java for example
<beach>
aeth: Yes, but the point is that they don't even reason about it.
<fragamus>
yeah because extending java is possible if you have 5 years and 100 people
<jackdaniel>
some people criticize lisp for being to easy to work with, as in: it is easier to wrap "scratch-my-itch" hack than to contribute to existing solution
<ck_>
there's definitely a point to that, jackdaniel
<jackdaniel>
what leads to many incomplete libraries with overlapping purpose
<jackdaniel>
I don't have an opinion here, just thought it is a good idea to mention it
<fragamus>
thats preferable to 5 years and 100 people
<ck_>
yes, exactly. I once attended a talk about "finding a good cond-let library" (for clojure)
<fragamus>
it makes it possible for the thing to evolve
<beach>
fragamus: I don't think you have any evidence for precise numbers like that.
<jackdaniel>
if I had to play devil's advocate I'd say, that I'd prefer one complete library after 5y than 100 incomplete libraries in a week
<ck_>
baffling. There's probably three dozen cond-let macros people have whipped up in half an hour around
<ck_>
Well it's not like lisp is all impromptu and no planning. The (Hyper)spec is a great achievement.
<no-defun-allowed>
(defmacro if-let ((variable value) then else) `(let ((,variable ,value)) (if ,variable ,then ,else))) ; three dozen and one
<ck_>
cond-let, not if-let :) But yes, that's the point.
<fragamus>
java is all impromptu with its evolving syntax
<no-defun-allowed>
ck_: budget cuts
<fragamus>
the syntax is a nightmare
<jackdaniel>
I can't help but remind you, that Java is not in the channel topic
<jackdaniel>
bashing it belongs to #lispcafe
<fragamus>
ok flame off
<fragamus>
jackdaniel: just remember when you play devil's advocate, you are merely saying what satan would say
<jackdaniel>
well, I like Common Lisp and I work with it a lot, but this language has serious flaws neverless, so I'm far from calling it panacea (and shy away from comparing with other languages)
<ck_>
why the last part?
<jackdaniel>
because such criticism would be very flawed unless I'm expert in *both* languages
<aeth>
yes
<jackdaniel>
I can compare CL with C: both languages are different, have different purpose and are incomparable
<ck_>
Okay I disagree somewhat. Of course different languages have different paradigms and a direct comparison is not always fruitful. But to say you shouldn't compare anything at all between languages is throwing out the contents with the bathwater
<jackdaniel>
no, I'm just saying that it is too often seen that people compare A to B where they know only A in fact
<jackdaniel>
think how silly it sounds when someone says, that Lisp has too many parenthesis
<ck_>
Right, I can agree with that.
<jackdaniel>
and I see it too often to have trust in such comparisons
<aeth>
jackdaniel: I think the library issue is just because of who's making the libraries for CL. Almost entirely amateur projects.
<fragamus>
I think non-lisp languages require one to inhale the syntax in order to properly step over it when meta-programming
nowhereman has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<LdBeth>
fragamus: blob languages can do meta programming, the first of them is Meta Language
<LdBeth>
* I mean the first designed to do so
notzmv has joined #lisp
<LdBeth>
Since there’s a lot of string rewrite based languages before or near when lisp invented
<LdBeth>
And many believes that string rewrite systems contributed lisp’s macro
frgo has joined #lisp
notzmv has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
<Godel[m]>
LdBeth: Looks like SBCL does know how to dump structures without needing make-load-form iff the struct definition is evaluated before the call to dump it. I hadn't put the struct definition in eval-when.
frgo has quit [Ping timeout: 248 seconds]
random-nick has joined #lisp
<LdBeth>
GG
Gnuxie[m] has quit [Write error: Connection reset by peer]
katco has quit [Write error: Connection reset by peer]
Godel[m] has quit [Remote host closed the connection]
djeis[m] has quit [Remote host closed the connection]
sciamano has quit [Write error: Connection reset by peer]
dtw has quit [Write error: Connection reset by peer]
colelyman has quit [Remote host closed the connection]
no-defun-allowed has quit [Remote host closed the connection]
Jachy has quit [Read error: Connection reset by peer]
LdBeth has quit [Remote host closed the connection]
iarebatman has quit [Remote host closed the connection]
Trivulzianus has quit [Remote host closed the connection]
akanouras has quit [Read error: Connection reset by peer]
liambrown has quit [Write error: Connection reset by peer]
v88m has quit [Read error: Connection reset by peer]
irdr has quit [Remote host closed the connection]
v88m has joined #lisp
irdr has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
akanouras has joined #lisp
no-defun-allowed has joined #lisp
<no-defun-allowed>
Göd.el: prolly would be helped by sharpsign S
v88m has quit [Read error: Connection reset by peer]
lnostdal has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
frgo has joined #lisp
frgo has quit [Ping timeout: 272 seconds]
v88m has joined #lisp
Godel[m] has joined #lisp
mulk has joined #lisp
v88m has quit [Ping timeout: 245 seconds]
garbochock has quit [Ping timeout: 272 seconds]
v88m has joined #lisp
frgo has joined #lisp
frgo has quit [Read error: Connection reset by peer]
frgo has joined #lisp
<Godel[m]>
I just noticed, upon putting defuns inside `(eval-when (:compile-toplevel :load-toplevel :execute) ... )`, CCL doesn't compile those functions, and I get `Undefined Function` errors. SBCL works fine.
<Godel[m]>
I have to evaluate the defuns by sending them to repl with CCL.
<Godel[m]>
(I mean, I get the errors from the toplevel (sly) not when I call them inside the file.)
<beach>
Godel[m]: The standard allows for the compilation environment to be different from the startup environment.
<beach>
So it is possible that CCL defines the function in the compilation environment and then discards that environment once the compilation is done.
<beach>
In fact, that is the preferable behavior, in my opinion.
<Godel[m]>
I see.
<Godel[m]>
Why is it preferable?
<beach>
Because compiling a file should not have any side effects on the run-time environment.
josemanuel has quit [Quit: leaving]
Trivulzianus has joined #lisp
<Godel[m]>
I have an asdf package, I compile it and switch to the package, should I expect the symbols in it to be loaded after compilation of all the files?
<beach>
OK, let's try some correct terminology. I take it you have an ASDF *system* (not a package), right?
<beach>
How do you "compile it"?
heisig has joined #lisp
<Godel[m]>
sorry, I meant loading an asdf system.
<Godel[m]>
`(ql:quickload :somesystem)`
<beach>
When the compiled files in the system are loaded, you will see all the side effects of all the top-level forms in the files.
<Godel[m]>
`(in-package :somesystem)`
libre-man has quit [Ping timeout: 244 seconds]
<beach>
So the effect should be very closed to the effect you get if you LOAD all the source files.
fragamus has quit [Ping timeout: 244 seconds]
libre-man has joined #lisp
<Godel[m]>
Let me try it again.
<beach>
How about giving an example instead?
lnostdal has joined #lisp
kajo has quit [Ping timeout: 264 seconds]
<beach>
Any symbol without a package marker, or with an explicit package marker in any of the files will typically exist.
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
<beach>
Not sure about names of lexical variables in a system where the packages are created only in the compilation environment.
<Godel[m]>
I'll get back in a few minutes.
<beach>
OK, I have the answer to that...
<beach>
Names of lexical variables that are not otherwise needed in the compiled code (like, say, for debugging purposes) are not necessarily present after the system has been loaded.
<beach>
Example: Put this in a file: (defun ff (xxx) (1+ xxx)) or something like that. Start SLIME. Type (proclaim '(optimize (debug 0) (speed 3))) and then (compile-file <name-of-lisp-file>).
<beach>
This is SBCL I am trying now, so now, restart your Common Lisp system by typing ,restart or something like that.
<beach>
Then load the FASL file.
<beach>
Finally try (find-symbol "XXX").
<beach>
The symbol does not exist.
<beach>
However, since SBCL does not distinguish between the compilation environment and the startup environment, if you stay inside your running SBCL system, compiling the file will create the symbol XXX, simply because the file is being read by READ.
grumble has quit [Quit: inside their machines there is one empty file]
<Godel[m]>
Thanks
<Godel[m]>
So if I call those functions, and have them otherwise needed, they should stay...
gurmble has joined #lisp
gurmble is now known as grumble
<Godel[m]>
(when I call...)
wxie has joined #lisp
<Godel[m]>
Actually, that's not what happens for me in case of sbcl 1.5.4. I compiled a file (test.lisp) with a factorial function, and load it with `--load test.fasl`, then when I evaluate `(find-symbol "FACT"), FACT is returned, an internal symbol. Contents of the test file: https://bin.disroot.org/?6b6ddb183282a081#L4vdMR3Q+IgLCcikl6+2uZpBq1g5xtkIzaF0q8Dtk8k=
<ck_>
did you compile the fasl with the debug and speed settings beach mentioned?
<Godel[m]>
I used declare, not proclaim
cosimone has quit [Ping timeout: 252 seconds]
krwq has quit [Remote host closed the connection]
<ck_>
but your discussion was about arguments to the function, not the function name ?! I'm confused. Of course the function symbol will be part of the fasl
<ck_>
how else would you call it
<Godel[m]>
I also tried with proclaim, all X, ACCand FACT are internal symbols still.
cosimone has joined #lisp
libertyprime has joined #lisp
<Godel[m]>
He was right in that CCL doesn't do that.
<no-defun-allowed>
Göd.el: did you restart SBCL after generating a FASL?
<Godel[m]>
yes, I started a different session in the terminal with 'ros run --load test.fasl`.
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
<Godel[m]>
tried with sbcl 1.5.4 and 1.5.3
makomo has quit [Quit: WeeChat 2.4]
igemnace has quit [Quit: WeeChat 2.5]
SaganMan has joined #lisp
wxie has quit [Quit: wxie]
libertyprime has quit [Quit: leaving]
<ck_>
hmm, you are right, that's what my sbcl does as well. I have not used slime for this either -- maybe there are some different settings in that environment?
<Godel[m]>
In which environment?
<ck_>
slime
<ck_>
or beach is using a government-level secret technology sbcl
<Godel[m]>
Lol
<ck_>
or -- the ever-present forces of darkness have prevented you from removing superfluous symbols at this time
oni-on-ion has joined #lisp
wxie has joined #lisp
<Godel[m]>
Both sly and slime does the same. The symbols are retained.
<no-defun-allowed>
I think the moral of the story is you shouldn't count on it.
<Godel[m]>
Okay, that aside, how do I tell CCL to load the symbols in the startup environment?
<no-defun-allowed>
If they're used as names of things that matter, they will be loaded.
<no-defun-allowed>
DEFPACKAGE will create the symbols when it creates the package too (to my knowledge).
lnostdal has joined #lisp
akoana has left #lisp ["Leaving"]
<Godel[m]>
Well, I'm stupid. My init file for quicklisp had a form dependent on sb-ext which prevented it from loading anything other than the forms before that non-conforming form with CCL. Would have been easier if roswell's sbcl just used `.sbclrc` instead of roswell forcing the same init file on all implementations.
cosimone has quit [Quit: WeeChat 2.4]
wxie has quit [Quit: wxie]
<Godel[m]>
Idk how I succeeded in loading a system and package in CCL at all.
<Godel[m]>
The symbols weren't loaded, in any case.
t58 has joined #lisp
<Godel[m]>
Now everything's fine.
wxie has joined #lisp
djeis[m] has joined #lisp
wxie has quit [Quit: wxie]
patrixl has joined #lisp
FreeBirdLjj has joined #lisp
heisig has quit [Quit: Leaving]
SaganMan has quit [Quit: WeeChat 1.6]
wxie has joined #lisp
wxie has quit [Client Quit]
wxie has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 250 seconds]
cosimone has joined #lisp
Arcaelyx has joined #lisp
donotturnoff has joined #lisp
wxie has quit [Quit: wxie]
cosimone has quit [Quit: WeeChat 2.4]
lavaflow has quit [Ping timeout: 246 seconds]
Inline has joined #lisp
libre-man has quit [Ping timeout: 245 seconds]
libre-man has joined #lisp
cosimone has joined #lisp
CloseToZero has joined #lisp
<CloseToZero>
ls
CloseToZero has quit [Quit: WeeChat 2.5]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
nanoz has joined #lisp
_whitelogger has joined #lisp
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
FreeBirdLjj has joined #lisp
Lycurgus has joined #lisp
dddddd has joined #lisp
admich has joined #lisp
nowhereman has quit [Ping timeout: 258 seconds]
lnostdal has quit [Ping timeout: 245 seconds]
nowhereman has joined #lisp
igemnace has joined #lisp
rumbler31 has joined #lisp
admich has quit [Remote host closed the connection]
nowhereman has quit [Quit: Konversation terminated!]
nowhere_man has joined #lisp
iovec has joined #lisp
v88m has quit [Remote host closed the connection]
v88m has joined #lisp
jmercouris has joined #lisp
<jmercouris>
I'm trying to work with Lispworks and have it start slime automatically
<jmercouris>
unfortunately, whenever I start Lispworks (personal edition) I have to manually enter in that stuff to start slime
<jmercouris>
swank server
knicklux has joined #lisp
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
<Lycurgus>
on mac? just setq'ing inf lisp works for ccl and sbcl
<Lycurgus>
the melpa stuff is general in my setup, slime isn't the only thing that uses it
<jmercouris>
yes, on mac
<jmercouris>
Lycurgus: I'm not sure what you are saying, I have this .lispworks file where I am trying to launch Swank server with Lispworks, but it doesn't start it
<Lycurgus>
i'm saying I use slime on mac with ccl and sbcl
<Lycurgus>
and just set the path to them for the inferior lisp
<Lycurgus>
but I don't anticipate using LW
<Lycurgus>
it's free version is crippled and I am a poor boy
<Lycurgus>
*its
<Lycurgus>
seven thousand goddamn dollars
<jmercouris>
I have SBCL as well, I'm looking to create a cross-platform user interface for a non-profit product, CAPI is the best
<Lycurgus>
but at least they don't try to take a cut of everything you make or charge for the run time
<Lycurgus>
LW is donating their thing pro bono?
<jmercouris>
No, they aren't
<jmercouris>
I'll have to pay 1500 for the DV edition or whatever its called
<jmercouris>
I do care about this project enough to pay for it...
<aeth>
Whoever wants to hop in on the Lisp-on-HN karma bandwagon
<aeth>
Mezzano was posted 19 days ago so that is probably too soon. Some others here could think of something, I'm sure, though.
<aeth>
borodust: You could try doing a Show HN of trivial-gamekit since HN's hivemind is filling its front page with Lisp articles right now. i.e. https://borodust.org/projects/trivial-gamekit/
dacoda has quit [Read error: No route to host]
<aeth>
CEPL would be another thing that could be received well
<ck_>
Isn't this december the 20th anniversary of sbcl?
dacoda has joined #lisp
dialectic has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
<Josh_2>
Lets have an E-party
andrei-n has quit [Remote host closed the connection]
oni-on-ion has quit [Remote host closed the connection]
mathrick has quit [Ping timeout: 276 seconds]
dacoda has quit [Ping timeout: 264 seconds]
james4 has left #lisp ["WeeChat 2.4"]
<Josh_2>
hmm, so I can't use (setf (funcall accessor instance) "abc") :( Is there a way I can get around this?
<Josh_2>
I have to make just (setf (accessor-method instance) "abc")
<_death>
or rather, (funcall (fdefinition `(setf ,accessor)) (cdr alist-entry) instance)
<_death>
what has that to do with a macro?
<Josh_2>
Well I didn't think you should be using ` and , outside of macros
nirved has joined #lisp
<Josh_2>
Okay that worked, but my logic was broken anyways. Thanks _death I'll fix when I get back
<_death>
you can use backquote if you treat the the object as a literal
<_death>
it has nothing to do with macros
miklos1 has quit [Remote host closed the connection]
<_death>
Josh_2: in this case it may be enough just to read a list of initargs and (apply #'make-instance 'data-entry initargs)
<stacksmith>
Backquote is extremely useful outside of macros, as a list-building device.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
varjag has joined #lisp
Kundry_Wag has joined #lisp
<seok>
is this || used for anything in common lisp?
Lycurgus has quit [Quit: Exeunt]
<stacksmith>
What is that? |...| is for disambiguating symbols.
oni-on-ion has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
<dialectic>
#| stuff |# is also used for (nestable) comments, so careful with that too if you're making a dispatch character.
manualcrank has joined #lisp
<saturn2>
apparently || is a valid symbol name
<MichaelRaskin>
Yes, with empty symbol-name
<MichaelRaskin>
CLSQL abuses that
<dialectic>
Oh my.
<saturn2>
that sounds terrible
<MichaelRaskin>
Well, in SQL string concatenation is ||
<dialectic>
Ooooooh. Interesting.
<stacksmith>
Is that really abuse? It's just a symbol, I suppose.
<MichaelRaskin>
Well, borderline: they use that it looks || in code and ignore the fact that it has empty name
<stacksmith>
Yeah... It's kind of hard to enter it any other way than ||, so as much as I want to object to it, I can't find a good reason... I suppose (find-symbol "") to get '|| may be a little confusing.
seok99 has joined #lisp
<seok>
right,
bugrum has joined #lisp
<stacksmith>
In a DSL anything goes, as far as I am concerned.
seok99 has quit [Remote host closed the connection]
<seok>
Anyone have experience with caveman2?
<seok>
How do I retrieve values sent via form as POST?
random-nick has quit [Read error: Connection reset by peer]
<fiddlerwoaroof>
The advantage of this is that you don't need to depend on a specific lens library to provide lenses: a lens is just a function that works in a certain way and any such function will be compatible with DATA-LENS.LENSES:VIEW, DATA-LENS.LENSES:SET, and DATA-LENS.LENSES:OVER
<fiddlerwoaroof>
Also, these functions use the "traditional" names for the lens operations, so they'll be more familiar to people coming from other languages.
Kundry_Wag has joined #lisp
dialectic has quit [Ping timeout: 272 seconds]
alexanderbarbosa has joined #lisp
brayanlts has joined #lisp
varjag has quit [Remote host closed the connection]
brayanlts has quit [K-Lined]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo has quit [Ping timeout: 246 seconds]
dialectic has joined #lisp
<dialectic>
lenses seem vaguely inappropriate for a language like common lisp where I can iterate over slot values or use symbols to set arbitrary slots.
<saturn2>
common lisp doesn't come with a convenient built-in way to make modified copies of arbitrary objects without mutation
<oni-on-ion>
i think they are conceptual tools
<oni-on-ion>
R and Julia have things called 'DataFrame' which is kind of like a lense into arbitrarily large data sets, but less about code and more about data (afaik)
<oni-on-ion>
lens*
<oni-on-ion>
side note spectacle ocular lenses applied to my wetware biology have ruined me
<oni-on-ion>
fwiw
<dialectic>
saturn2: wrap COPY-STRUCT and (SETF (SLOT-VALUE ...) ...) in a macro?
zhlyg has quit [Ping timeout: 245 seconds]
<dialectic>
oni-on-ion: That is also a DB concept.
<saturn2>
dialectic: that's why i said built-in, obviously you can create it with macros
<dialectic>
Excuse me, I meant COPY-STRUCTURE.
<dialectic>
saturn2: I mean, sure. But how is that any worse or better than a "lens"? You could use one macro, for all cases.
nowhere_man has joined #lisp
<dialectic>
Admittedly my functional-fu is weak in this area. I know this won't work for the "applicative" pattern.
anewuser has joined #lisp
<saturn2>
i guess it would only be better insofar as it's a clean design that has a name
<saturn2>
also it's trivially extensible
Adamclisi has quit [Quit: leaving]
<dialectic>
Do you have a blog post I could read? I think I need a primer again.
<fiddlerwoaroof>
Lenses are really nice, because if you have two lenses, simple function composition composes the "pointers"
<fiddlerwoaroof>
And, thy are just "values", so you can pass them around, allowing you to separate "what" a function operates on from the operation applied.
wxie has joined #lisp
<fiddlerwoaroof>
Accessors, etc. are handy and, to some degree, overlap with lenses but a significant difference is that setting a lens copies the underlying object, while setfing an accessor mutates it: both have their place, but lenses preserve encapsulation a bit better
frgo has joined #lisp
ltriant has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
dialectic has quit [Ping timeout: 258 seconds]
kajo has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
wxie has quit [Quit: wxie]
frgo has quit [Ping timeout: 245 seconds]
dialectic has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
anewuser has quit [Ping timeout: 248 seconds]
pyx has joined #lisp
pyx has quit [Client Quit]
alexanderbarbosa has quit [Remote host closed the connection]