jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <http://cliki.net/> <https://irclog.tymoon.eu/freenode/%23lisp> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.5.4, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
nonlinear9 has joined #lisp
nonlinear has quit [Quit: Ping timeout (120 seconds)]
mingus has quit [Ping timeout: 268 seconds]
Elronnd has joined #lisp
makomo has quit [Ping timeout: 245 seconds]
Necktwi has quit [Ping timeout: 268 seconds]
gxt_ has quit [Quit: WeeChat 2.4]
Necktwi has joined #lisp
dialectic has quit [Ping timeout: 245 seconds]
ebrasca has quit [Remote host closed the connection]
wigust- has joined #lisp
wigust has quit [Ping timeout: 268 seconds]
lemoinem is now known as Guest77558
Guest77558 has quit [Killed (tolkien.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
jabr0ni has quit [Ping timeout: 245 seconds]
SenasOzys has joined #lisp
keep_learning_M has joined #lisp
dialectic has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life has joined #lisp
Elronnd has quit [Ping timeout: 245 seconds]
t58 has quit [Quit: Leaving]
Elronnd has joined #lisp
Ricchi has quit [Remote host closed the connection]
esrse has joined #lisp
slac-in-the-box has quit [Ping timeout: 245 seconds]
Ricchi has joined #lisp
kdas_ has joined #lisp
kushal has quit [Ping timeout: 260 seconds]
akoana has left #lisp ["Leaving"]
Inline has quit [Ping timeout: 252 seconds]
oni-on-ion has quit [Remote host closed the connection]
^ is now known as [
[ is now known as ^
nonlinear9 has quit [Quit: The Lounge - https://thelounge.github.io]
nonlinear has joined #lisp
^ is now known as [
Necktwi has quit [Ping timeout: 245 seconds]
karswell_ has quit [Remote host closed the connection]
karswell_ has joined #lisp
dialectic has quit [Ping timeout: 258 seconds]
torbo has quit [Remote host closed the connection]
SenasOzys has quit [Ping timeout: 258 seconds]
dddddd has quit [Remote host closed the connection]
dialectic has joined #lisp
Necktwi has joined #lisp
<beach> Good morning everyone!
devon has quit [Ping timeout: 246 seconds]
Ricchi has quit [Remote host closed the connection]
ggole has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
ebobby has joined #lisp
vlatkoB has joined #lisp
ebobby has quit [Quit: Lost terminal]
SenasOzys has joined #lisp
varjag has joined #lisp
oni-on-ion has joined #lisp
gareppa has joined #lisp
SenasOzys has quit [Ping timeout: 272 seconds]
dale has quit [Quit: dale]
Necktwi has quit [Ping timeout: 244 seconds]
Necktwi has joined #lisp
kdas_ is now known as kushal
v88m has quit [Ping timeout: 258 seconds]
v88m has joined #lisp
bitch has quit [Ping timeout: 245 seconds]
martylake has quit [Remote host closed the connection]
martylake has joined #lisp
varjag has quit [Ping timeout: 272 seconds]
dacoda has joined #lisp
zhlyg has joined #lisp
martylake_ has joined #lisp
martylake has quit [Ping timeout: 272 seconds]
Lycurgus has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
scymtym has quit [Ping timeout: 245 seconds]
dacoda has quit [Ping timeout: 252 seconds]
yangby has joined #lisp
yangby has quit [Client Quit]
rozenglass has joined #lisp
gareppa has quit [Quit: Leaving]
oni-on-ion has quit [Remote host closed the connection]
dale has joined #lisp
vaporatorius has joined #lisp
dialectic has quit [Ping timeout: 248 seconds]
scymtym has joined #lisp
<LdBeth> beach: morning beach
catalinbostan has joined #lisp
dialectic has joined #lisp
Elronnd has quit [Quit: Elronnd]
<White_Flame> What's the most idiomatic way to combine remove-if-not (filter) and mapcar (transform) in a single pass?
<ck_> loop when .. collect?
<dialectic> +1
<White_Flame> hmm, yeah, my loop-fu is weak
Necktwi has quit [Ping timeout: 246 seconds]
<dialectic> look before you loop (use iterate)
v0|d has quit [Read error: Connection reset by peer]
<phf> edgar-rft: thank you for doing the legwork! i also reached out to author, but haven't heard anything back yet
cosimone has joined #lisp
<aeth> White_Flame: if you don't like loop you can just write your own macro or higher order function on top of it
<aeth> map-with-filter or something
<White_Flame> no, I'm using loop
<White_Flame> I like standard stuff, even if iterate does make it nicer
<aeth> dialectic: I'd use iterate if it was just loop with parens and extensibility, but it's its own very different thing that I can't expect people to be able to read
<White_Flame> and I'm sure loop hides faster imperativeness than I want to bother implementing myself
<aeth> loop-with-parens (I'll call it do-loop) is (far) on my todo list, though.
<dialectic> I wouldn't call it "very different"
<aeth> It fills the same niche very differently. It has a learning curve.
<dialectic> Perhaps. That's a fair criticism. I didn't regret the one day it took to learn it, though. I never use loop anymore.
<aeth> It is well documented.
<aeth> You kind of have to be well documented with a macro like that.
<dialectic> I tried SERIES as well. That one... wasn't as fun.
<LdBeth> GG
orivej has joined #lisp
<phf> White_Flame: at least on cmucl (loop when ... collect) expands into a tagbody with setq's and go's, so yeah, not something you might want to write yourself
<aeth> one macro that would be fun is one that is essentially a miniature computer algebra macro
<dim> loop/iterate, there's also the “for” macro but I can't seem to be finding the repo again easily
<dialectic> Someone did that, in lisp, and made a lot of money off of it :P
phf has left #lisp [#lisp]
<aeth> I mean (sum for i from 1 to 32 by 7) or something
<aeth> and obviously you can get a lot more elaborate from there
<aeth> On the surface, SUM would look like LOOP's sum clause, but under the hood it would be using https://en.wikipedia.org/wiki/Summation#Identities because it would have more restrictions on what can be summed
Necktwi has joined #lisp
<dim> ahah, found it, the for looping macro is at https://shinmera.github.io/for/ and it looked interesting, it's on my “list” of things to try someday
<aeth> you can't use FOR and ITERATE in the same package without prefixes because ITERATE has this weird thing with symbols and expects to be :USEd, unlike LOOP, which accepts any package. So for:for and iterate:for will collide
<aeth> interestingly, according to that page, for is basically intended to be used with its package prefix... so as for:for
<aeth> I guess because conflicts would be common
<dialectic> are the clauses matched by symbol-name or eq?
<White_Flame> this is literally what keywords are for. why are the underused in places like this?
<dialectic> -shrug-
<dialectic> Possibly because iterate lets you define your own clauses.
<dialectic> Well, it lets you define drivers... but those are only for FOR clauses. Hm.
v0|d has joined #lisp
<aeth> White_Flame: that's one of the places where my macro would differ from FOR/ITERATE/SERIES/etc. I like keyword-utilising LOOP because it makes the ALGOL-style keywords stand out as, well, Lisp keywords
<aeth> White_Flame: But, yes, keywords aren't really used because it's intended to be extensible.
<aeth> I guess you could keyword the built-ins and expect the extensions to be namespaced, but that could look weird
<aeth> but that's only for the first part of a clause. If you're doing (:for x :from 1 :to 42) the rest of the clause should have keywords. Then you can implement that as a plist tail and have order not matter and internally use destructuring-bind with &key
<aeth> even if it's (foobar:for x :from 1 :to 42)
dale has quit [Quit: dale]
hhdave has joined #lisp
<dialectic> Are there SERIOUS-CONDITIONs that are not ERROR?
<aeth> yes
<White_Flame> clhs storage-condition
<aeth> inspecting it in SBCL, I get the subclasses: (#<sb-pcl::condition-class sb-di:debug-condition> #<sb-pcl::condition-class sb-sys:interactive-interrupt> #<sb-pcl::condition-class sb-ext:timeout> #<sb-pcl::condition-class common-lisp:storage-condition> #<sb-pcl::condition-class common-lisp:error>)
Necktwi has quit [Quit: leaving]
<aeth> most of these are internal to SBCL, but that means that your implementation might add others on top of the two specified, and libraries might add others
schweers has joined #lisp
hhdave has quit [Ping timeout: 248 seconds]
makomo has joined #lisp
alca has quit [Quit: bye!]
donotturnoff has joined #lisp
hhdave has joined #lisp
<aeth> (CCL only has one extra, external-process-creation-failure)
karswell_ has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 246 seconds]
karswell_ has joined #lisp
<aeth> It's interesting that CCL uses standard-classes and SBCL uses sb-pcl::condition-classes
heisig has joined #lisp
amerlyq has joined #lisp
dialectic has quit [Ping timeout: 258 seconds]
fivo has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
fivo has quit [Client Quit]
random-nick has joined #lisp
orivej has joined #lisp
rozenglass has quit [Remote host closed the connection]
rozenglass has joined #lisp
martylake has joined #lisp
martylake_ has quit [Ping timeout: 245 seconds]
m00natic has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
libre-man has quit [Ping timeout: 244 seconds]
notzmv has quit [Ping timeout: 258 seconds]
libre-man has joined #lisp
keep_learning_M has joined #lisp
frgo has quit [Remote host closed the connection]
pillton has quit [Remote host closed the connection]
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 246 seconds]
hhdave_ is now known as hhdave
kajo has quit [Ping timeout: 276 seconds]
dacoda has joined #lisp
makomo has quit [Ping timeout: 268 seconds]
Lycurgus has quit [Quit: Exeunt]
frgo has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
cosimone has joined #lisp
karswell_ has quit [Remote host closed the connection]
ebrasca has joined #lisp
karswell_ has joined #lisp
esrse has quit [Ping timeout: 268 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
m00natic has quit [Remote host closed the connection]
cosimone has quit [Quit: WeeChat 2.4]
donotturnoff has quit [Ping timeout: 245 seconds]
scymtym has quit [Ping timeout: 252 seconds]
frgo_ has joined #lisp
frgo has quit [Ping timeout: 248 seconds]
frgo_ has quit [Ping timeout: 268 seconds]
makomo has joined #lisp
<drmeister> What's the poop with compiler macros and the slime interactive macro expansion. Is it not supposed to expand compiler macros - or is it an implementation dependent detail?
Inline has joined #lisp
catalinbostan has quit [Quit: Textual IRC Client: www.textualapp.com]
dddddd has joined #lisp
<LdBeth> It is not supposed to do so
keep_learning_M has joined #lisp
keep_learning_M has quit [Client Quit]
<drmeister> Hmmm, do you know why? I kinda hoped I could expand compile-macros with it because I've got some gnarly code expansion going on. Reading the slime code I see it talks about compiler-macros but I don't see where it uses their expansions.
oni-on-ion has joined #lisp
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
kajo has joined #lisp
<LdBeth> drmeister: an implementation can choose to not perform compiler macro expandsion
catalinbostan has joined #lisp
anewuser has joined #lisp
<LdBeth> If you’re interested in how compiler macro expands, you get the sense that compiler macros work exactly as ordinary macros
egp_ has joined #lisp
catalinbostan has quit [Client Quit]
anewuser has quit [Ping timeout: 258 seconds]
keep_learning_M has joined #lisp
Inline has quit [Ping timeout: 252 seconds]
varjag has joined #lisp
<pfdietz> My complaint with ITER is that it breaks Waters' COVER. The latter is cheating slightly, but usually isn't caught at it. ITER is an exception.
pfdietz has quit [Remote host closed the connection]
wxie has joined #lisp
martylake has quit [Remote host closed the connection]
martylake has joined #lisp
Necktwi has joined #lisp
pfdietz has joined #lisp
<drmeister> LdBeth: thank you
Inline has joined #lisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
rippa has joined #lisp
<dtw> If there is a :test key argument for function (e.g. (position item sequence :test ...)) is there a guarantee for a specific order of arguments for the test function? The spec _could_ be interpreted that "item" is given first and "sequence's" element (or value of :key function) is second. It's not totally clear, though. http://www.lispworks.com/documentation/HyperSpec/Body/17_ba.htm
Lord_of_Life has joined #lisp
manualcrank has joined #lisp
<dtw> I'm using (position-if ...) so I get to build the test function myself. I'm just curious how you interpret the spec.
<dtw> This whole question is not meaningful with EQL or such symmetrical test functions but with > or < it's important.
<pfdietz> Look at "satisfy the test" in the glossary of the CLHS
<pfdietz> "(for a two argument test) to be in a state such that the two-place predicate which is the sequence function's test argument returns true when given a first argument that is the object being considered, and when given a second argument that is the result of calling the sequence function's key argument on an element of the sequence function's sequen
<pfdietz> ce argument which is being tested for equality; "
<ggole> Seems as if both the glossary and the page agree that 'the object', eg, the value that is not an element, is the first argument.
<ggole> Using position-if rather than relying on that would surely be better style though.
<pfdietz> There is still a question of what's required for SEARCH and MISMATCH.
<pfdietz> And for the set functions (UNION, etc.) it's almost certainly bad form to depend on a particular order.
<pfdietz> BTW, this makes me want some sort of categorical notion that links equality functions with hash functions.
martylake has quit [Remote host closed the connection]
<dtw> pfdietz: Thanks. Indeed it reads there in the glossary. For code-reading human it's probably better to use *-if and *-if-not functions.
fivo has joined #lisp
<ggole> pfdietz: do you mean x = y implies hash x = hash y (the usual requirement)? Or did you mean some lower level thing to do with ensuring that holds?
<Xach> hmm: (401 "Unauthorized" from #<GITHUB-REQUEST :GET to "https://api.github.com/repos/sionescu/fiveam/releases">)
Bike has joined #lisp
karswell_ has quit [Read error: Connection reset by peer]
karswell_ has joined #lisp
<Xach> hmm, looks like github is blacklisting me somehow, actually.
<Xach> ugh.
<Xach> ahh, How Stale Was My Token
<ck_> sounds like the title of an easy listening song
Inline has quit [Quit: Leaving]
dacoda has quit [Ping timeout: 252 seconds]
djeis[m] has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
sjl_ has joined #lisp
ebrasca has quit [Remote host closed the connection]
rozenglass has quit [Remote host closed the connection]
sjl_ has quit [Quit: WeeChat 2.3-dev]
cosimone has joined #lisp
saravia has joined #lisp
sjl has joined #lisp
egp_ has left #lisp ["Leaving"]
FreeBirdLjj has joined #lisp
faheem has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
Tristam has joined #lisp
smazga has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
schweers has quit [Ping timeout: 252 seconds]
fortitude has joined #lisp
donotturnoff has joined #lisp
v88m has quit [Ping timeout: 248 seconds]
amerlyq has quit [Ping timeout: 244 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
ym555 has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
heisig has quit [Quit: Leaving]
wxie has quit [Ping timeout: 276 seconds]
karswell_ has quit [Remote host closed the connection]
karswell_ has joined #lisp
ym555 has quit [Read error: Connection reset by peer]
notzmv has joined #lisp
dmh has joined #lisp
<pjb> White_Flame: (mapcaN (lambda (item) (when (funcall filter item) (list (funcall transform item)))) list)
<pjb> White_Flame: note: mapcaN allows you to map 1 -> N (0..*) in a flat list.
linli has joined #lisp
chipolux_ has quit [Ping timeout: 248 seconds]
linli has quit [Remote host closed the connection]
scymtym has joined #lisp
hhdave has quit [Quit: hhdave]
<makomo> any recommendations for libraries providing dataframe-like functionality? i have some json data that encodes various relations and it would be neat to be easily to do GROUP BYs, JOINs, etc.
<makomo> my first idea is to just insert the data into an in-memory sqlite database and work with that
Arcaelyx has joined #lisp
iovec has joined #lisp
igemnace has joined #lisp
chipolux has joined #lisp
v0|d has quit [Remote host closed the connection]
interruptinuse has quit [Quit: ZNC - https://znc.in -- bye bye!]
interruptinuse has joined #lisp
w37 has quit [Remote host closed the connection]
catalinbostan has joined #lisp
cosimone has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
amerlyq has joined #lisp
abhixec has joined #lisp
orivej has joined #lisp
cosimone has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
ggole has quit [Quit: Leaving]
shka_ has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
karswell_ has quit [Ping timeout: 248 seconds]
keep_learning_M has quit [Quit: This computer has gone to sleep]
amerlyq has quit [Read error: Connection reset by peer]
amerlyq has joined #lisp
slyrus_ has joined #lisp
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
<pfdietz> ggole: the former
catalinbostan has quit [Quit: Textual IRC Client: www.textualapp.com]
random-nick has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
<faheem> makomo: Weird. I kind of came here to ask exactly that questoin.
<faheem> The only thing I'm aware of is a library that Tamas Papp wrote. But it's kind of abandoned.
<makomo> faheem: hah :-). have you found and tried any?
<makomo> i see
<faheem> And I'm not sure how usable it is.
<makomo> i found two more
<faheem> makomo: Haven't you come across it? It's the topic hit for -> data frame common lisp
<makomo> yeah, i found it, but was wondering whether you tried it
<makomo> this is another one https://github.com/blindglobe/rho
<faheem> makomo: No, I haven't. It didn't exactly seem developed. Tamas apparently decided that Julia was a better better bet.
<faheem> I'm not exactly a regular CL user, but I'd like to use it more.
<makomo> yeah :/
<makomo> ah, i see
<faheem> makomo: Did you find anything that seemed at all usable. Something like Pandas seems hopeless, unfortunately.
<makomo> at a glance both of these seem kind of usable, but both are underdocumented and not really finished, so, nope :(
<faheem> Ah, blindglobe is Tony Rossini. The statistician.
<makomo> mhm :)
<faheem> I think he was trying to developed CL for statistics. Looking.
<faheem> developed -> develop
<makomo> yup, just found that -- https://github.com/blindglobe/common-lisp-stat
<faheem> 76 commits. Hmm.
<faheem> makomo: Yes, that one.
<makomo> "ann" being the name of the dataframe lib
<makomo> hm, or not
<shka_> what you are looking for?
<makomo> but it looks abandoned as well
<makomo> shka_: a dataframe library
<shka_> all suck
<makomo> as in R's or Pandas' dataframe
<shka_> i wrote my own
<makomo> does your suck as well? :)
<makomo> yours*
<shka_> makomo: kinda, it is fresh
<faheem> "experimenting with Tamas' cl-data-frame"
<makomo> shka_: is it public?
<shka_> yes
<shka_> and cl ecosystem has some mostly lackluster CSV libs which makes things harder
<faheem> shka_: Oh dear. Everyone writing their own is kind of a guarantee that nothing with ever be complete enough to use.
<shka_> faheem: yeah, it sucks
<shka_> but, as i said, nothing was really any good
<shka_> this one solves few critical points at the very least
<makomo> faheem: yeah :/
<faheem> shka_: 384 commits is better than some. Of course, it depends on the commits. Do you have tests?
<faheem> And have you used it for real work?
<shka_> faheem: some tests, yes
<faheem> ok
<shka_> and yes, i use it quite a lot
<makomo> shka_: does yours support stuff like joins/merges/group-bys?
<faheem> shka_: Was the Tamas one no good?
<shka_> faheem: could you please give me a link to it?
<faheem> shka_: one sec.
<shka_> makomo: no joins, no merges, it leans back on the cl-data-structures though so group by just works
<faheem> shka_: What makomo said.
<faheem> shka_: leans back?
amerlyq has quit [Quit: amerlyq]
<shka_> yeah, it is another lib, has some data structures (not relevant here) and operations that are supposed to work on abstract interfaces
<faheem> shka_: Are you talking about tpapp's library?
<shka_> no, i am talking about my own lib
<faheem> shka_: ok
<shka_> give me a second, i will show you how this works
<faheem> ok
<shka_> ok, so there is this abstraction called ranges, and there is abstraction called aggregation functions
<faheem> shka_: What kind of printing/display do you have?
<faheem> I know that's kind of trivial, but I tend to be visual.
<shka_> faheem: none, currently, i am planing of making viewer in CLIM
<shka_> which seems to be the best option nowdays
lucasb has joined #lisp
<faheem> shka_: I was just thinking of an ascii one. Like R or Pandas.
<faheem> But go on.
<shka_> ascii is fine, but I strongly prefer having GUI
<faheem> makomo: Are you still there?
<makomo> yup
<faheem> shka_: If I might interrupt, how does yours compare to the tpapp one?
<makomo> this indexing business is pretty neat. tpapp has a library related to that https://github.com/tpapp/cl-slice
<shka_> anyway, idea is that aggregation functions work on ANY range so if you just manage to implement the right protocol it simply chew it trough fine
<faheem> shka_: ok
<shka_> i have stuff like line-by-line range so you can work with text files this way
<shka_> and defining aggregation functions is actually easy to it is extendable
<aeth> For CL GUIs you can use Sketch, but you'd have to write your own way to render graphs/etc. to it. https://github.com/vydd/sketch
<faheem> aggregation reminds me of SQL.
<shka_> faheem: same basic idea
<shka_> anyway, back to data frames
<makomo> faheem: that's pretty much what i want to use dataframes for, and yeah, the two are very related
<faheem> Ideally one would be able to write to some kind of abstract canvas.
<shka_> so my implementation is very basic at the moment, and main focus was on core ideas like mutability and the right API
<shka_> but i find it personally useful
<faheem> shka_: Ok. I hope you don't abandon yours as well.
<faheem> That seems to be the fate of CL libraries, sadly.
<shka_> no, i am still working on it
<faheem> Most of them, anyway.
<faheem> shka_: Good for you. So, have you looked at the tpapp library?
<shka_> but before i can put it in the QL i will have to stabilize cl-data-structures
<faheem> Don't mean to pester you...
<shka_> faheem: yeah, i did look at it, does not support sparse columns which is deal breaker for me
<faheem> is Quicklisp pretty open, in the sense that anyone can put anything in there?
<faheem> shka_: Ok, but overall how does it compare to yours? Less developed or just different?
<faheem> You should see if you could take features/ideas from there. All this replication is very inefficient.
<shka_> it is simpler, i had very specific set of features i wanted to have
<faheem> And I don't know what sparse columns are.
<faheem> shka_: Ok. Based on what? R / Pandas / something else / nothing?
<Xach> faheem: There's a process that I moderate and most stuff goes in but some stuff does not.
<shka_> faheem: so the thing is that i have HUGE data sets filled mostly with nulls
<faheem> Xach: Ok
<faheem> shka_: Right, sparse data sets.
<shka_> they literally won't fit in memory unless you are smart about it
<faheem> shka_: What kind of data?
dmh has quit [Quit: Connection closed for inactivity]
<shka_> QL is pretty open but i don't want to put garbage in it
<faheem> sure
<shka_> faheem: mostly medical stuff
<Xach> I don't consider the garbage-ness of a project when looking at a request to add something.
<faheem> Ah. Bioinformatics, or something else?
<faheem> Xach: Do you require tests?
<Xach> faheem: no. it must build on sbcl on linux, though.
<faheem> Xach: I see
<Xach> that means it compiles without (full) warnings
<shka_> Medical, claims. Some bright mind figured that ideal way to represent the diagnosis is to store them in 20 seperate columns
<faheem> shka_: You said the kpapp library does slicing.
<faheem> Is that right?
<faheem> shka_: Ah, so patient data. Got it.
<faheem> Probably not too large, thne.
<faheem> then.
<shka_> faheem: very large actually
<faheem> shka_: Oh? Ok.
<shka_> i have 60 GB CSV files.
<faheem> shka_: wow
<shka_> mostly filled with nulls, but still
<faheem> that must be a lot of patients
<shka_> so as you would imagine i love me some destructive operations
<shka_> and sparse columns
<faheem> shka_: Does it do slicing too?
<faheem> That's pretty basic.
<shka_> well, you can slice columns subset if you want to, you can filter rows as well
<makomo> faheem: regarding duplication of work :) https://fare.livejournal.com/169346.html
<faheem> makomo: Yes, i read that.
<faheem> shka_: ok
<faheem> It's definitely a real problem with CL. A dozen libraries for the same thing. None of them usable.
<faheem> Hurray.
<shka_> well, that's how it is
<shka_> as I said, nothing really cut it for me so i rolled my own
<faheem> shka_: Do you have a mailing list or something? Can you shoot me an email when you project is on QL?
<shka_> but if you are willing to try it, i will have more input to consider the future development
<faheem> Or I could test it earlier, I suppose.
<faheem> And perhaps makomo would test it too.
<faheem> shka_: Sure, I could try it. Is it usable now, then?
<makomo> maybe i'll give it a go, but i really wanted the ability to do joins
<faheem> makomo: Would it be hard to add?
<shka_> makomo: sorry, i will be working on it in the future
<faheem> shka_: You mean joins?
<shka_> yeah, it is on my todo list
<makomo> faheem: i'm not sure, maybe?. i'm not familiar with the code so i have no idea. :)
<faheem> BTW, where are you guys? Bombay, India, here.
<makomo> shka_: no problem :)
<makomo> it's not your fault anyway :D
random-nick has joined #lisp
<faheem> Data frames aren't actually complicated, as things go.
<faheem> Of course, you have to take the time.
<shka_> faheem: if you have enough of wiggle space to be inefficient
<shka_> anyway, here is the frames library: https://github.com/sirherrbatka/cl-data-frames but you will need also this (which is way to big) https://github.com/sirherrbatka/cl-data-structures and this one (which is pretty small) https://github.com/sirherrbatka/lense
<shka_> dependencies
<shka_> lense will probably be soon in the QL
<faheem> shka_: ok
<shka_> cl-data-structures is kinda a mess because it has some stuff like statistical estimators that don't have any business being in there
<makomo> yeah, i saw the standard-deviation thing :)
<faheem> shka_: It's quite large.
<faheem> Did you write the whole thing yourself?
<shka_> i will probably have to modularize it
<shka_> faheem: yeah
<shka_> it got out of hand
<faheem> shka_: I see you forked it from something else.
<faheem> Which is 55 commits.
<shka_> not really
<shka_> long story, but this is pretty much everything written by me
<faheem> shka_: So not a fork, really?
<shka_> not really a fork
<faheem> Again, where are you guys located? Not that it really matters.
<shka_> me? I am from Poland.
<faheem> shka_: Ok.
<faheem> makomo: How about you?
<shka_> anyway, i would be thrilled if you guys want to try my stuff out and maybe help me a little
<faheem> shka_: I take it you're using this for contract work, or something?
<faheem> Judging by the patient data thing.
<faheem> shka_: Sure, I could give it a whirl. But my CL is beginnerish and rusty.
<shka_> data-frames work although are rough around the edges, cl-data-structures are genuinely useful as fuck
<faheem> Do you want my email address?
<shka_> nah
<faheem> ok
<shka_> you can write issue on github if you have ANY question
<shka_> i will do my best to answer
<makomo> faheem: Europe :)
<faheem> shka_: Ok, will do. Unfortunately, your library isn't high on Google.
<faheem> Putting it on QL should help with visibility.
<shka_> well, what can i say
<faheem> How many data frame libraries are there already?
<makomo> 4 so far
<shka_> who knows?
<shka_> makomo: sounds about right
<faheem> shka_: It's not something you can control.
<faheem> makomo: On QL?
<faheem> Can you give me a list?
<makomo> not sure if they're on QL
<shka_> i really need to clean up cl-data-structures and modularize it before i put on github
<faheem> makomo: Ok, thank you.
<faheem> shka_: Isn't it already on github? Do you mean QL?
<shka_> i mean QL, sorry
<shka_> anyway, try aggregation functions from cl-data-structures as well
<shka_> they are sweet
<shka_> probably the best thing i ever made with CL
<shka_> and the most useful as well
<faheem> shka_: ok
<faheem> shka_: BTW, in terms of performance and reliability, does CL work well for you?
<faheem> As in, are you able to do real work with it?
<shka_> sure i can
<faheem> Not many people use it for numerical work, I think.
<faheem> shka_: So it doesn't crash a lot, or anything like that?
<faheem> And are you using SBCL, CCL, or something else?
<shka_> SBCL on linux
<faheem> shka_: ok. Debian?
<shka_> it is pretty good, GC is the only weak point i ran into
<shka_> eh, maybe?
<shka_> i run this on ubuntu, arch linux and whatever admin decided to put on the server
<faheem> shka_: maybe what? maybe Debian?
<shka_> maybe debian, maybe red hat
<shka_> i don't even care
<faheem> oh
<faheem> So GC is not so great? Too much memory use?
<faheem> Or it doesn't give back fast enough?
<shka_> it works fine, but huge heaps sometimes bug it out
<faheem> shka_: ok
<faheem> Good to know. Thanks.
<shka_> if you need just 8GBs of ram you are fine
<shka_> sometimes, i need a lot more
<faheem> shka_: Oh. That's not much.
<shka_> well, it is not painful enough for me to stop and i seem to be the only person with such problems so maybe it is fine
<faheem> shka_: I doubt you're the only person. Do you file bug reports?
<shka_> heh, i did not actually
<shka_> (don't judge me)
<shka_> faheem: don't let this discourage you from sbcl though
<faheem> shka_: You should.
<faheem> shka_: I've used it before, but not recently.
<faheem> I remember having problems with GC. I did file bug reports, too.
<faheem> At least one, that I remember.
<shka_> i know i should, doing this in a productive way would require a lot of time, and i have way to many things on my hands already
<faheem> For some reason I have https://bugs.launchpad.net/sbcl/+bug/1446962 in my browser.
<faheem> Not sure where I got the link from.
<faheem> shka_: I understand.
<faheem> shka_: Well, sleep time. Nice talking to you.
<shka_> faheem: rest well
<shka_> faheem: nope, i like some aspects of R though
<faheem> ok
<shka_> unlike the abominations that pandas is
<slyrus_> is cffi supposed to find things in /usr/lib/x86_64-linux-gnu ?
Josh_2 has joined #lisp
<slyrus_> the real problem being that I can't load sdl2-ttf
v88m has joined #lisp
dacoda has joined #lisp
<PuercoPop> shka_: Have you seen https://github.com/fiddlerwoaroof/data-lens? How does it compare to lense?
<shka_> PuercoPop: it is not the same stuff, all i really wanted is to have direct equivalent of racket style lenses, this goes for full blown DSL build with monads
<shka_> which i don't need, because cl-data-structures ranges and aggregation functions are way more useful
<shka_> (for me)
<shka_> so obviously, my lens is simply a first class accessor
<shka_> and here is something way more complex
<shka_> well, good night everyone
shka_ has quit [Ping timeout: 244 seconds]
notzmv has quit [Ping timeout: 248 seconds]
dale has joined #lisp
vhost- has quit [Ping timeout: 245 seconds]
saravia_ has joined #lisp
saravia has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 248 seconds]
dacoda has quit [Ping timeout: 264 seconds]
<pfdietz> faheem: I am interested in improved curation of the Quicklisp ecosystem. But time is finite.
MichaelRaskin has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
martylake has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
donotturnoff has quit [Ping timeout: 244 seconds]
vutral has joined #lisp
hhdave has joined #lisp
vlatkoB has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
Bike has quit [Quit: Bike]
notzmv has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
dale has joined #lisp
zhlyg has quit [Ping timeout: 268 seconds]
hhdave has quit [Quit: hhdave]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
sjl has quit [Quit: WeeChat 2.3-dev]
sjl has joined #lisp
hhdave has joined #lisp
hhdave has quit [Client Quit]
lawfullazy has joined #lisp
saravia_ has quit [Remote host closed the connection]
Inline has joined #lisp
<makomo> huh interesting. if there's a bound global dynamic variable *VAR*, doing (defvar *var* (error "hello")) makes it unbound (using SBCL). is this expected?
random-nick has quit [Read error: Connection reset by peer]
linli has joined #lisp
<zulu-inuoe> makomo: I'm not seeing that behaviour. Are you sure the variable wasn't already unbound?
Bike has joined #lisp
<makomo> zulu-inuoe: lemme try again in a fresh image
linli has quit [Ping timeout: 244 seconds]
rumbler31 has joined #lisp
<makomo> zulu-inuoe: do you get an error when executing the form?
<zulu-inuoe> makomo: Not on the second defvar, since the variable was already created
<makomo> right
<makomo> must have been a package mixup then
lucasb has quit [Quit: Connection closed for inactivity]
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
<makomo> zulu-inuoe: lol it was swank, gah.. there's a special case just for DEFPARAMETER when you're using slime's SLIME-EVAL-DEFUN
<zulu-inuoe> makomo: Oh? Really? What does it do?
<makomo> it instead calls SLIME-RE-EVALUATE-DEFVAR which then calls SWANK:RE-EVALUATE-DEFVAR on the CL side which uses MAKUNBOUND
<equwal> Good morning
<makomo> only after unbinding it does it evaluate the form, which then errors, leaving the symbol unbound
<zulu-inuoe> @_@. It does that for `defvar`?
<makomo> yeah, just defvar :')
<zulu-inuoe> Oh wow.
<makomo> so to conclude, it didn't have to do with packages after all
<makomo> (string-match "^(defvar " form)
<makomo> slime.el:4081
<makomo> or just C-h f slime-eval-defun
<makomo> erm, s/DEFPARAMETER/DEFVAR/ above
<zulu-inuoe> Yeeep. Still exists in sly, too. Interesting. But I guess I've never called it (I always C-c C-c or C-c C-e)
<makomo> heh, i frequently do slime-eval-defun (keybinding ,ef in spacemacs)
dale has quit [Quit: My computer has gone to sleep]
rumbler31 has quit [Remote host closed the connection]
dale has joined #lisp
Josh_2 has quit [Remote host closed the connection]
Josh_2 has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
Josh_2 has quit [Ping timeout: 258 seconds]
buffergn0me has quit [Ping timeout: 250 seconds]
stacksmith has joined #lisp
libre-man has quit [Ping timeout: 258 seconds]
libre-man has joined #lisp
dialectic has joined #lisp
makomo has quit [Quit: WeeChat 2.4]
wxie has joined #lisp
akoana has joined #lisp
elderK has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
rumbler31 has joined #lisp
wxie has quit [Quit: wxie]
rumbler31 has quit [Ping timeout: 245 seconds]
smazga has quit [Quit: leaving]
cantstanya has quit [Remote host closed the connection]
cantstanya has joined #lisp
zotan has quit [Ping timeout: 272 seconds]