<DrDuck>
Do you know if dependency directed backtracking is possible in SCREAMER?
<Bike>
i do not
kajo has joined #lisp
zacts has joined #lisp
EvW has quit [Quit: EvW]
akoana has joined #lisp
Ricchi has quit [Remote host closed the connection]
<White_Flame>
DrDuck: reading through the docs, I don't really see any config for backtracking
<White_Flame>
I also don't understand the term "nondeterministic" as used there, as the choice points are in deterministic order and generally exhaustive
<DrDuck>
wonder how hard it would be to hack on screamer and add an option for dependency directed backtracking
<LdBeth>
(if (nd t nil) 1 2) => (nd 1 2)
<DrDuck>
or if that would be a bad idea and i should work on spinning something up myself first
<White_Flame>
LdBeth: yeah, but that's not what screamer seems to do, is it?
<LdBeth>
(if (nd t nil) 1 (if (nd t nil) 2 3)) => (nd 1 2 3)
<DrDuck>
"Second Screamer foregoes intelligent backtracking in favor of chronological backtracking. Experience has shown that the overhead of maintaining dependencies to support intelligent backtracking costs far more than the computation saved in most practical applications. We believe that chronological backtracking represented via nondeterminism is a useful programming paradigm when used properly. It is an important control
<DrDuck>
construct which adds signicant expressive power to CommonLisp making programs easier to write debug and understand."
<DrDuck>
from the SCREAMER paper
<LdBeth>
White_Flame: screamer does that
<White_Flame>
oh, right. But that's still deterministic as far as I understand the term
<White_Flame>
it's basically akin to a set of prolog results
<LdBeth>
it is called nd because there's a set of results rather than only one
<White_Flame>
yeah, with some googling it appears to have a specific CS definition as such
<LdBeth>
I'm not responseble for that term :-P
<White_Flame>
heh
schjetne has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
schjetne has quit [Ping timeout: 245 seconds]
lalilulelo has quit [Read error: Connection reset by peer]
akoana has left #lisp ["Leaving"]
defaultxr has joined #lisp
notzmv has joined #lisp
Fare has joined #lisp
lavaflow has quit [Ping timeout: 245 seconds]
lavaflow has joined #lisp
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
Guest20332 has left #lisp ["Leaving"]
reppie is now known as x[LGWs4x4i]uG2N0
karstensrage has joined #lisp
alexanderbarbosa has quit [Read error: Connection reset by peer]
Kaisyu7 has joined #lisp
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
anewuser has quit [Ping timeout: 258 seconds]
anewuser has joined #lisp
Fare has quit [Ping timeout: 252 seconds]
Kaisyu has joined #lisp
DrDuck has quit []
DrDuck has joined #lisp
semz has quit [Ping timeout: 264 seconds]
teej has joined #lisp
techquila has quit [Remote host closed the connection]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
<aeth>
So for all of the -7 people interested in my md->html side project, I decided to write my own HTML gen because of how concise my subset test was and it's still only 34 lines with most of the edge cases handled (I just need to escape <, >, and &, as well as " in attributes). s-expressions really do map pretty directly to XML-style languages.
<aeth>
This whole thing might just be doable in a weekend, although, to be fair, I've generated programming language strings before, which are way more complicated than web documents unless I added JS to the mix.
lemoinem is now known as Guest29517
Guest29517 has quit [Killed (weber.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
<aeth>
Oh no it's Thursday it doesn't count as a weekend because I started a day early.
orivej has quit [Ping timeout: 246 seconds]
<beach>
Good morning everyone!
techquila has joined #lisp
anewuser has quit [Quit: anewuser]
shifty has quit [Ping timeout: 268 seconds]
<aeth>
Good morning, beach
gxgx2 has joined #lisp
<gxgx2>
(let (foo and) (if (foo t nil) (print "Success") (print "Failure"))) yields an undefined function FOO error. Is there a way to pull something like this off nicely?
<Bike>
you presumably mean (let ((foo and)) ...)
<gxgx2>
Originally, I was trying to pass the logical operators in as arguments to a function, but I don't know how to make a usable binding to them at all,
<Bike>
i mean, that won't work either
<Bike>
AND is a macro, so you can't really pass it around like you can with a function
<aeth>
gxgx2: for your specific example, maybe macrolet? (macrolet ((foo (&rest forms) `(and ,@forms))) (foo t nil)) => NIL ; replace and with or to get T
<aeth>
gxgx2: For your actual problem (arguments to a function) that's harder and any solution would be hackish. Maybe use a macro for that instead of possible?
<aeth>
(Afaik, the solutions would probably involve eval-ing or compiling each time you call the function, although that could be memoized.)
<Bike>
i mean practically speaking gxgx2 is probably just using them as functions
<gxgx2>
More or less attempting to, yeah
<gxgx2>
(logOp a b c)
<gxgx2>
is basically the actual use case
<gxgx2>
and I want to be able to pass in 'and or 'or for logOp
<gxgx2>
(if (equal logOp 'and) (and a b c) (or a b c)) works, but isn't a particularly nice solution and leads to a good bit of repeat code
<Bike>
and you're using logical operations, not bitwise, right?
<gxgx2>
Correct
<Bike>
(let ((foo (lambda (a b) (and a b)))) (if (funcall foo t nil) (print "Success") (print "Failure"))
poet has joined #lisp
<gxgx2>
Hm. In my case, I know there will always be three arguments, so I could do (lambda (a b c) ...) but is there a more generalizable way that would mimic the syntax of and? Having to pass in a list would be non-ideal
permagreen has quit [Remote host closed the connection]
ark has quit [Read error: Connection reset by peer]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<gxgx2>
Bike, Much thanks. I should be able to adapt that to my purpose and the weird dialect I'm using
threefjord has quit [Ping timeout: 246 seconds]
cyberlard has quit [Ping timeout: 258 seconds]
red-dot has joined #lisp
dddddd has quit [Remote host closed the connection]
threefjord has joined #lisp
cyberlard has joined #lisp
<beach>
gxgx2: Dialect of what?
<gxgx2>
Lisp. I'm using Cadence SKILL, so things don't fully translate in a one-to-one fashion
<beach>
I see.
poet has quit [Ping timeout: 250 seconds]
teej has quit [Quit: Connection closed for inactivity]
Bike has quit [Quit: Lost terminal]
gravicappa has joined #lisp
tourjin has joined #lisp
<tourjin>
if i wrote some functions in interpreter how I can see the codes I typed in ?
test1600 has joined #lisp
<beach>
You shouldn't write code that way. You should have one window with source code and on with the SLIME REPL. Then you can send your code to the REPL with C-c C-c. And it is typically not an interpreter. It is an on-the-fly compiler.
<aeth>
In Emacs+SLIME, you do M-. and it'll take you to the location in the source file where it was defined.
<tourjin>
yes u said that yesterday. I'm still working on it. trying to install cygwin instead wsl.
<tourjin>
for now I only can use interpreter on windows 10.
<beach>
tourjin: Using "u" to mean "you" is frowned upon in this channel.
<beach>
tourjin: It is not an interpreter.
<tourjin>
beach: i see. thanks. sbcl command line is not an interpreter?
<beach>
No.
<beach>
We call it a REPL. Read-Eval-Print-Loop. And it is an on-the-fly compiler as I said.
<beach>
tourjin: The difference is important, because people associate "interpreter" with "slow" and they think Common Lisp must be slow because it has a REPL.
vaporatorius has quit [Remote host closed the connection]
<aeth>
tourjin: Traditionally, Common Lisp was implemented with both an interpreter and a compiler, although sometimes the compiler is just a bytecode compiler. In the REPL (and a few other places), you would use the interpreter if you did (defun foo ()), but you could (compile 'foo) and then it would be compiled. Also, the files would be compiled.
<aeth>
tourjin: SBCL does have a separate interpreter iirc, but it is rarely used (and maybe it even got removed at this point) because by default its REPL actually compiles every line. This is good. It's fast enough that you don't notice the compilation, and you exercise the same codebase so there are no edge cases where the same code could do different things depending on if it was interpreted or compiled.
<aeth>
(Or even just be considerably faster if it was compiled vs. interpreted)
<beach>
aeth: That is not true: (compiled-function-p #'foo) => T
<aeth>
beach: In SBCL, yes.
<aeth>
Is that always the case?
<beach>
And that is what tourjin is using. So I was trying very hard to tell tourjin a simplified version of why Common Lisp is not slow. Now I am sure tourjin is completely confused.
<aeth>
Sorry if I wrote it in a confusing way. My first line was the "traditional expectation", i.e. what tourjin expects. My second line is what SBCL actually does.
<aeth>
My point was that the REPL probably used to be an interpreter in every original CL (although I'm not sure) back in the day when compilation was noticable, but it doesn't have to be anymore, and it isn't in SBCL. It just compiles every form.
<tourjin>
so you mean there is no way to see the function codes I typed in on sbcl * command line?
<xantoz>
no, because it only stores the compiled versions in RAM, iirc
<aeth>
I don't think that the source form gets saved with the function definition in the REPL, although I could be mistaken. Usually you start writing in the SLIME REPL and then after it gets big enough put it into a file, even a temporary file. And in SLIME you can just do a backwards history search by typing out (defun foo and then doing M-p (Alt+p)
<aeth>
If I had to get the definition, I would just do the backwards history search in SLIME, but that won't work in the bare terminal. Most people will use some feature-enhanced REPL
<tourjin>
ok i got it. probably that's why you told me do not use bare sbcl.
<fengshaun>
speaking of sbcl and repl, I have to figure out how to use slime efficiently
<aeth>
It's one of those things where you pick up a new command accidentally every now and then, or maybe set out to learn 10 in a short period, but you only ever scratch the surface.
<fengshaun>
thoughts so, I've just been sufficing to slime-eval-defun, but the repl is inconvenient, especially since I'm using evil-mode
nanoz has joined #lisp
vlatkoB has joined #lisp
nanoz has quit [Client Quit]
jeosol has joined #lisp
nanoz has joined #lisp
ljavorsk has joined #lisp
sauvin has joined #lisp
yoeljacobsen has joined #lisp
ggole has joined #lisp
tourjin has quit [Ping timeout: 268 seconds]
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
Fare has joined #lisp
paul0 has quit [Ping timeout: 245 seconds]
gxgx2 has quit [Remote host closed the connection]
marusich has joined #lisp
marusich has quit [Remote host closed the connection]
Fare has quit [Ping timeout: 252 seconds]
chipolux has quit [Ping timeout: 250 seconds]
JohnMS_WORK has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
shifty has joined #lisp
varjag has joined #lisp
karswell has joined #lisp
<fiddlerwoaroof>
I don't know if anyone here uses docker, but I've added an image with some useful functionality built in
<fiddlerwoaroof>
If you do docker run -ti fiddlerwoaroof/sbcl-static:1.5.6 you should get an sbcl repl
<fiddlerwoaroof>
And then something like this: (fwoar.repl-utils:github "Shinmera" "lquery") will clone a github repo into quicklisp's local-projects directory
ljavorsk has quit [Remote host closed the connection]
ravenousmoose has quit [Ping timeout: 250 seconds]
shifty has quit [Ping timeout: 268 seconds]
ljavorsk has joined #lisp
shifty has joined #lisp
<jonatack>
fiddlerwoaroof: nice
ltriant has quit [Quit: leaving]
<fiddlerwoaroof>
Also, I put together a little demonstration of writing a web api Server in Common Lisp using ningle here: https://fiddlerwoaroof.github.io/cl-todo-backend/ it isn’t done yet, but I’ve been really pleased with .org-mode for this.
ljavorsk_ has joined #lisp
ljavorsk has quit [Ping timeout: 268 seconds]
ljavorsk_ has quit [Remote host closed the connection]
<jonatack>
fiddlerwoaroof: Good to see. I've been moving to CL for my personal web things. Current one is to frequently pull down the GitHub data for the Bitcoin Core repo via their GraphQL API,
ljavorsk_ has joined #lisp
makomo has joined #lisp
<jonatack>
fiddlerwoaroof: archive it, ane tweet/toot selected items on twitter and mastodon to promote code review and reviewers.
<fiddlerwoaroof>
Cool, I'm a big fan of Lisp for webby stuff
<fiddlerwoaroof>
The most "real" project I have in Lisp at the moment is a library for writing slack bots: I use it to track jenkins builds at work and a couple other things, and it's pretty fun to fiddle with every once in a while
chipolux has joined #lisp
<jonatack>
Yes. Same. So far have been using dexador, quri, and jsown for the http, uri, and json things.
<fiddlerwoaroof>
I use drakma/puri/yason :)
<jonatack>
Haha interesting :)
<fiddlerwoaroof>
although, I probably should be using quri, because I think puri is slightly incorrect in some of its details
<jonatack>
I reckoned quri would play well with dexador since both are by the same author. Using it for money-critical applications in https://github.com/jonatack/cl-kraken
frgo has joined #lisp
<fiddlerwoaroof>
It's always interesting seeing what subset of CL someone uses
<fiddlerwoaroof>
I tend to a more CLOSy style then that code :)
<fiddlerwoaroof>
I'm hoping to eventually write a github-type service in CL, so I've been slowly implementing readers for git's file formats
schjetne has joined #lisp
<jonatack>
Fukumachi's or mine? I'm a beginner in CL after a decade in both assembly and Ruby so open to suggestions.
<jonatack>
Haven't used CLOS yet.
<fiddlerwoaroof>
I just browsed through your code quickly
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
If you haven't read them yet, you should skim PCL's chapters on CLOS and the condition system: they've really influenced a lot of my thinking about the FP vs. OOP debates
<fiddlerwoaroof>
But, defining your application as a set of protocols (collections of inter-operating generic functions) seems to me to be a really useful way to structure an application
<jonatack>
Thanks. I have all the books and am going through them sporadically. PCL is great, skimmed those chapters but need to assimilate them.
<fiddlerwoaroof>
CLOS sort of flips the way Ruby/Java etc. do OOP by putting the emphasis on generic functions (roughly equivalent to methods in other object systems) and relatively de-emphasizing classses
shifty has quit [Ping timeout: 244 seconds]
Cymew has quit [Quit: Konversation terminated!]
shifty has joined #lisp
<jonatack>
Yes, the OOP in Ruby/Java is a bit ceremonial for my taste. But I came to OOP after imperative and functional. Generic funs look good.
Cymew has joined #lisp
<fiddlerwoaroof>
My current hypothesis about a lot of the complaints about OOP is that they are really problems with the message-passing conception of OOP and how that makes methods second-class citizens
<fiddlerwoaroof>
A multimethod isn't a message passed to a class, but a way to specify how a set of classes interact.
<jonatack>
Multimethods look amazing...need to try using them. Thanks for the feedback and suggestions.
<jonatack>
My day job is C++ ATM so CL is a breath of fresh air :)
<fiddlerwoaroof>
Yeah, I mostly wrote CSS today, and a bit of Javascript
<fiddlerwoaroof>
I'm lucky, though: every once in a while I get to work on our Clojure backend
<jonatack>
Git cloned cl-git and will look at the code.
<fiddlerwoaroof>
I just noticed the version on Github isn't my latest version
<fiddlerwoaroof>
I'm not quite ready to push it, but I've been cleaning up the structure a bit.
mindthelion has joined #lisp
techquila has quit [Ping timeout: 276 seconds]
even4void has joined #lisp
<jonatack>
Sure, ping me when you push if you don't mind.
<fiddlerwoaroof>
k
x[LGWs4x4i]uG2N0 has quit [Remote host closed the connection]
sonologico has quit [Remote host closed the connection]
yoeljacobsen has joined #lisp
cosimone has joined #lisp
MightyJoe has joined #lisp
jonatack has quit [Quit: jonatack]
cyraxjoe has quit [Ping timeout: 246 seconds]
escew has joined #lisp
jprajzne has quit [Ping timeout: 244 seconds]
hhdave has joined #lisp
jprajzne has joined #lisp
<escew>
hello, anyone here used lisp-binary library? i'm wondering what the best way to handle fixed-size null-terminated strings is
v88m has quit [Ping timeout: 246 seconds]
shifty has quit [Ping timeout: 245 seconds]
shifty has joined #lisp
<beach>
I can't figure out how to pass initial bindings to BT:MAKE-THREAD.
cosimone has quit [Remote host closed the connection]
<beach>
I could use some help.
cosimone has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
<beach>
And the manual doesn't explain the nature of the INITIAL-BINDINGS keyword argument.
gigetoo has quit [Ping timeout: 245 seconds]
cosimone has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
<jdz>
I seem to remember struggling a bit with this too.
<jdz>
So I made myself a macro.
<jdz>
Now I'm checking if it works.
<saturn2>
is there an advantage over just putting a let form inside the lambda?
<beach>
saturn2: What would you do otherwise?
gigetoo has joined #lisp
<beach>
Oh, and SBCL documentation for MAKE-THREAD has a keyword parameter EPHEMERAL but it is not explained.
<beach>
Oh, well.
<saturn2>
i mean INITIAL-BINDINGS seems superfluous
<beach>
Oh, I see.
cosimone_ has joined #lisp
<beach>
You may be right.
<beach>
Yes, I think I can work with that. Thanks.
<no-defun-allowed>
Oh, initial-bindings is an alist of dynamic variable names and their values, eg ((*standard-output* . <some kind of stream>))
Lord_of_Life_ has joined #lisp
cosimone has quit [Ping timeout: 264 seconds]
<beach>
no-defun-allowed: Thanks!
<no-defun-allowed>
I believe bt:*default-special-bindings* is appended to it too.
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
cosimone__ has joined #lisp
defaultxr has quit [Ping timeout: 246 seconds]
datajerk has quit [Ping timeout: 246 seconds]
cosimone_ has quit [Ping timeout: 258 seconds]
schjetne has quit [Read error: No route to host]
datajerk has joined #lisp
<d4ryus>
hi, i have a question about format: How does it know how much indentation is needed when a form is printed with a linebreak? Example: (format t "~%test: ~a~%" (loop :for i :from 0 :to 100 :collect i))
SaganMan has quit [Ping timeout: 246 seconds]
schjetne has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
<saturn2>
it just counts how many characters have been printed so far on the current line
<d4ryus>
is there a format directive to do that?
<jdz>
beach: Also bordeaux-threads uses EVAL to evaluate values passed in the :initial-bindings list. A very poor choice in my opinion.
<no-defun-allowed>
Crap, it is.
<beach>
jdz: That explains my problems.
jonatack has joined #lisp
<beach>
jdz: Thanks.
<jdz>
beach: You are welcome! Thank you too for bringing this up — I rewrote my code to not use the :initial-bindings parameter.
jprajzne has quit [Remote host closed the connection]
tdleffler has joined #lisp
<d4ryus>
saturn2: thank you!
kajo has quit [Ping timeout: 264 seconds]
frgo has quit [Ping timeout: 244 seconds]
jprajzne has joined #lisp
<Lycurgus>
the thing that passed 8th grade science test currently in the MSM is partially ACL
<beach>
Nice.
awolven has quit [Ping timeout: 268 seconds]
yoeljacobsen has quit [Ping timeout: 244 seconds]
jeosol has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
"Aristo"?
<Lycurgus>
yeah, and not sure it currently uses ACL but at somepoint it did. Allegro page on it has a stale link to that actual project.
<no-defun-allowed>
What I read claims it's the work of a neural network, and I can't find much about ACL, but then again "theorem proving" doesn't sound as nice to investors as deep learning.
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
noobineer1 has joined #lisp
noobineer2 has quit [Ping timeout: 250 seconds]
cosimone__ has quit [Remote host closed the connection]
cosimone__ has joined #lisp
nanoz has quit [Ping timeout: 268 seconds]
cosimone__ has quit [Quit: Leaving]
EvW has joined #lisp
frgo has joined #lisp
amerlyq has joined #lisp
jlarocco has quit [Ping timeout: 244 seconds]
even4void has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
papachan has joined #lisp
kajo has joined #lisp
bnh^ has quit []
Fare has joined #lisp
aautcsh has joined #lisp
gravicappa has joined #lisp
xkapastel has joined #lisp
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
EvW has quit [Ping timeout: 250 seconds]
aautcsh has joined #lisp
ljavorsk__ has quit [Ping timeout: 245 seconds]
yoeljacobsen has joined #lisp
aautcsh has quit [Ping timeout: 276 seconds]
jonatack has quit [Ping timeout: 258 seconds]
tdleffler has left #lisp [#lisp]
EvW1 has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
logicmoo has joined #lisp
Jesin has quit [Ping timeout: 245 seconds]
mbrumlow has quit [Ping timeout: 245 seconds]
Jesin has joined #lisp
mbrumlow has joined #lisp
Cymew has quit [Quit: Konversation terminated!]
Cymew has joined #lisp
Cymew has quit [Quit: Konversation terminated!]
Fare has quit [Ping timeout: 252 seconds]
awolven has joined #lisp
lucasb has joined #lisp
mindCrime has joined #lisp
Necktwi has joined #lisp
cosimone has joined #lisp
jonatack has joined #lisp
aautcsh has joined #lisp
test1600_ has quit [Quit: Leaving]
nanoz has joined #lisp
Fare has joined #lisp
Necktwi has quit [Ping timeout: 245 seconds]
<thijso>
What is the correct way to park/pause/sleep a thread in bordeaux-threads? I have a scheduler thread that needs to perform some small tasks every x seconds (on the order of minutes). Is it okay/correct to just (sleep *timeout*) in that thread to get that behaviour? Or should I do it differently?
<thijso>
s/*timeout*/*idle-skip-time*/ or something
<no-defun-allowed>
That should work, as sleep will correspond to some syscall that puts the thread to sleep.
<thijso>
Ah, great. Thanks, no-defun-allowed
<no-defun-allowed>
(Or, if you have an implementation with green threads, it'll put that thread to sleep and the implementation's scheduler will leave it alone.)
Lycurgus has quit [Quit: Exeunt]
Bike has joined #lisp
Necktwi has joined #lisp
jiny has joined #lisp
jiny is now known as tourjin
yoeljacobsen has quit [Ping timeout: 268 seconds]
jonatack has quit [Ping timeout: 264 seconds]
LiamH has joined #lisp
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<tourjin>
if sbcl is compiler rather than a interpreter. how can I make excutable out file ? should I add some option ?
<no-defun-allowed>
(sb-ext:save-lisp-and-die "executable-name" :compression 9 :executable t :toplevel #'function-that-starts-your-program)
<no-defun-allowed>
But SBCL is not a batch compiler, like a C compiler, rather it compiles incrementally as you feed it code. This just dumps out the memory to an executable.
jonatack has joined #lisp
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<tourjin>
that means I can't make excutable file?
<Bike>
you can, it's just not the same workflow as you'd do in C or whatever
even4void has joined #lisp
paul0 has joined #lisp
<tourjin>
sbcl my.lisp does'nt create an excutable file. it just run it. which option should I add?
<Bike>
no-defun-allowed told you what to do. you execute the sb-ext:save-lisp-and-die function.
<Bike>
please don't just ignore meaningful advice given to you
aautcsh has quit [Read error: Connection reset by peer]
dale_ has joined #lisp
dale_ is now known as dale
yoeljacobsen has quit [Ping timeout: 245 seconds]
smazga has joined #lisp
_whitelogger has joined #lisp
skibo has quit [Quit: WeeChat 2.3]
shka_ has quit [Quit: WeeChat 1.9.1]
schjetne has quit [Ping timeout: 258 seconds]
sjl has quit [Quit: WeeChat 2.3-dev]
fitzsim is now known as fitzsim_`
fitzsim has joined #lisp
fitzsim_` has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
ironbutt has quit [Quit: Leaving]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
jprajzne has quit [Quit: Leaving.]
EvW has joined #lisp
logicmoo has quit [Read error: Connection reset by peer]
v88m has quit [Ping timeout: 245 seconds]
jonatack has quit [Quit: jonatack]
frgo_ has joined #lisp
spal_ has joined #lisp
dmiles has joined #lisp
astronavt___ has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
surrounder has quit [Ping timeout: 244 seconds]
surrounder has joined #lisp
astronavt has quit [Ping timeout: 244 seconds]
Posterdati has quit [Ping timeout: 244 seconds]
zacts has quit [Ping timeout: 264 seconds]
mathrick has quit [Ping timeout: 264 seconds]
spal has quit [Ping timeout: 268 seconds]
Posterdati has joined #lisp
mathrick has joined #lisp
zacts has joined #lisp
zacts has quit [Client Quit]
tourjin has quit [Remote host closed the connection]
tourjin has joined #lisp
<beach>
tourjin: Whether a system uses a compiler or an interpreter is an issue that is orthogonal to whether it can produce executable files. Don't confuse the two. And you are not alone in this confusion, of course.
<beach>
tourjin: That is why I insisted on pointing it out to you. Many people who see an interactive system such as Common Lisp, think that it must be interpreted, so they think it must be slow. They are wrong.
<Xach>
learning new things helps keep your imagination informed about what is possible
<beach>
Very true.
<beach>
Xach: Did you manage to use SICL LOOP OK?
<tourjin>
thanks all. i'm still installing cygwin for two days. :-)
q9929t has joined #lisp
<Xach>
beach: yes! and i forgot i had it loaded, and i loaded one of my own projects and instantly got an error about a clause ordering error
<Xach>
I thought SBCL had updated and broken my code until I remembered the truth
<beach>
Heh, great story.
<Xach>
i have a feeling that this will reveal a great many clause ordering issues
<Xach>
issues that would not have arisen if clisp rather than sbcl was so dominant
<beach>
Sure.
<beach>
People may not care of course.
q9929t has quit [Quit: q9929t]
LiamH has quit [Ping timeout: 258 seconds]
aautcsh has joined #lisp
aautcsh_ has joined #lisp
aautcsh has quit [Ping timeout: 252 seconds]
fynzh[m] has quit [Remote host closed the connection]
malaclyps[m] has quit [Remote host closed the connection]
keep-learning[m] has quit [Read error: Connection reset by peer]
katco has quit [Remote host closed the connection]
djeis[m] has quit [Read error: Connection reset by peer]
dtw has quit [Remote host closed the connection]
no-defun-allowed has quit [Read error: Connection reset by peer]
liambrown has quit [Write error: Connection reset by peer]
Godel[m] has quit [Write error: Connection reset by peer]
LdBeth has quit [Read error: Connection reset by peer]
munksgaard[m] has quit [Write error: Connection reset by peer]
akanouras has quit [Remote host closed the connection]
Jachy has quit [Remote host closed the connection]
iarebatman has quit [Write error: Connection reset by peer]
sciamano has quit [Write error: Connection reset by peer]
eriix[m] has quit [Remote host closed the connection]
nonlinear[m] has quit [Read error: Connection reset by peer]
hiq[m] has quit [Remote host closed the connection]
rippa has joined #lisp
aautcsh_ has quit [Changing host]
aautcsh_ has joined #lisp
kpoeck has joined #lisp
mindCrime_ has joined #lisp
<kpoeck>
There is even a wrong loop use in Alexandria
<kpoeck>
I was tempted to try to use SICL Loop in clasp, but there are so many loop uses style symbolics out there
aautcsh_ has quit [Read error: Connection reset by peer]
akanouras has joined #lisp
mindCrime has quit [Ping timeout: 245 seconds]
aautcsh has joined #lisp
Ricchi has joined #lisp
ebrasca has quit [Remote host closed the connection]
aautcsh has quit [Ping timeout: 276 seconds]
hhdave has quit [Quit: hhdave]
schjetne has joined #lisp
aautcsh has joined #lisp
<Xach>
kpoeck: ouch
ravenousmoose has joined #lisp
aautcsh has quit [Client Quit]
LiamH has joined #lisp
defaultxr has joined #lisp
shka_ has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
<selwyn_>
is the clisp implementation superior to that of sbcl in some aspects?
<selwyn_>
implementation of LOOP i mean
<Xach>
selwyn_: it has a more conformant loop
<Xach>
it rejects non-conforming loops
LdBeth has joined #lisp
<LdBeth>
P
djeis[m] has joined #lisp
dtw has joined #lisp
katco has joined #lisp
no-defun-allowed has joined #lisp
Jachy has joined #lisp
eriix[m] has joined #lisp
Godel[m] has joined #lisp
iarebatman has joined #lisp
sciamano has joined #lisp
nonlinear[m] has joined #lisp
liambrown has joined #lisp
keep-learning[m] has joined #lisp
malaclyps[m] has joined #lisp
munksgaard[m] has joined #lisp
fynzh[m] has joined #lisp
hiq[m] has joined #lisp
gareppa has joined #lisp
varjag has joined #lisp
notzmv has quit [Ping timeout: 246 seconds]
notzmv has joined #lisp
sjl has joined #lisp
cosimone has quit [Quit: Leaving]
xkapastel has quit [Quit: Connection closed for inactivity]
ravenousmoose has quit [Ping timeout: 264 seconds]
kajo has joined #lisp
quazimodo has joined #lisp
Ven`` has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
stepnem has quit [Ping timeout: 268 seconds]
stepnem has joined #lisp
fitzsim is now known as fitzsim_
fitzsim has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
gareppa has quit [Quit: Leaving]
EvW1 has joined #lisp
karlosz has joined #lisp
orivej has joined #lisp
EvW1 has quit [Ping timeout: 264 seconds]
notzmv has quit [Ping timeout: 264 seconds]
Oladon_work has joined #lisp
fitzsim has quit [Ping timeout: 245 seconds]
threefjord has quit [Quit: leaving]
Akhetopnu has joined #lisp
<tourjin>
this is not about lisp. but somebbody help me. how can I change color of xterm or rxvt?
khisanth_ has quit [Ping timeout: 268 seconds]
<Oladon_work>
tourjin: Why don't you ask in #xterm or #linux?
<tourjin>
ok thanks
<pjb>
tourjin: man xterm ; man rxvt
notzmv has joined #lisp
ebrasca has joined #lisp
even4void has joined #lisp
even4void has quit [Client Quit]
khisanth_ has joined #lisp
Ven`` has joined #lisp
EvW has joined #lisp
ebrasca has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
momozor has joined #lisp
jonatack has joined #lisp
<momozor>
Hi. What do you guys think on using some of the Scheme naming style. In particular, a-function for immutable one, a-destructive-function! for a mutable one, and what-is-this? for a predicate.
<momozor>
using this convention in Lisp*
<momozor>
will there be any significant semantic issues if one want to follow such convention in CL
vlatkoB has quit [Remote host closed the connection]
<momozor>
Like naming your variables or a function with the camelCase style can be harmful or useless in CL..
<Bike>
semantic? no. it's against general practice, though.
<momozor>
bike: I see. Thanks.
<momozor>
Also, I wonder if there is a general practice to distinguish between mutable and immutable functions in CL?
shka_ has quit [Ping timeout: 244 seconds]
ggole has quit [Quit: Leaving]
<Oladon_work>
I tend to like using ! and ? in function names for those purposes in CL, if only to show off to everyone else who can't have non-alphanumeric symbols in in their languages.
<aeth>
momozor: I use ! and ? all of the time, although I'm kind of 50/50 on "?" vs. "-p" and it depends on the nature of the code (I'll never use "foop", because that's just confusing for humans and computers to parse). The other conventions from Scheme would be pretty unrecognizable.
<Oladon_work>
Yeah, I'm also about 50/50 on ? vs -p
<aeth>
As for ! I'm 50/50 on including it or not. It's more like... "is there an expectation for this to be pure?" It's a good way to name a variant, e.g. if you have matrix-* and matrix-*!
momozor has quit [Ping timeout: 245 seconds]
<Oladon_work>
Agreed. I wouldn't name something "foo!" if there's no "foo"
<aeth>
Well, unless it was in an otherwise mostly/entirely pure file/package/project/whatever.
<Bike>
the usual destructive function thing is nfoo
<Bike>
not always great, but that's how it is
<aeth>
Bike: n stands for "non-consing" and a foo! can be consing, such as if it logged or memoized.
<aeth>
It's not a direct equivalent, and it's much uglier and more inconsistently/rarely used than "-p" anyway
LiamH has quit [Remote host closed the connection]
LiamH has joined #lisp
<aeth>
You also want a suffix rather than a prefix so that it sorts alphabetically next to its pure equivalent if it exists, like foo and foo!
<Bike>
i don't think what it stands for matters much
<aeth>
It's just that I personally think that ? and ! are separate naming issues because CL has a 100% direct ? equivalent in -p, while it has several, not-frequently-used, fairly-problematic (imo) equivalents to !
<aeth>
nfoo is just the most common, but I've seen others iirc. It would take me some time to look them up since it's not particularly searchable
<aeth>
perhaps foof is the next most common, but that has a specific meaning, and is for things like incf that you'd define with something like define-modify-macro
<aeth>
(and then there's getf, which doesn't mutate!)
makomo has quit [Quit: WeeChat 2.4]
shifty has joined #lisp
cosimone has joined #lisp
krid has joined #lisp
scymtym has quit [Ping timeout: 264 seconds]
gravicappa has quit [Ping timeout: 245 seconds]
vaporatorius has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
tourjin has quit [Ping timeout: 245 seconds]
amerlyq has quit [Quit: amerlyq]
Bike has quit [Quit: Bike]
v88m has joined #lisp
scymtym has joined #lisp
lavaflow has quit [Ping timeout: 245 seconds]
random-nick has quit [Ping timeout: 246 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 250 seconds]
krid has quit [Ping timeout: 245 seconds]
<fengshaun>
is there an equivalent of gdb for sbcl?
lavaflow has joined #lisp
<fengshaun>
the errors seem cryptic and (trace) doesn't seem to do anything (it just prints the invocation of the function)
dilated_dinosaur has joined #lisp
<jackdaniel>
in Common Lisp you may recompile a function in question to have explicit break in it
<jackdaniel>
there is also step functionality
<fengshaun>
how do I use the step functionality?
<jackdaniel>
moreover trace allows you to specify an action
<jackdaniel>
(specifying actions in trace is implementation-dependent, so you'd need to refer to sbcl manual)
Bike has joined #lisp
<jackdaniel>
if you have a function you want to check, you may modify it and call interactively to see what's going on
<jackdaniel>
having IDE like slime helps a lot with that
<jackdaniel>
another thing is that you probably want to set speed 1 / debug 3 optimization options before compiling the code so sldb backtraces are not crippled