jackdaniel changed the topic of #commonlisp to: Common Lisp, the #1=(programmable . #1#) programming language | Wiki: <https://www.cliki.net> | IRC Logs: <https://irclog.tymoon.eu/libera/%23commonlisp> | Cookbook: <https://lispcookbook.github.io/cl-cookbook> | Pastebin: <https://plaster.tymoon.eu/>
attila_lendvai has quit [Quit: Leaving]
jeosol has joined #commonlisp
random-nick has quit [Ping timeout: 260 seconds]
dtman34_ has joined #commonlisp
dtman34 has quit [Ping timeout: 252 seconds]
junkrunner has quit [Ping timeout: 268 seconds]
AmateurLisper has quit [Quit: Leaving]
attila_lendvai has joined #commonlisp
attila_lendvai has quit [Client Quit]
thuna` has quit [Remote host closed the connection]
thuna` has joined #commonlisp
karlosz has quit [Quit: karlosz]
Nilby has joined #commonlisp
lucerne has quit [Read error: Connection reset by peer]
attila_lendvai has joined #commonlisp
seletz has joined #commonlisp
nij- has joined #commonlisp
dipper_ has quit [Remote host closed the connection]
euandreh has quit [Ping timeout: 256 seconds]
seletz has quit [Ping timeout: 268 seconds]
akoana has quit [Quit: leaving]
<jcowan> thuna`: Use wget -L 2 -r http://clhs.lisp.se/Body/
attila_lendvai has quit [Ping timeout: 260 seconds]
joast has joined #commonlisp
gxt has quit [Remote host closed the connection]
bilegeek has quit [Quit: Leaving]
gxt has joined #commonlisp
junkrunner has joined #commonlisp
anticomputer has quit [Ping timeout: 255 seconds]
anticomputer has joined #commonlisp
azimut_ has quit [Ping timeout: 255 seconds]
waleee has quit [Ping timeout: 246 seconds]
pfd has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
thuna` has quit [Quit: sleep...]
terrorjack has quit [Quit: The Lounge - https://thelounge.chat]
terrorjack has joined #commonlisp
<doulos05> Anybody here doing web work with Caveman2?
<doulos05> Or Clack/Lack for that matter (That might have the answer). I need to include Single Sign On with Google (based on OAuth2) in an app. I've found clath, which looks like what I need.
<doulos05> But I can't figure out where in the caveman2:make-package skeleton, I should put the call to `(clath:component "127.0.0.1") that I see in the documentation.
<doulos05> I've tried everywhere that seems obvious to me. lack:builder call in app.lisp, the start function in main.lisp, right after the *web* variable is instantiated in web.lisp...
Fare has quit [Ping timeout: 255 seconds]
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
gxt has quit [Ping timeout: 255 seconds]
dec0d3r has joined #commonlisp
gxt has joined #commonlisp
aartaka has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #commonlisp
nij- has left #commonlisp [Using Circe, the loveliest of all IRC clients]
<doulos05> Nevermind, I have found an error in the documentation for clath and will be submitting a pull request. The endpoint to verify clath is working is *server-url*/clath/login/, not *server-ulr*/clath/login
seletz has joined #commonlisp
seletz has quit [Ping timeout: 260 seconds]
rgherdt has joined #commonlisp
zagura___ is now known as zagura
kstuart has joined #commonlisp
igemnace has joined #commonlisp
Inline has joined #commonlisp
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
szkl has quit [Quit: Connection closed for inactivity]
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
rangahy has joined #commonlisp
Inline has quit [Client Quit]
rainthree has joined #commonlisp
|3b| has quit [Ping timeout: 252 seconds]
seletz has joined #commonlisp
enzuru has quit [Quit: ZNC 1.8.2 - https://znc.in]
seletz has quit [Ping timeout: 260 seconds]
enzuru has joined #commonlisp
rangahy has quit [Ping timeout: 268 seconds]
rangahy has joined #commonlisp
shka has joined #commonlisp
seletz has joined #commonlisp
Cymew has joined #commonlisp
ogamita has quit [Read error: Software caused connection abort]
ogamita has joined #commonlisp
aartaka has joined #commonlisp
rainthree has quit [Read error: Connection reset by peer]
<shunter> Why do lambda lists use &keywords instead of :keywords?
aartaka has quit [Ping timeout: 260 seconds]
dmgk has quit [Read error: Software caused connection abort]
dmgk has joined #commonlisp
<beach> shunter: Maybe for historical reasons.
victor has quit [Read error: Software caused connection abort]
victor has joined #commonlisp
MajorBiscuit has joined #commonlisp
<beach> Maclisp apparently had at least &OPTIONAL.
iquites has quit [Read error: Software caused connection abort]
iquites has joined #commonlisp
<beach> And &REST too.
<beach> Same for Lisp-machine Lisp.
<beach> shunter: Does that answer your question?
<shunter> So, it's for historical reasons?
<phoe> probably, yeah
<phoe> backwards compatibility and all that jazz
<aeth> It predates :keywords? Either that or because at one point you'd have to have specified your &key arguments with :keywords like that
<aeth> would be my other guess, if that was the case
<aeth> :key :foo :bar would look ugly
<shunter> I see, thanks
<phoe> (:key foo bar) though
<beach> aeth: I suggest you do some research, like I did.
junkrunner has quit [Ping timeout: 248 seconds]
doomduck has quit [Read error: Software caused connection abort]
doomduck has joined #commonlisp
contrapunctus has quit [Ping timeout: 255 seconds]
pranavats has quit [Ping timeout: 252 seconds]
causal has quit [Quit: WeeChat 3.7.1]
cosimone has joined #commonlisp
gpiero has quit [Read error: Software caused connection abort]
euandreh has joined #commonlisp
gpiero has joined #commonlisp
euandreh has quit [Remote host closed the connection]
euandreh has joined #commonlisp
rainthree has joined #commonlisp
Brucio-61 has quit [Ping timeout: 260 seconds]
rangahy has quit [Ping timeout: 260 seconds]
rangahy has joined #commonlisp
rainthree3 has joined #commonlisp
rainthree has quit [Ping timeout: 260 seconds]
azimut has joined #commonlisp
Brucio-61 has joined #commonlisp
pve has joined #commonlisp
random-nick has joined #commonlisp
rainthree3 has quit [Read error: Connection reset by peer]
rangahy has quit [Ping timeout: 260 seconds]
nij- has joined #commonlisp
jmdaemon has quit [Ping timeout: 268 seconds]
<nij-> Why do we say that handler-case unwind everything (worse), but handler-bind is able to preserve the stack?
<nij-> This is the example i'm looking at. It seems that they are doing pretty similar things: https://bpa.st/3XAQ
<beach> Why do we "say" that? Because it is so?
<nij-> Yeah my question is .. why is it so, given that they seem to do pretty similar things in the examples I gave.
<beach> That means your example does not expose the difference.
<jackdaniel> nij-: in handler-bind handlers you have access to the dynamic context of the error
<jackdaniel> i.e special variable dynamic values may differ, the call stack may be different etc
<Nilby> handler-case isn't worse if it's what you want
<jackdaniel> handler-case serves another purpose (and may be implemented in terms of handler-bind)
rangahy has joined #commonlisp
<jackdaniel> what do you think about a function name fearless-handler ? a handler that always invokes the restart "continue" when present
<_death> jackdaniel: there's already such a function, it's called CONTINUE
<hayley> (defmacro fuck-it (&body body) `(handler-bind ((error #'continue)) ,@body))
<Nilby> jackdaniel: having sufferd from having some accidentally fearless handlers, i can say you'll likely spend a lot of time back at top-level without much clue why
<pjb> (handler-bind ((error #'continue)) …)
<jackdaniel> _death: right you are :)
<jackdaniel> Nilby: I wouldn't put it in the code; I'm tinkering with the bootstrap environment (there is no debugger available then, so it is either _ecl_unrecoverable_error(c); or cl_funcall(1, continuation);
<Nilby> heh, then i guess replace top-level with c debugger command line
<Nilby> what's extra fun is fearless handlers in print-object or the debugger
<nij-> pjb, thanks for your informative example!
<nij-> In the case of (g), the backtrace doesn't even mention (error "foo")!!
<nij-> Why would anyone use handler-case then?
tyson2 has joined #commonlisp
<pjb> because in general it's enough to report the error.
<jackdaniel> handler-case is a syntactic sugar that returns when you have an error
<jackdaniel> also if you are clever enough, you don't need to cons a function for the handler body
<pjb> (handler-case (/ 1 0) (error () 'infinite)) #| --> infinite |#
<pjb> in those cases, you don't need the backtrace.
<Nilby> handler-case saves you the step of having to do some restart/return if that's what you want
<jackdaniel> s/when you handle the condition/
Brucio-61 has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 252 seconds]
<jackdaniel> I have a macro in my toy utilities handler-case* that executes the body in the dynamic context and only after that returns
<Nilby> nij-: sometimes you might even want forms wrapped in both handler-bind and handler-case
<Nilby> pjb: maybe you know, some lisps actually used ∞ as a number
kstuart has quit [Ping timeout: 260 seconds]
<jackdaniel> don't trap the fpe and enjoy *-float-{positive,negative}-infinity
rangahy has quit [Ping timeout: 260 seconds]
rangahy has joined #commonlisp
dec0d3r has quit [Quit: Leaving]
Brucio-61 has joined #commonlisp
<nij-> pjb in your (/ 1 0) example, handler-case is better because it's a bit shorter than (handler-bind ((error (lambda (c) 'infinite))) (/ 1 0))?
rangahy has quit [Ping timeout: 260 seconds]
<phoe> nij-: this handler-bind example doesn't do anything
<phoe> the return value of the handler is ignored
<nij-> yeah, same as in (handler-case (/ 1 0) (error () 'infinite))
<phoe> no
<phoe> have you tried executing these two forms in your REPL?
rangahy has joined #commonlisp
|3b| has joined #commonlisp
<nij-> yeah, the behaviour is a bit different
<nij-> Oh I see what you mean. (handler-case (/ 1 0) (error () 'infinite)) handles the error.
<nij-> Then what's an equivalent form of that in terms of handler-bind?
<jackdaniel> both handle it, one just doesn't return
<phoe> jackdaniel: actually only one handles it and the other declines to handle it
<phoe> nij-: (block nil (handler-bind ((error (lambda (c) (return 'infinite)))) (/ 1 0)))
<jackdaniel> I see that this is a term in the spec, fair enough
<phoe> yes, if a handler function returns normally without transferring control then that's the definition of "declining to handle a condition"
<jackdaniel> handler-bind may be used in many interesting ways - i.e change the dynamic state and leave the rest to the next handler
<nij-> ok, that's verbose. I can see why handler-case is useful.
pfd has quit [Quit: Client closed]
<phoe> whereas "handling" == transferring control
<phoe> but then yeah, there are many cases that you cannot cover with handler-case
<phoe> the simplest is getting the stack trace at the point where the error was signaled
<jackdaniel> another is invoking a restart that has been estabilished in the body
<nij-> I see.
<nij-> So why is the condition unhandled in (handler-bind ((error (lambda (c) 'infinite))) (/ 1 0))?
<phoe> what is handling it then?
<nij-> In phoe's example, it doesn't seem to be handled either, no? You just redirect the control flow.
<phoe> clhs 9.1
<phoe> "If a handler is invoked, it can address the situation in one of three ways: Decline (...), Handle (...), Defer (...)"
<phoe> "You just redirect the control flow." is the whole point
attila_lendvai has joined #commonlisp
<nij-> Oh, I see! "HANDLE: It can handle the condition by performing a non-local transfer of control."
<nij-> This is the meaning of "to handle"
<phoe> yep! that's the definition
<nij-> How to defer then? The CLHS doesn't mention on that page.
<phoe> and every handler in HANDLER-CASE does a non-local jump as its first and only thing
<phoe> nij-: (handler-bind ((... (lambda (c) (foo)))) ...)
<phoe> or, even better, (foo c)
<nij-> Oh, so it just means that the handler function does something else -
<phoe> or, even better, (when (foo c) (return-from ...))
<jackdaniel> or even betterer (lambda (condition continuation) (foo condition continuation))
<phoe> :D
<nij-> that's not CL, no?
<jackdaniel> no, that's not cl
<hayley> (call/cc jackdaniel)
<nij-> phoe note taking time. Thanks :D
<phoe> it can be CL, it's just not the condition system - it's a continuation-passing style program
<jackdaniel> not cl as in: not specified in cl
<hayley> Nah, I believe the modern approach is (lambda (resolve reject) ...)
<phoe> (lambda (resolve reject doubt) ...) is the modern approach, you gotta leave space for what happens in case of e.g. a network partition
<phoe> whereas a postmodern approach would require an active Postgres connection
<jackdaniel> the "continuation" part is for when you invoke stuff like cerror, the rest is the same as with cl (more or less)
scymtym has joined #commonlisp
<nij-> Thanks phoe! By the way, I have your book physically lying around me. Feel like it's the right time to read :D
<phoe> most glad to hear it
<Nilby> you can never go back, just forward to where you came from
<hayley> Post-modernists are just modernists in denial - I say it as their Postgres library undoubtedly uses CPS :)
pfd has joined #commonlisp
varjag has joined #commonlisp
<jackdaniel> didn't postgres have a lisp interpreter or something?
<jackdaniel> I think that they have scraped it at some point of time
<nij-> gotta go for now. Thanks everyone who'd helped :)
nij- has left #commonlisp [Using Circe, the loveliest of all IRC clients]
<jackdaniel> what a discrimination; people who do not help want to be appreciated too
<Nilby> #commonlisp has a very talented set of lurkers
<varjag> let's say i have a list of sorted numeric lists, and i want to collate it: '((3 4) (3 7) (5 7 9)) => ((3 3) (4) (5) (7 7) (9))
<jackdaniel> and we have a proof that they are not forgotten ssh session on sdf - thanks to the great libera chat migration
<varjag> is there a nice clean way to do this?
<varjag> cause i keep ending with ugly looking loops
<_death> just count them and generate a list based on that?
<varjag> _death: it's simplifed, the acutal objects are not numbers but number-keyed objects
<phoe> varjag: (serapeum:assort (alexandria:flatten '((3 4) (3 7) (5 7 9))))
<varjag> phoe: heh nice
<varjag> gotta check if there's less overhead with these two than with my ugly loops
<varjag> mm
<jackdaniel> (constantly '((3 3) (4) (5) (7 7) (9)))
<phoe> (deftype t () '(satisfies constantly))
MajorBiscuit has quit [Ping timeout: 255 seconds]
<pjb> jackdaniel: a prototype of postgres was implemented in lisp.
<varjag> that's just mean… imagine if i was doing my homework
<pjb> jackdaniel: it is possible to plug-in languages for stored procedure, so theorically, you could hook ecl into postgres.
<pjb> this may have been done for some scheme.
<jackdaniel> what I'm attempting to do now is to stick common lisp into a microcontroller :3
<phoe> as in compile some CL code onto it, or actually run a whole CL runtime there?
<pjb> or a pruned tree thereof.
<phoe> if the latter, what's the microcontroller hardware constraints?
<pjb> 32-bit 2MB RAM.
<Nilby> varjag: (mapcar #'cdr (sort (group-by-alist #'identity (flatten '((3 4) (3 7) (5 7 9)))) #'< :key #'car))
<jackdaniel> aren't you asking too many specific questions for an early stage of the project?
<phoe> well, mmmmaybe
<jackdaniel> 'whole cl runtime' is a vague term, especially when we assume that some modules may be lazily loaded (or error if they requested but not present)
<phoe> yes, I see
<jackdaniel> (defun compile (&rest args) (declare (notinline)) (load "sys:compiler"))
<Bike> (reduce (lambda (l1 l2) (merge 'list l1 l2 #'<)) '((3 4) (3 7) (5 7 9))), just to actually use merge for once
<jackdaniel> and what is common lisp if not a dozen of special operators plus a huge standard library, hm?
<phoe> just three smaller lisp dialects in a trench coat
<jackdaniel> and yes, I'm jelly of what ulisp achieved portability-wise ;)
<Nilby> to fit CL in small things you'd probably have to discard modern things such as unicode
<jackdaniel> well, I'll update you on the progress if I have anything to show, probably on my blog ;p
MajorBiscuit has joined #commonlisp
<Nilby> just char-name on unicode is huge
<jackdaniel> Nilby: the lazy loading thing something
<varjag> thanks
<phoe> Nilby: store it in ROM, it's so much cheaper than RAM on many platforms
<jackdaniel> generally if we are picky, then storing all standard symbol names in memory is huge
<Nilby> I've seen lisps with symbols stored as prefix trees, slower but small
<jackdaniel> another thing is that common lisp symbols are fat
* Nilby used to run lisp 1.X on a pdp8 with maybe 6k ram?
<jackdaniel> you have a name, two values (function and variable), type, home package, property list
Bike has quit [Quit: leaving]
<Nilby> no strings only symbols
Bike has joined #commonlisp
<beach> Nah, you can put all but the name and the package in the environment.
<beach> ... as we do in SICL.
<phoe> even then, I assume you could stuff all standard CL symbols into ROM; the only "property" that can change about them is symbol-plist, right?
<jackdaniel> yes, and still the fattest part is the name
<phoe> also ROMable in case of CL and many keywords
random-nick has quit [Ping timeout: 268 seconds]
attila_lendvai has quit [Remote host closed the connection]
pfd has quit [Quit: Client closed]
<jackdaniel> either way even if I fail, some improvements are already made in a process, most notably delimited continuations are back (not pushed yet)
<Bike> oh, that's cool. in ecl generally?
<jackdaniel> yes
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
<Bike> what's the interface look like?
<jackdaniel> I've defined it the same as it used to be in ecl before green threads were removed (see commit 0312839e1 for documentation)
<jackdaniel> some things may still change of course
<jackdaniel> (make-continuation <thread>) and (resume <continuation>)
<Bike> you can only use the continuation once?
<jackdaniel> yes
<Bike> i don't understand how you could do like shift/reduce with this. having external continuations is cool, though
attila_lendvai has joined #commonlisp
<jackdaniel> shift/reset ?
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #commonlisp
<jackdaniel> right, so reset (not reduce)
MajorBiscuit has quit [Ping timeout: 255 seconds]
<jackdaniel> I'll see how these examples may be implemented with what ecl has now before making a pull request; that will surely make a good program for examples/
chrcav has quit [Quit: Lost terminal]
chrcav has joined #commonlisp
Fare has joined #commonlisp
morganw has joined #commonlisp
thuna` has joined #commonlisp
waleee has joined #commonlisp
Inline has joined #commonlisp
aartaka has joined #commonlisp
son0p has quit [Ping timeout: 256 seconds]
MajorBiscuit has joined #commonlisp
jeosol has quit [Quit: Client closed]
Cymew has quit [Ping timeout: 256 seconds]
nij- has joined #commonlisp
rangahy has quit [Ping timeout: 256 seconds]
<nij-> With CFFI, can I execute any C code on the fly? Something like (cffi:execute "int fn () { \n return 0;\n }")?
<nij-> Or I must use that code to produce a shared library separately, and load it with CFFI?
<phoe> Nilby: the latter
<phoe> if anything, use ECL, it has an option for inline C code
<Bike> cffi would need to be or include a c compiler to do that, nij-
<jackdaniel> c interpreter would be enough!
<Bike> granted.
<phoe> embrace the dark side
waleee has quit [Ping timeout: 252 seconds]
MajorBiscuit has quit [Ping timeout: 260 seconds]
rangahy has joined #commonlisp
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
attila_lendvai_ has joined #commonlisp
attila_lendvai has quit [Read error: Connection reset by peer]
<nij-> Is there a C interpreter?
attila_lendvai_ has quit [Remote host closed the connection]
<Bike> there are c interpreters, but not in cffi
attila_lendvai_ has joined #commonlisp
<Bike> cffi is for calling c code, not writing c code.
attila_lendvai_ has quit [Remote host closed the connection]
<nij-> Got it. But I can always write a wrapper in C that writes the C code, compiled to SO, and load.
<nij-> Thanks!
<nij-> I've heard though that C oughts to be compiled, and no interprettor can really do what the compile does semantically.
MajorBiscuit has joined #commonlisp
<Bike> nah, there are c interpreters. and actually, in modern C++ (which isn't C, but eh) constexpr probably means a compiler has to have some kind of interpreter in it as well.
<nij-> Are they semantically the same?
<nij-> Oh, I even recall that emacs have both (compiler and interpreter), and it's hard to converge their semantics.
<Bike> eh, CL does it
<beach> There is a long-ish Lisp tradition that the interpreter uses dynamic variable bindings and the compiler uses lexical variable bindings, but that tradition was abandoned (luckily) in Common Lisp.
<beach> Maybe that's what Emacs Lisp does.
<nij-> beach in CL both use lexical?
<beach> Yes.
<Bike> there are differences between compiling and evaluating, but they're pretty minor and mostly relate to redefinitions.
<nij-> Nice.
<nij-> If C even has a JIT compiler, then we don't need to worry about possible divergence in semantics.
<phoe> and one edge case wrt load-time-value
<beach> I also recall that Franz Lisp (not Allegro) went to a lot of trouble to make the compiler respect dynamic variable bindings for many things.
markb1 has joined #commonlisp
karlosz has joined #commonlisp
cage has joined #commonlisp
cosimone` has joined #commonlisp
cosimone has quit [Ping timeout: 252 seconds]
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
cosimone` has quit [Ping timeout: 246 seconds]
szkl has joined #commonlisp
Oladon has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
son0p has joined #commonlisp
junkrunner has joined #commonlisp
<White_Flame> nij-: I think it would actually be harder to write a JIT compiler for C than other languages. It would be harder to infer what runtime heuristic info you need to collect to get any benefit
Fare has quit [Ping timeout: 252 seconds]
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
notzmv has joined #commonlisp
<nij-> You mean it's harder to optimize a JIT compiler for C?
aartaka has quit [Ping timeout: 268 seconds]
sedzcat has joined #commonlisp
rangahy has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
Fare has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 268 seconds]
Lycurgus has joined #commonlisp
Fare has quit [Ping timeout: 260 seconds]
Fare has joined #commonlisp
junkrunner has quit [Ping timeout: 256 seconds]
nij- has quit [Ping timeout: 268 seconds]
rangahy has joined #commonlisp
Oladon has quit [Quit: Leaving.]
Lycurgus has quit [Quit: Exeunt https://tinyurl.com/4m8d4kd5]
morganw has quit [Remote host closed the connection]
<luis> Someone at ELS did some work on method inlining, or some sort of class sealing and I can't recall who. Does anybody have any idea what I'm talking about?
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
random-nick has joined #commonlisp
<luis> _death: that's exactly it. Thanks!
rainthree has joined #commonlisp
thuna` has quit [Remote host closed the connection]
thuna` has joined #commonlisp
hrberg has quit [Quit: https://quassel-irc.org - Chat comfortably. Anywhere.]
hrberg has joined #commonlisp
<Bike> Is there any way to wrap quicklisp dependency resolution around a dynamic extent? So that e.g. (with-quicklisp (asdf:load-system :foo)) will try getting the system from quicklisp if it's not available. I think quicklisp internally establishes a handler on asdf:missing-dependency
Bung has joined #commonlisp
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
<_death> so.. what would be the problem of writing such an operator?
<Bike> the way quicklisp does it internally involves asdf internals and some kind of table to avoid loops
rgherdt_ has joined #commonlisp
rgherdt has quit [Ping timeout: 255 seconds]
<_death> by "asdf internals" do you mean the readers for the condition?
<_death> I would think these ought be exported (and get better names)
<yitzi> I think clpm does that?
<yitzi> You can wire it into load-system or require
<yitzi> Bike: ^
<Bike> _death: i agree. i just don't want to do this myself if it exists already, mainly
<Bike> I can check out clpm
rainthree3 has joined #commonlisp
rainthree has quit [Read error: Connection reset by peer]
qhong has quit [Ping timeout: 246 seconds]
qhong has joined #commonlisp
varjag has joined #commonlisp
qhong has quit [Ping timeout: 260 seconds]
<pjb> Bike: (defmacro with-quicklisp (load-form) `(ql:quickload ,@(rest load-form))) (with-quicklisp (asdf:load-system :foo)) #| ERROR: System "foo" not found |#
rainthree3 has quit [Quit: see you later]
qhong has joined #commonlisp
ym has joined #commonlisp
causal has joined #commonlisp
junkrunner has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
Fare has quit [Ping timeout: 260 seconds]
Brucio-61 has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 252 seconds]
lisp123 has joined #commonlisp
waleee has joined #commonlisp
frgo has joined #commonlisp
shka has quit [Ping timeout: 248 seconds]
rgherdt_ has quit [Remote host closed the connection]
contrapunctus has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]
Brucio-61 has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
Bung has quit [Remote host closed the connection]
Fare has joined #commonlisp
aartaka has quit [Ping timeout: 255 seconds]
seok has joined #commonlisp
<seok> is there a resource for clojure from the perspective of a common lisp programmer? or a reference to the differences
<seok> Looking to use some java api's
<contrapunctus> seok: is ABCL not an option?
<seok> hadn't thought about that, indeed that could be better
frgo has quit []
sedzcat has quit [Quit: sedzcat]
euandreh has quit [Quit: euandreh]
euandreh has joined #commonlisp
euandreh has quit [Remote host closed the connection]
euandreh has joined #commonlisp
euandreh has quit [Ping timeout: 260 seconds]
varjag has quit [Read error: Connection reset by peer]
varjag has joined #commonlisp
varjag has quit [Client Quit]
dra has joined #commonlisp
seok has quit [Quit: Leaving]
euandreh has joined #commonlisp
Fare has quit [Read error: Connection reset by peer]
Fare has joined #commonlisp
euandreh has quit [Ping timeout: 260 seconds]
junkrunner has quit [Ping timeout: 255 seconds]
NotThatRPG has quit [Quit: Textual IRC Client: www.textualapp.com]
euandreh has joined #commonlisp
jmdaemon has joined #commonlisp
nij- has joined #commonlisp
<nij-> I'm doing a long computation with many intermediate result. At the end, I need to analyze that result. However, the intermediate results are too large, and sometimes it fill the heaps. I wonder if there are some data structure that is persistant and doesn't use memory at all (hopefully, it feels like using a hash table)?
<phoe> a data structure that uses no memory at all
<phoe> oh boy
<nij-> ? what's wrong? I don't mind the poset-analysis being slow, so I think it's fine if it's backended by files on disks.
<Nilby> nij-: stream to a file
jeosol has joined #commonlisp
<nij-> Yeah, i'm really looking for an existing CL system that does that for me (with nice abstraction, so I feel like I'm using a hash table).
rangahy has quit [Ping timeout: 260 seconds]
<Nilby> maybe a simple key store like zcdb
Fare has quit [Ping timeout: 260 seconds]
<nij-> Hmmm "cdb can handle any database up to 4 gigabytes."
<nij-> This is less than the 8GB I allow my lisp to have. :-(
<_death> my old leveldb bindings may do the job
<nij-> _death: could you briefly describe what it does?
<nij-> no info in readme
random-nick has quit [Ping timeout: 260 seconds]
<_death> back then I used it for some bitcoin index dbs, which took a few gigs
<nij-> > LevelDB is not an SQL database. Like other NoSQL and dbm stores, it does not have a relational data model and it does not support SQL queries.
<nij-> How does its query lang look like, then @@?
<_death> like a hash table, basically.. (leveldb:puts db "Hello" "World") (leveldb:gets db "Hello") => "World"
<nij-> How well does it handle higher dimensional database?
<nij-> (By that I mean the keys will be lists..)
<_death> it doesn't do that out of the box.. you will need to encode them into octets or strings
brettgilio has quit [Ping timeout: 268 seconds]
<nij-> How about.. if my keys are plists (:x _ :y _ :z _)
<nij-> and say I want to get all values of keys with :y = 2 and :z = 1?
<_death> again, you'll need to do that yourself or use another system.. leveldb is rather low level
<nij-> Got it. Thank you, _death.
<_death> maybe fact-base or something.. I don't remember if it stores everything in memory or not, though
random-nick has joined #commonlisp
Fare has joined #commonlisp
epony has quit [Quit: QUIT]
junkrunner has joined #commonlisp