jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language<http://cliki.net/> logs:<https://irclog.whitequark.org/lisp,http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.5, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
<mrblack> but anyway, it won't hurt me to know some Clisp, right?
<oni-on-ion> your CL should run in clisp and sbcl
<mrblack> cool
<aeth> According to the HyperSpec syntax specification of LOOP, ':for foo type' has to be ':for foo :of-type bar-type' unless type is 'fixnum | float | t | nil' and I was saying ':for foo double-float' instead of ':for foo :of-type double-float'. I (and SBCL, ECL, and CCL) interpreted 'float' as allowing the various float subtypes (including double-float) but CLISP interprets it strictly and only wants fixnum, float, t, or nil, with no subtype of
<aeth> , with no subtype of float (or fixnum?)
<oni-on-ion> all the CL compilers do all the CL like all the C compilers do the C, we can get into implementation-specific features later
<oni-on-ion> its fun to get all the knowledge and information but sometimes we just want to code and get stuff done and play with computers =)
<aeth> Put concretely, SBCL, ECL, and CCL accept this, but CLISP does not: (loop :for foo double-float := 0d0 :then (1+ foo) :until (> foo 42d0) :finally (return foo))
<aeth> (Also single-float, short-float, and long-float)
<Bike> skipping of-type is for simonists
<Bike> i think clisp is also stricter about clause ordering, or maybe the other way around, or maybe it's been fixed
<aeth> Bike: I wanted to keep more :FORs as one-liners but I didn't want to break the line length limit of 100
<oni-on-ion> }|"
<aeth> Bike: as it is I only had to make 2 as two-liners iirc
dale has quit [Quit: dale]
<aeth> oh, oops, I was using 80, not 100, and 1 technically went over it by 1 character anyway.
<mrblack> what programs you use to code lisp? text editor, IDE?...
<Bike> mostly emacs
<Bike> with the slime edity developy thing
<djeis[m]> emacs, with sly for CL.
<aeth> The majority use SLIME with GNU Emacs. The minority use Sly with GNU Emacs. Notice the pattern: GNU Emacs.
<mrblack> yep
<mrblack> do you use paredit?
<aeth> I suspect it's the same case, where the majority use paredit, but the minority use something roughly equivalent.
<aeth> note that if you don't (setq paredit-space-for-delimiter-predicates '((lambda (endp delimiter) nil))) then some reader macros break with paredit iirc
<mrblack> I usually don't do start something looking for lots of tools, but I have a serious case of not being able to parse parenthesis, so I decided to get all the help I can right from the start
<aeth> (well, it doesn't break them, it just breaks their style, by adding a space afterward)
Kundry_Wag has joined #lisp
nowhere_man has quit [Ping timeout: 260 seconds]
<oni-on-ion> :{ let lisp parse for you
<djeis[m]> I use a whole bunch of stuff mixed together, some of it my own design lol
<oni-on-ion> man makes his own workshop -9
<oni-on-ion> =)**
<oni-on-ion> we arent setting up pre-fab garages and studios, we make our own, based on our workflow
shifty has joined #lisp
frodef has quit [Ping timeout: 252 seconds]
warweasle has joined #lisp
Nephromancer has quit [Quit: Connection closed for inactivity]
moei has quit [Ping timeout: 252 seconds]
varjag has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Oladon has quit [Quit: Leaving.]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
cl-arthur has quit [Quit: Lost terminal]
varjag has joined #lisp
pjb has quit [Read error: No route to host]
varjag has quit [Ping timeout: 244 seconds]
warweasle has joined #lisp
Achylles has quit [Ping timeout: 240 seconds]
bmansurov has left #lisp ["Later"]
phao has joined #lisp
hydan has quit [Quit: Connection closed for inactivity]
robotoad has quit [Quit: robotoad]
shifty has quit [Ping timeout: 260 seconds]
skeuomorf has joined #lisp
robotoad has joined #lisp
anewuser has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
moei has joined #lisp
Oladon has joined #lisp
eminhi has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
astronavt has quit [Ping timeout: 268 seconds]
rnmhdn has joined #lisp
rtypo has quit [Ping timeout: 252 seconds]
Pixel_Outlaw has joined #lisp
Roy_Fokker has quit [Read error: Connection reset by peer]
jkordani has quit [Read error: Connection reset by peer]
lopan5 has joined #lisp
phao has quit [Quit: Leaving]
dddddd has quit [Remote host closed the connection]
jinkies has joined #lisp
<MetaYan> mrblack: A nice Lisp environment based on Emacs and SBCL: https://portacle.github.io
<ober> nice for when you're on windows
<MetaYan> mrblack: There is also #clschool and #clnoobs
lopan5 has left #lisp [#lisp]
trittweiler has quit [Ping timeout: 252 seconds]
trittweiler has joined #lisp
<MetaYan> ober: Good to know. I use it on Mac - constantly.
<ober> if you don't use the emacs normally, I could see the value
<mrblack> MetaYan, oh, I know about Portacle, but I'm an Emacs user already, I think there's no turning back :P
<mrblack> I guess a well configured Emacs will have everything there's in Portacle, right?
<ober> typically.
<ober> one rarely just kisses emacs, and then breaks up with it.
<MetaYan> Yes, Portacle is Emacs, SBCL, Quicklisp put together in a nice ease-to install package.
<MetaYan> easy-to-install
<ober> and on some platforms it's a god send. where setting those up can be quite a pain
jack_rabbit has quit [Ping timeout: 252 seconds]
FreeBirdLjj has joined #lisp
jeosol has quit [Ping timeout: 256 seconds]
<adlai> portmanteau of porthole barnacle?
<mrblack> oh... should I install quicklisp?
<no-defun-allowed> yes
<MetaYan> mrblack: Highly recommended
<mrblack> do I have to configure it on Emacs or something?
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<no-defun-allowed> using quicklisp you should install slime then use that slime to load quicklisp so kinda
regreg_ has joined #lisp
<mrblack> okay
<mrblack> I already set up slime with SBLC on Emacs
<mrblack> I used apt on Debian... maybe it's plug-n-play?
<ober> (ql:quickload :quicklisp-slime-helper) then be sure to source in ~/quicklisp/slime-helper.el in emacs
<mrblack> ober, is this command to run on SBCL?
<mrblack> ober, cause it is throwing an error
<no-defun-allowed> did you load quicklisp first?
<mrblack> nope... I don't know how to load. I instaled via apt and "whereis" it won't tell me where it is. May I should not use the apt version?
<Bike> quicklisp isn't in debian
<mrblack> I thought it was this one: cl-quicklisp
<Bike> huh
<Bike> well, honestly most people around here at least avoid the debian packages
<mrblack> really? good to know
<Bike> a few years ago they were always super out of date and finicky. dunno about now.
<no-defun-allowed> debian is usually out of data
<ober> yeah, unless you want 100% compat with PCL common lisp. :P
<no-defun-allowed> *date
<mrblack> how's the command to load quicklisp from SBCL?
<Bike> it's just (load "/path/to/quicklisp/setup.lisp")
<mrblack> awesome, thanks
<Bike> i couldn't tell you where debian put setup.lisp, though
<mrblack> it's in the same folder
<mrblack> its working
<mrblack> should I load Quicklisp every time I start Lisp?
<Bike> yeah. you can do (ql:add-to-init-file) and it'll put it in sbcl's init file so you don't have to do it yourself
<mrblack> great
<ober> yeah, most of us have become use to the curl/ql/sbcl/emacs loop
<ober> learn that slime. there are a load of features that are use by many, but not obvious to new folks.
<mrblack> I think I finished the main configurations
Oladon has quit [Quit: Leaving.]
trittweiler has quit [Ping timeout: 244 seconds]
<mrblack> wow... the slime repl well configure is very very nice
rnmhdn has quit [Ping timeout: 272 seconds]
anewuser has quit [Quit: anewuser]
<adlai> at which point mrblack discovers that there's a special circle of hell wherein slime addicts are forced to program lisp verbally, and each day a different one has to act as stenographer - using a mechanical typewriter
<ober> gateway drug.
<oni-on-ion> agh/ugh
[X-Scale] has joined #lisp
* adlai occupies the fixed point in that circle where you have to untangle the key jams
X-Scale has quit [Ping timeout: 240 seconds]
[X-Scale] is now known as X-Scale
<oni-on-ion> dracula
<mrblack> adlai, :D
<mrblack> I was considering using sbcl in the command line. I WAS A FOOL.
<adlai> supposedly clisp is quite a useful standalone
<ober> yeah, command line for only exists because they have not gotten around to removing it.
razzy has quit [Ping timeout: 260 seconds]
<mrblack> very very nice
<mrblack> why would someone use anything other than Emacs/Portacle for lisp?
<djeis[m]> So they don’t need to learn a new editor at the same time as learning a new programming language.
<no-defun-allowed> cause climacs is a thing
<mrblack> djeis[m], makes sense
<djeis[m]> Don’t get me wrong- love emacs. Do think it’ll probably stay the best lisp env going forward. But that doesn’t mean everyone should be expected to take the time to learn it. Better if at least a good subset of the CL-specific functionality were in more editors.
<mrblack> I agree
<djeis[m]> Now if only I had infinite time...
<ober> and sbcl is not used by everyone
<mrblack> Emacs is awesome, but I'd never recommend it to a "normal" person :P
<mrblack> one must go to Emacs by itself,
<mrblack> one must hear the calling
<mrblack> It is written
<ober> gateway to lisp
<MetaYan> SBCL command line can become quite nice with sbcl-readline - just git clone https://github.com/jini-zh/sbcl-readline in quicklisp/local-projects , (ql:register-local-projects) once and then (ql:quickload :sbcl-readline)
jeosol has joined #lisp
<mrblack> is it possible to prevent Slime from writing those messages when it starts?
<MetaYan> What messages?
Pixel_Outlaw has quit [Remote host closed the connection]
beach has joined #lisp
<MetaYan> If you mean the animation, you can put (setq slime-startup-animation nil) in .emacs
<beach> Good morning everyone!
<MetaYan> Good norning!
<MetaYan> /morning/
<jeosol> Good morning beach
definite has joined #lisp
<no-defun-allowed> morning beach
definite has quit [Client Quit]
ntalin has joined #lisp
ntalin has quit [Client Quit]
ntalin has joined #lisp
ntalin is now known as definite
definite has left #lisp [#lisp]
<LdBeth> GG
<mrblack> MetaYan, no.. I think it's loading stuff. But it goes away quick so I can't paste.
asarch has joined #lisp
<adlai> mrblack: messages to which buffer?
<mrblack> adlai, slime-repl sbcl
<MetaYan> mrblack: Maybe check the *inferior-lisp* buffer?
<adlai> mrblack: eh it shouldn't be sending any messages there during startup. you're probably noticing the inferior lisp buffer where slime talks to sbcl, or maybe the emacs message buffer
<mrblack> yeah... I don't know how to solve this. It's of no consequence, really. Just a little OCD on my part.
cmatei has quit [Remote host closed the connection]
jack_rabbit has joined #lisp
skeuomorf has quit [Ping timeout: 244 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
dented42 has joined #lisp
dented42 has quit [Client Quit]
Bike has quit [Quit: Lost terminal]
rnmhdn has joined #lisp
rnmhdn has quit [Ping timeout: 272 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
ggole has joined #lisp
regreg_ has quit [Ping timeout: 245 seconds]
regreg_ has joined #lisp
<phoe> Morniiing
rnmhdn has joined #lisp
doubledup has joined #lisp
regreg_ has quit [Quit: Konversation terminated!]
Kevslinger has quit [Quit: Connection closed for inactivity]
eminhi has quit [Quit: leaving]
rnmhdn has quit [Ping timeout: 268 seconds]
<beach> Hello phoe.
beach has quit [Disconnected by services]
<no-defun-allowed> hi phoe
beach has joined #lisp
<no-defun-allowed> welcome back beach
<beach> Thanks.
mrblack has quit [Ping timeout: 252 seconds]
jinkies has quit [Ping timeout: 260 seconds]
wiselord has quit [Ping timeout: 272 seconds]
mrblack has joined #lisp
<phoe> Hey hi beach no-defun-allowed
<no-defun-allowed> o/
angavrilov has joined #lisp
logicmoo is now known as dmiles
dented42 has joined #lisp
Guest5800_ has quit [Quit: Connection closed for inactivity]
vlatkoB has joined #lisp
heisig has joined #lisp
rippa has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
quipa has joined #lisp
quipa has quit [Remote host closed the connection]
<phoe> Are there any papers on implementing a condition system in Lisp that doesn't have a condition system?
<phoe> I'm interested in the basics of implementing handler-bind, for instance.
wiselord has joined #lisp
<beach> As I recall, the condition system can be implemented entirely in a portable way. But I haven't thought about it for some time.
<adlai> phoe: http://citeseerx.ist.psu.edu/viewdoc/summary?doi= (warning: the helpful answer would've been "no", but go on, click the link :)
<phoe> beach: AFAIK, handlers are just functions, and handler-bind simply conses another handler on top of a dynamic variable. handler-case adds a THROW to achieve non-local exit.
<beach> Sounds right.
<phoe> SIGNAL searches the handler list for matching ones and invokes them; ERROR is signal on top of invoke-debugger.
<phoe> And there are restarts on top of this.
<adlai> clhs error
<phoe> like, literally, (defun error (e) (signal e) (invoke-debugger e))
<phoe> (except ERROR also accepts format controls)
* adlai was always under the impression that this behavior could be implemented as a handler of last resort
<phoe> a handler of last resort would always trigger even in case of SIGNAL
robotoad has quit [Quit: robotoad]
<adlai> not if it punts nonerrors
<phoe> (signal (make-condition 'condition)) doesn't usually invoke a debugger; (error (make-condition 'condition)) always does unless the condition is handled
asarch has quit [Quit: Leaving]
<phoe> same with (signal (make-condition 'error)) - no debugger here
* adlai stands corrected
<phoe> signaling a condition means "hey, I got this state in the program, you could run some code now if you'd like to"; invoking a debugger on a condition means "oh no, boy, you're *NOT* getting away with this, the program execution is halted"
<phoe> which means, signal + invoke-debugger is equivalent to "hey, either you handle this thing, or your program stops in an unpleasant way"
<phoe> which is exactly what #'ERROR does
<phoe> handlers are just simple callbacks that you are able to specify dynamically; they are pretty useful for non-local exits, though, which is what they are often used for
robotoad has joined #lisp
<phoe> see (let ((x 2)) (handler-bind ((condition (lambda (e) (declare (ignore e)) (incf x 2)))) (print x) (signal 'condition) (print x)))
<phoe> that's a silly and simple example
<phoe> you can substitute anything you want for the lambda body, and use the condition object for passing arguments to that callback.
definite has joined #lisp
beach has quit [Ping timeout: 240 seconds]
beach has joined #lisp
definite has left #lisp ["ERC (IRC client for Emacs 26.1)"]
frodef has joined #lisp
dddddd has joined #lisp
moei has quit [Ping timeout: 252 seconds]
<oni-on-ion> clhs horror
<specbot> Couldn't find anything for horror.
nanoz has joined #lisp
quipa has joined #lisp
arbv has quit [Ping timeout: 252 seconds]
<makomo> morning
<oni-on-ion> hillo
SaganMan has joined #lisp
marvin2 has quit [Ping timeout: 245 seconds]
runejuhl has quit [Quit: WeeChat 2.1]
robotoad has quit [Quit: robotoad]
<beach> Hello makomo.
<makomo> hello
<adlai> clhs extreme-prejudice
<specbot> Couldn't find anything for extreme-prejudice.
* adlai gives up looking for the halt state precursor state, it appears to be the case that contrary to popular belief, common lisp actually is turing-complete.
robotoad has joined #lisp
<oni-on-ion> what
<aeth> Not only is Common Lisp turing complete, it has like 10 turing complete surprising areas (well, would be surprising in other languages).
<russellw> aeth, oh, what are they?
<aeth> #.(loop) ; for when you want the reader to infinite-loop
<aeth> (eval-when (:compile-toplevel) (loop)) ; for when you want to the compiler to infinte loop
runejuhl has joined #lisp
<Shinmera> infinite loops have nothing to do with turing completeness.
doubledup has quit [Quit: Leaving]
<russellw> It's an example. You see his point: the reader and compiler can both be instructed to run general code, which is an interesting and unusual feature. Most languages don't have that
<aeth> (defun foo (&rest rest) (declare (ignore rest)) (loop)) (deftype foo () `(satisfies foo)) ; for when you want the type system to infinite loop
<aeth> etc
<russellw> cool!
<aeth> Shinmera: yeah, but usually the stated reason why you can't do these sorts of things in $language is to avoid infinite looping
<aeth> Technically, I should be doing calls to my Brainfuck implementation instead, since that's a good proof of Turing completeness, but that's actually less fun.
mrblack has quit [Remote host closed the connection]
<russellw> :)
<oni-on-ion> heh type system
<Shinmera> russellw: if you can evaluate arbitrary forms the turing comleteness isn't surprising, it's obvious.
<russellw> Shinmera, exactly. So it suffices to pick an example that demonstrates you can evaluate arbitrary forms in those places
mrblack has joined #lisp
<Shinmera> russellw: he specifically talked about surprising areas though.
<Shinmera> but whatever
<aeth> Shinmera: Usually languages that offer compile time evaluation offer a restricted subset of the language or some other, restricted language.
<aeth> Because they don't want turing completeness because they don't want things like infinite loops.
<aeth> It's surprising to be able to evaluate arbitrary forms in certain areas.
<oni-on-ion> reader, compiler, type system; what other areas?
<aeth> macro expansion, but that's kind of cheating because most languages don't even have that
<russellw> C does, and does not allow evaluating arbitrary code in it, so I think that's a fair example
<aeth> eval-when also can make code run at ":load-toplevel"
runejuhl has quit [Quit: WeeChat 2.1]
<oni-on-ion> CL typesystem could be documented more for justice
<aeth> I'm trying to think of where else... probably something to do with CLOS or conditions
<Shinmera> russellw: C does not have macros, it has reader macros.
<oni-on-ion> the human brain o_o
<Shinmera> or they're closer to that concept, anyway
<aeth> oh and I wouldn't count reader macros on my list because #. pretty much covered it
mrblack_ has joined #lisp
mrblack has quit [Read error: Connection reset by peer]
moei has joined #lisp
moei has quit [Ping timeout: 240 seconds]
quipa_ has joined #lisp
quipa has quit [Ping timeout: 244 seconds]
runejuhl has joined #lisp
robotoad has quit [Quit: robotoad]
beach has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
random-nick has joined #lisp
beach has joined #lisp
random-nick has quit [Remote host closed the connection]
<phoe> Style question: (in-package :foo) or (in-package #:foo)?
<beach> (cl:in-package #:foo)
<Shinmera> phoe: as long as you're consistent it really doesn't matter anymore
random-nick has joined #lisp
<jackdaniel> bueuty of confusion, I've spent last hour writing a comment which strives to spare that confusion future generations
<jackdaniel> beauty*
<phoe> jackdaniel: show me
<jackdaniel> comment is relatively short. I was just trying to first grok why it behaves the way I observe it
<jackdaniel> (basically: x-origin/y-origin are relative to pen position in glyph coordinate system, which is the first-quadrant -- Y grow upwards), that's why we negate left distance and not top one
<jackdaniel> )
<phoe> yes, in the first quadrant, X goes leftwards to negative infinity
<phoe> so it's logical that the values there are negative
<jackdaniel> erm, no
<jackdaniel> first quadrant is what you know from math
<jackdaniel> when you draw charts
<jackdaniel> bottom-left is origin and grows upward-right
ggole has quit [Remote host closed the connection]
<jackdaniel> what is often in computer graphics is second quadrant
<phoe> oh wait a second, I confused the second with the fourth
<jackdaniel> bleh, Computer graphics are IV quadrant, sorry
<phoe> ...wait, did I not?
<phoe> I did not - yes, I understand what you mean, computer graphics often use fourth quadrant
<jackdaniel> either way X grows to the right, not towards infinity in both :)
<jackdaniel> (minus infinity)
<jackdaniel> so, now time for kerning in McCLIM
<phoe> good luck!
<jackdaniel> that will be the easy part (luckily)
SaganMan has quit [Quit: WeeChat 1.6]
<phoe> Where exactly does the standard specify that (setf (find-class 'condition-type) nil) is the way to remove a condition type from the global environment?
<Shinmera> It doesn't and it isn't.
<Shinmera> In practice it is because usually conditions are classes, but there's no promise about that
<Shinmera> so even find-class on a condition type is implementation specific
varjag has joined #lisp
<phoe> So, I assume, there is no portable way to remove a condition from the global environment?
<Shinmera> No.
<Shinmera> CL has real weird edge cases where some definition information is available only for certain kinds of definitions.
<Shinmera> well, information and operations.
<Shinmera> Reminds me, I should add a protocoll to Definitions to update or remove definitions.
<Shinmera> *protocol, even
<phoe> Well then, I'll lead the implementation-defined behavior and assume that condition classes exist, no matter what they are.
<beach> I detect an opportunity to specify that conditions are classes in WSCL.
<beach> Is there any implementation that does not do it that way?
orivej has quit [Quit: No Ping reply in 180 seconds.]
<no-defun-allowed> Is there anything describing why people shouldn't use the Unix "philosophy"?
<beach> What is the Unix "pholosophy"?
<no-defun-allowed> "worse is better" is the first accurate name I found.
<beach> The Unix-haters handbook is a good start.
<phoe> beach: I haven't found one.
<phoe> no-defun-allowed: http://simson.net/ref/ugh.pdf
<jackdaniel> no-defun-allowed: you may want to read http://www.dreamsongs.com/WIB.html
<phoe> beach: I know that SBCL, CCL, ECL, ABCL use condition classes. Only SBCL out of these four doesn't have conditions as standard-objects.
<jackdaniel> commonly referred as "worse is better"
graphene has quit [Remote host closed the connection]
<beach> phoe: Good to know, thanks!
<no-defun-allowed> Thankyou.
<phoe> beach: I don't know about other implementations, particularly the commercial ones.
<beach> Right.
graphene has joined #lisp
<phoe> gendl: do you have access to LispWorks and ACL? Could you give us the results of (describe (make-instance 'condition)) on these two platforms?
<beach> Remind me and I'll ask Martin in Genoa.
<phoe> ...wait a second, I'll actually do that myself.
<phoe> LispWorks conditions are standard-objects.
<beach> OK.
<beach> I am a bit surprised though.
scymtym has quit [Ping timeout: 268 seconds]
<beach> I would have expected the existence of a condition-object and condition-class just as there is standard-object and standard-class and also funcallable-standard-object and funcallable-standard-class.
d4ryus1 has joined #lisp
<beach> Well, not condition-object, just condition.
<phoe> So does ACL.
White__Flame has joined #lisp
<phoe> So, effectively, ACL, LW, CCL, ECL, ABCL all use standard-objects for conditions.
<jackdaniel> that's laziness of course
<beach> phoe: Er, hold on a sec...
<phoe> jackdaniel: laziness?
nonlinear has joined #lisp
<beach> phoe: I don't think the fact that CONDITION is a standard class implies that instances of that class are standard objects.
<beach> phoe: I mean, built-in-class is a standard class, and there are certainly instances of built-in-class that are not standard objects.
<phoe> (typep (make-instance 'condition) 'standard-object) ;=> T on both LW and ACL.
<phoe> You're right. I double-checked this.
stux|RC-only has quit [Ping timeout: 240 seconds]
ober has quit [Ping timeout: 240 seconds]
flip214 has quit [Ping timeout: 240 seconds]
Intensity has quit [Ping timeout: 240 seconds]
eagleflo has quit [Ping timeout: 240 seconds]
mgsk has quit [Ping timeout: 240 seconds]
varjag has quit [Ping timeout: 240 seconds]
NB0X-Matt-CA has quit [Ping timeout: 240 seconds]
d4ryus has quit [Ping timeout: 240 seconds]
snits has quit [Ping timeout: 240 seconds]
luis has quit [Ping timeout: 240 seconds]
karstensrage has quit [Ping timeout: 240 seconds]
eschatologist has quit [Ping timeout: 240 seconds]
saturn2 has quit [Ping timeout: 240 seconds]
H4ns has quit [Ping timeout: 240 seconds]
White_Flame has quit [Ping timeout: 240 seconds]
<beach> phoe: OK, that's good.
eschatologist has joined #lisp
<jackdaniel> phoe: making conditions standard objects (given you have clos already) is easy and you have no push from the standard to givem them a separate hierarchy like condition-class
moei has joined #lisp
<phoe> jackdaniel: yes, and I actually enjoy the fact that they obey the instance creation protocol - I have my personal use-case for defining INITIALIZE-INSTANCE :AFTER on conditions which only SBCL doesn't obey.
saturn2 has joined #lisp
<jackdaniel> I'm not saying that such unification is bad thing, only that doing it that way is most likely due to a said laziness
<phoe> yes, I understand that one
<jackdaniel> as of defining initialize-instance :after on condition - it is just not common lisp, so I'd hardly call it a bug
iomonad has quit [Ping timeout: 252 seconds]
<jackdaniel> (when you do that yo udo no better than people who cast pointers in C ;-)
<phoe> jackdaniel: I know, I simply wish I could do that
<phoe> conditions as second-class CLOS objects don't float my boat
White__Flame is now known as White_Flame
orivej has joined #lisp
ggole has joined #lisp
panji has joined #lisp
<phoe> wow! classes are type specifiers
<phoe> (typep 2 (find-class 'integer)) ;=> T
<jackdaniel> you don't need find-class here
<jackdaniel> (defclass foo () ()) (typep (make-instance 'foo) 'foo) ; -> t
<phoe> jackdaniel: I know
iomonad has joined #lisp
<phoe> I knew that (typep 2 'integer) works
<phoe> I didn't know that (typep 2 (find-class 'integer)) works
<phoe> that class objects are valid type specifiers
<beach> clhs 4.2.3
<phoe> "...or defining a class by using defclass or define-condition automatically causes the name of the structure or class to be a new type specifier symbol."
<phoe> woah, the standard just said that define-condition defines classes"
* jackdaniel drops off the amusement train to make a spaghetti \o
<|3b|> if i'm generating all the code at compile time (basically compiling a file that looks like "(foo:generate-all-the-code)"), is there any benefit to generating a defpackage form over generating code for building the packages incrementally?
<phoe> debuggability
<|3b|> you mean i can generate a defpackage to test manually?
<phoe> DEFPACKAGE is much easier to parse by humans in case something goes wrong (and Murphy's law says it most likely will)
<|3b|> humans never see it
<phoe> unless something goes wrong
<|3b|> (foo:generate-all-the-code) is literally the contents of the source file (probably better named and with argument, but still a 1 line macro call)
<phoe> technically, there's absolutely no difference
<phoe> but if I ever were to debug code generated by a machine, I'd prefer a DEFPACKAGE where all package information is stored in one place rather than seeing bits of EXPORTs and IMPORTs thrown all over the place
<|3b|> but i guess users can macroexpand it (and then watch emacs break on the 100+MB of output)
<phoe> ...do you want to feed 100MB of source code into the compiler at once?
<|3b|> well, probably would still be pretty close together, but probably not hard to build a defpackage form
<|3b|> yeah, i already do
<phoe> good lords
<|3b|> just don't want to put it in git (and also not sure about the legality of doing so once i thought about it)
<|3b|> it is package definitions and ffi info for the entire android API
<|3b|> gnerated from a 30MB or so .jar file from the android sdk
<|3b|> so rather than try to figure out the legality of shipping the jar or code derived from it (and deal with 100MB files in git, or making them smaller), i can just say "download the SDK or this file, and put a path to it here"
<phoe> yes, I see
<|3b|> and generate the ffi data into a .fasl directly from the .jar
<|3b|> (.fasl is more reasonable 15mb)
<|3b|> takes ~30sec to compile from file, but hopefully that won't have to happen often. just loading the .fasl is ~1-2sec
<Xof> .slol
<|3b|> also hopefully generating the code won't be much slower than READing it
<|3b|> nah, seems like reasonable time for 100MB of source, and some of that might be my code being slow
panji has quit [Remote host closed the connection]
<|3b|> since it has to process the ffi info while it loads
<|3b|> and if not, loading 4.5k packages from from a single .fasl file isn't really something i'd expect sbcl to worry about optimizing :)
scymtym has joined #lisp
gravicappa has joined #lisp
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
SenasOzys has quit [Remote host closed the connection]
nowhere_man has joined #lisp
SenasOzys has joined #lisp
Nephromancer has joined #lisp
SaganMan has joined #lisp
lavaflow has quit [Ping timeout: 252 seconds]
makomo has quit [Quit: WeeChat 2.2]
Bike has joined #lisp
<phoe> beach: if you want to note one more interesting trait of modern implementations, it seems that all of them allow to create condition instances via MAKE-INSTANCE.
<phoe> (princ (make-instance 'simple-condition :format-control "foo ~A" :format-arguments '("bar"))) prints "foo bar"
<phoe> Tested on SBCL, CCL, ABCL, LW, ACL; about to test on ECL.
<phoe> Tested on ECL as well.
<phoe> And using MAKE-INSTANCE instead of MAKE-CONDITION allows INITIALIZE-INSTANCE :AFTER to fire, which works around my issue.
<phoe> So, if I refrain from using MAKE-CONDITION, I can actually make conditions obey the instance creation protocol on SBCL.
<phoe> Undefined behavior, here I come!
<oni-on-ion> where CL shines
<phoe> When it comes to UB, Lisp still doesn't shine as hard as some other languages
<oni-on-ion> but those have only one or zero implementatois
<phoe> not really - C has surprisingly many implementations that disagree a real lot on what UB means
<phoe> compared to that, Lisp implementations are surprisingly converging
<oni-on-ion> hm idk C impls agree on a lot of things also
<oni-on-ion> never ever been an issue
* phoe takes this to #lispcafe
moei has quit [Ping timeout: 252 seconds]
warweasle has joined #lisp
* |3b| tries to test the "generate 100MB of code" function, crashes slime connection :/
<|3b|> at least i can just reconnect
<|3b|> (and clear *inferior-lisp* once in a while, since it is still printing out there)
<phoe> may your heap take the beating
<|3b|> turns out i actually need 2 forms in the actual source though (i think), one to make packages and other to build forms using symbols from them
* |3b| built with 20GB heap, so hopefully not a problem
<|3b|> currently using 3GB
<phoe> |3b|: something along the lines of "you can't (progn (defpackage foo) (foo:bar)) because the reader will complain"?
<|3b|> something like that
<|3b|> calling find-symbol myself when generating the progn, but same issue i think
<phoe> you could work around this by using UIOP:SYMBOL-CALL everywhere you need a funcall, which will decrease readability but make this thing work
<|3b|> or just split into 2 forms :)
<phoe> yep, that
<phoe> it would be much better I guess
<|3b|> don't have to think about it that way (and can time them separately if i care)
makomo has joined #lisp
<gendl> phoe: ACL:
igemnace has joined #lisp
<gendl> lw:
<beach> phoe: I see, yes. Well, in SICL, I can do (make-instance 'symbol :name ... :package ...) :)
<|3b|> seems to be generating packages and ffi defs correctly from casual inspection at least, time to figure out how to hook it into macros
<phoe> gendl: thanks.
<gendl> Good morning everyone,
<phoe> beach: yep. Thought you might want to add this behavior to WSCL.
<beach> phoe: But symbols are not standard objects.
<phoe> Yep, they're built-in.
<|3b|> (complicated by needing 2 macros but wanting to only parse things once)
<beach> Hello gendl.
<gendl> if you were making an in-browser thing for editing CL or CL-based code, what editor would you use?
<gendl> So far I have found:
<phoe> gendl: you mean a web browser, right?
<gendl> yes web browser.
<gendl> I've found http://www.ymacs.org
<gendl> the seconds seems much more actively maintained
<gendl> second*
<gendl> and it has a CL mode - but i just tried their example and simple things like C-y don't work (hopefully can be customized)
<phoe> hm, I forgot how to write CL code without a slime connection to a Lisp image
<|3b|> looks like tab just inserts tabs too :/
<phoe> even indentation won't work too well in that case
<gendl> phoe: yeah, me too. Slime connection to the lisp always has to be there as a "power user" option
<gendl> the web-based editor would be for quick & small edits
orivej has quit [Ping timeout: 252 seconds]
<scymtym> gendl: are you looking for a stand-alone solution or something that talks to a CL backend?
<gendl> scymtym: stand-alone. I'll do my own talking to the CL backend.
<gendl> (for now that will consist of a simple "compile & load" button and not much else)
<|3b|> ymacs seems much nicer for lisp out of the box
<gendl> |3b| I remember seeing ymacs in production use somewhere recently, i forget where though...
* |3b| wonders how hard it would be to have both as options, default to ymacs, with other for people that expect 'normal' editors
<scymtym> gendl: that sounds like "yes" and "no" at the same time :) i'm asking because one option could be the "Monaco" Javascript editor combined with a "Language Server" (that is implementation of Language Server Protocol) for and in CL
<gendl> because if you look at the ymacs project page it hasn't been touched in 3 years... maybe that's misleading somehow.
<gendl> scymtym - thanks, i'l l check that out. I saw something about LSP a while ago. That sounds like a whole new protocol which hopefully can be targeted with some kind of Slime-compatible thing some day (it's not already, is it?)
<phoe> LSP is inferior to Slime.
<scymtym> gendl: it is a new protocol. its advantage is being compatible with basically all editors and IDEs. an implementation does exist for CL to some extend (or two, rather)
<gendl> scymtym: thanks, LSP sounds like it's worth watching.
<gendl> the LSP functionality would be orthogonal to what I'm looking for here though, I think
<scymtym> phoe: in don't think comparing LSP to SLIME make sense
thetemplar has joined #lisp
<gendl> The LSP can apply to any editor, one running locally or (in theory) a web-based one.
<gendl> in my case the CL will be one and the same with the webserver serving the page
<gendl> so I won't need any fancy protocols just to have a "compile/load" action for the code in the browser editor textarea.
<gendl> But down the road, to do fancy feedback, autocompletion, etc, then it will need to get fancy.
<gendl> it would be great if someday we can re-use some or all of our current Slime customizations in an in-browser editor scenario. Maybe LSP will end up being one route to getting some of that.
<gendl> Or if an in-browser editor like Ymacs ever gets real elisp support.
<gendl> anyway my idea for now for casual users is to do most common "editing" things without the need to edit actual text...
regreg has joined #lisp
<gendl> then fall back to editing just little expressions (like for one slot at a time)
<gendl> then fall back to editing actual chunks of code with full definitions,
<gendl> then fall back to "power user" mode which will be basically the traditional Slime/Swank setup, where the user can just run emacs locally and connect with Slime.
<gendl> anyway i was up way too late last night and got woken up too early, rambling half asleep now, i'd better shut up and get some water/coffee/meditation/more sleep.
<gendl> last night i was trying to get a decent menu system working for the web-based thing i'm working on. Then i got carried away trying to make it mimic the MacOS menus. Check it out:
<gendl> that's just a snapshot of HTML/CSS/JS from the application -- the HTML is all coming from the application with cl-who etc.
gravicappa has quit [Ping timeout: 240 seconds]
roshanavand has joined #lisp
<gendl> sorry, that's probably off-topic since there's no visible Lisp involved at this point. I'll bring it up again when there's a live demo to check out.
varjag has joined #lisp
<gendl> |3b|: yeah, ymacs at least support C-k , C-y out of the box.
<gendl> but I have to get outside myself for a minute and realize this is for casual users, only some of whom will every have heard of or touched emacs
regreg has quit [Remote host closed the connection]
<gendl> |3b|: I think your idea of giving an option will be the way to go. At least an option of emacs-mode or "normal" mode -- because we do want to attract brand totally new users (people who've never heard of emacs), but there inevitably be some users (at least myself) who will always need/want/expect some level of emacs compatibility because those keystrokes are baked into finger memory...
trittweiler has joined #lisp
<jackdaniel> I like the idea of such neutral editor
Essadon has joined #lisp
lavaflow has joined #lisp
FreeBirdLjj has joined #lisp
<phoe> siiiigh
<gendl> phoe: what?
<phoe> if I wanted to put a constraint that all subclasses of a class must have different symbol names, I could use MOP trickery to achieve that
Roy_Fokker has joined #lisp
<phoe> I mean
<phoe> they must have different names under STRING=
<phoe> so FOO:BAR and QUUX:BAR would collide with each other
<phoe> can't easily do the same with conditions
<jackdaniel> this sounds like something really bad (form the programmer perspective)
<phoe> yep, I'm looking for better ideas than that
<jackdaniel> I don't think you should limit programmer too much of what he can or can't do
<beach> phoe: Why the constraint?
<jackdaniel> note that CL deliberely permits some ugly things if you know what you are doing: slot-value, :: package accessor etc. and that's much in line with how CL programmers often want to feel - unrestrained by arbitrary limitations
<phoe> beach: I'm being silly, don't mind me too much.
<beach> OK.
<jeosol> morning guys, what is the better way to update a variable e.g., via setf and automatically call some function afterwards. Currently, I am calling an update function to achieve this, but would like to just use (setf var-name value) if possible
<phoe> jeosol: this looks like a symbol macro use case
<jackdaniel> maybe with (setf (with-hook var-name) vlaue) ? then you could define (setf with-hook) function which expands to what you like
Achylles has joined #lisp
<jackdaniel> I don't think that having (setf var-name value) execute some post-step would be a good thing (because *reading* it would look like ordinary setf on a symbol, hence without post-step)
<phoe> hm, right
<jeosol> thanks phoe: jackdaniel
SenasOzys has quit [Remote host closed the connection]
<jeosol> I didn't mean the (setf var-name value) does that, just that I would like to have it that way.
<jeosol> if possible, I guess I'll try the options
SenasOzys has joined #lisp
<phoe> beach: does http://metamodular.com/CLOS-MOP/ensure-class-using-class.html load for you? It takes a long while for me
<phoe> jeosol: it gives the idea that you're setting a variable and that's all, nothing else happens
<phoe> if anything, I would find it more readable to have something like (update-my-var newval)
<jeosol> phoe: that's true. not helpful for another user
<gendl> phoe: loads for me right away.
<phoe> it's a function call that isn't a mere SETF call, so it reads like something else is going on there
nowhere_man has quit [Ping timeout: 268 seconds]
<jeosol> phoe: that's the mechanism I use currently, maybe I'll just use that then
<phoe> gendl: oh right, my network had a hiccup.
<gendl> you guys know about this one right: https://clos-mop.hexstreamsoft.com/
<beach> phoe: "load"?
<beach> phoe: What are you doing in order to load it?
<|3b|> what's the best way to share a time-consuming calculation between 2 macros? just eval-when a global? (ideally something that would avoid redoing the calculation when loading from .fasl, but would work when loading the .lisp)
<phoe> beach: nothing, my web browser had a hiccup.
<beach> phoe: ?
<beach> How were you trying to load it?
maximjaffe has joined #lisp
<phoe> Using a web browser, but it hung while loading the website for a minute.
<|3b|> other thing i can think of is doing it in reader (and possibly stored in a symbol macro)
<phoe> gendl: I know about it, yes.
<phoe> |3b|: I have things like (defparameter *foo* #.(compute-stuff)) - but it's a single function call.
<|3b|> yeah, reader + symbol macro seems like easiest to get working the way i want
<beach> gendl: Yes, I believe that was made by Jean-Philippe Paradis.
<|3b|> (not that i actually expect people to load it, so maybe just eval-when :compile would be OK)
quipa_ has quit [Ping timeout: 260 seconds]
* |3b| also doesn't want the calculation result stored in the .fasl
<|3b|> just seems a bit ugly to do things in the reader :)
<phoe> |3b|: oh, mine actually *does* store the result in the fasl
<|3b|> yeah, that's why symbol-macro vs special for this
<|3b|> or symbol-macrolet in hopes it gets GCd
<|3b|> (symbol-macrolet ((a #.(whatever))) (macrolet ((foo () (macroexpand 'a)))))
<|3b|> or however that works, think i need the env parameter too
<Bike> wait, so, you want the calculation result to be usable from the macroexpander, but for it /not/ to be in the fasl?
<|3b|> right
<|3b|> macroexpander makes the stuff that should be in the fasl
* |3b| is generating code based on contents of a separate file
<|3b|> maybe i should make this an asdf extension instead
<gendl> beach: Yes, Jean-philippe seems eager to spread awareness of this clos-mop version he's done. I've taken him to task on twitter regarding his rants, though (maybe shouldn't have opened that can of worms but I felt like somebody had to face him head on). I still acknowledge that he's indeed put real work into something intended to be beneficial for CL people, so I don't mind posting a link to his clos-mop version here occasionally.
<|3b|> any thoughts on how an asdf system that depends on an external file the user needs to acquire (for example by installing an sdk) should work?
<|3b|> or possibly give user option to specify path to sdk if they have it, and DL the file from version control for them if they don't
<jackdaniel> |3b|: I'd go after "defsystem-depends-on" and this file would define this system
<|3b|> file is in android SDK, i doubt they will add asd files for me :)
<|3b|> so i could have something like the debian "we can't distribute this so here's a package that will DL it for you" packages
<phoe> |3b|: sure, there are some systems that do things like that
<phoe> Shinmera's qt-libs for example, that download Qt binaries and unpack them properly as a part of loading the ASDF system
<phoe> you could use them for reference
<|3b|> any thoughts on whether i should just have a system that automatically downloads the version of the file i tested with from version control (~30MB), or if i should also have some way to let them use their own path if they have the SDK already?
<|3b|> and how the latter would work
<phoe> they likely have the android SDK defined somewhere
<|3b|> check env vars you mean?
<jackdaniel> |3b|: adding option to load their own SDK is certainly a good idea
<Shinmera> How it works in qt-libs is that there's a directory in the source tree it downloads things to
<Shinmera> if you want your own versions, just put them there
<jackdaniel> sometimes software compile and works only against certain sdk/ndk version
<jackdaniel> (especially on android)
<Shinmera> In any case, make sure that downloading automatically is allowed by the license and that you only download via ssl.
<|3b|> jackdaniel: yeah, though that probably applies to my thing too :)
<phoe> tell them to define a package called android-sdk-config with a variable named *sdk-path*; if the package exists and the symbol exists and the variable named by that symbol is bound, use that value as the SDK path
<phoe> that would be the long road
<jackdaniel> |3b|: sure, but give them means to try their version :)
Lycurgus has joined #lisp
<|3b|> Shinmera: well, it would be downloaded from google vcs servers, presumably they wouldn't put it there if downloading it wasn't allowed
<jackdaniel> if it fails it will be something what meats their expectations (which are certainly low for android)
<jackdaniel> for instance bionic for years had memset version, which ignored value and always set to 0 ;-)
<Shinmera> |3b|: I'm talking about potential license agreements that the user might have to explicitly sign off on to use the software.
<Lycurgus> "meat" is a typo a native speaker of English wouldn't make, glad to see that confirmed
* |3b| isn't really sure what the license for the specific file is, which is one reason i don't just include it directly
<Lycurgus> s/wouldn't/would be unlikely to/
<|3b|> i /think/ the use that would be made by someone using my code if it downloaded it for them is OK
<jackdaniel> how is my mistake a confirmation?
<jackdaniel> it could be a datapoint at best
<Lycurgus> true, but it's not the first such observation
<Bike> why wouldn't a native english speaker do that
<|3b|> (and i presumably google wouldn't go after things for using just API definitions after the java case, which is all that's left after my code parses it)
<Shinmera> Better question: why is this being discussed, it has nothing to do with Lisp
<Bike> i am undone...
pjb has joined #lisp
<Lycurgus> yeah, you chatted
<Shinmera> |3b|: As phoe pointed out, people generally seem ok with what I do in qt-libs
<jackdaniel> let's continue discussing legal issues with file distribution ;)
<Shinmera> |3b|: So maybe you can take some inspiration from that
<Lycurgus> there was something interesting about scieener lisp wasn't there?
<phoe> yes, its webside died some time ago
razzy has joined #lisp
<Lycurgus> you did that on purpose
<jackdaniel> Lycurgus: I think it used multithreading in its innards for performance
<|3b|> hmm, maybe it isn't allowed :/
<Lycurgus> jackdaniel, ah
<|3b|> at least from the obvious license, which may not apply to the specific files
<beach> gendl: What he did is based on what I did, which is fine.
<beach> gendl: But then he wanted me to push for his version and remove mine. He also wanted me to teach specbot about his version rather than mine.
<Shinmera> |3b|: Things like the android studio do automate downloading that stuff, but they display license agreements first, so if you replicate that you should be good
<|3b|> Shinmera: but that might forbid what i'm trying to do :/
<Shinmera> Ah?
<phoe> what are you trying to do?
<|3b|> (generic "no ... decompile ... etc" clause)
<beach> gendl: I told him that I had no ambition to do any further work with it. It fulfills its purpose fine, so he would have to do that himself.
<|3b|> possibly derivative works part
<Shinmera> |3b|: I see.
<beach> gendl: He did not seem happy with that at all.
<|3b|> but that file might be under AOSP license (apache), or maybe not
<|3b|> which are apache2
* |3b| supposes i'll just say "download it yourself, here's a URL" for now, not like i'm expecting users at the moment :p
cage_ has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<gendl> beach: your position is completely understandable. Jean-phillip’s irrational outbursts are not.
<gendl> Normally I would say leave him alone, but his twitter rants were not helpful
<beach> Yes, I see.
<gendl> His rants are a bit of a wake up
<beach> What were they about?
Pixel_Outlaw has joined #lisp
skeuomorf has joined #lisp
Oladon has joined #lisp
<gendl> wake up call for the CL community to cooperate a bit better, and maybe that has a place to an extent, but personal name calling and blaming was beyond the pale and just shows his breathtaking sense of entitlement to have other magically people do as he wishes.
<beach> Wow.
<Shinmera> He's now calling Xach a sociopath, among other things
<gendl> rants were claiming to “expose” corruption, conspiracies, “mafia” in the CL community.
<beach> How bizarre.
<Shinmera> It is baffling.
<beach> Indeed.
<jeosol> I probably missed this, not been on twitter for a while. When did it happen?
<Shinmera> Been happening for years
<jeosol> Oh I see.
<jeosol> I am not sure I know the guy or have seen those threads. I tend to ignore such things
cl-arthur has joined #lisp
<Shinmera> It's for the best
<gendl> Indeed I think ignoring such things is mostly for the best.
<jeosol> It's the best way to respond to these type of people especially if they have narcissitic tendencies. It just causes stresses for everyone and no one needs that.
<gendl> But on the other hand, totally ignoring him probably feeds his conspiracy theories.
<Shinmera> Does that matter?
<jeosol> gendl: to an extent yes, but the more you respond, the more they get power that their crap is working
<jeosol> taking time to respond is just feeding the madness. if there are happy users, we should just keep moving. There's already too much crap to deal with.
asarch has joined #lisp
<jeosol> These language wars never end. I was in a place in LA couple of weeks, they are a python shop and some guy hinted (read complained) why one lady uses R, and I'm describing workflows i did in CL. One guy asked how I deal with all the parentheses and why use an old language.
<Shinmera> another endless and largely pointless battle
* |3b| notes CL is 6 years older than python
<|3b|> such an old language
<|3b|> ansi CL is 3 years newer than python :p
<jeosol> Shinmera: my point exactly. I just kept on explaining, and not feeding it.
<|3b|> ansi CL is 6 years older than python 2
<phoe> Haskell is six years older than CLtL1
<phoe> I mean
<phoe> Haskell is six years younger than CLtL1
<phoe> and four years older than ANSI CL
<gendl> jeosol: language wars are one thing and can be dealt with somewhat rationally. This infighting and conjuring of conspiracies within CL is another thing entirely, and I agree 99% it deserves to be ignored and users and well-wishers should focus on positives and productive things (which exist everywhere if you have the right eyes and attitude).
<phoe> gendl: ...and even if you don't
<PuercoPop> scymtym: comparing SLIME and LSP makes no sense, but one can compare the wire protocol of swank with the LSP Protocol. The swank one could use a little bit more structure (like not communicate where the cursor is by sending ===> ... <===. LSP Using JSON means they have 'poorer' data types
<jeosol> gendl: I must admit, I never saw of any of the said "person" comments about infighting or conspiracies, just pointing something similar, and my approach is not feed it in general.
<gendl> anyway, as repulsive as this guy’s rants are, they do help me to keep in mind that transparency and communication are so important for any civic minded activities. I’ve been failing in this regard with Common Lisp Foundation -
<gendl> the site is in shambles, financial reports are old, were months overdue for the planned ASDF appreciation fundraiser -
heisig has quit [Ping timeout: 252 seconds]
nonlinear is now known as NB0X-Matt-CA
<gendl> but none of this is due to malice or conspiracies - just lots of competing priorities, lack of organizational skills, some laziness...
<gendl> but I can understand how from
<Shinmera> As usual, Hanlon's razor applies.
<gendl> shinmera: exactly.
<Shinmera> Speaking of improving CL community stuff, I hope I'll get time to tackle some els-web issues soon.
<Shinmera> Mostly the one about sharing information for people between editions
<Shinmera> Will require me to go over all the data again and clean it up, sigh
maximjaffe has quit [Quit: Leaving]
Josh_2 has joined #lisp
heisig has joined #lisp
skeuomorf has quit [Ping timeout: 252 seconds]
<scymtym> PuercoPop: i agree about comparing, if anything, then the wire protocols. one thing i like is that LSP has a specification (even if it is terrible)
<beach> Is the quality of the specification terribly, or that which it specifies?
grobe0ba has quit [Quit: ZNC 1.7.0 - https://znc.in]
kyby64 has joined #lisp
<PuercoPop> scymtym: There is also the NREPL specification from Clojure (sjl has a CL implementation). Which richer data types than JSON
<scymtym> beach: i have issues with both. that said, the /idea/ is good and something that has been long overdue
<beach> OK.
<scymtym> PuercoPop: i think, i looked at that at some point. maybe i should look again. thanks for mentioning it. do you know which editors support it?
grobe0ba has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 252 seconds]
skeuomorf has joined #lisp
gravicappa has joined #lisp
skeuomorf has quit [Read error: Connection reset by peer]
d4ryus1 is now known as d4ryus
heisig has quit [Quit: Leaving]
CEnnis91 has quit [Quit: Connection closed for inactivity]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Achylles has quit [Ping timeout: 252 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
khisanth_ has quit [Ping timeout: 252 seconds]
scymtym has quit [Ping timeout: 240 seconds]
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
lucca has joined #lisp
orivej has joined #lisp
Achylles has joined #lisp
<ealfonso> in cl-json, can I decode to a specific class without using the {"prototype": {"lispClass":..., "lispPackage": ...}} json key mechanism? How can I specify the "lispClass" in lisp?
khisanth_ has joined #lisp
Oladon has quit [Quit: Leaving.]
steiner has joined #lisp
<phoe> ealfonso: lispClass in Lisp?
<phoe> you create an instance of a particular class
<phoe> and that class's name is what becomes lispClass in JSON, AFAIU
<phoe> also I know about https://github.com/gschjetne/json-mop
<ealfonso> looking at their tests here, the way they specify into which class to decode JSON is by modifying the JSON to add the prototype key: https://github.com/hankhero/cl-json/blob/6dfebb9540bfc3cc33582d0c03c9ec27cb913e79/t/testdecoder.lisp but I'm wondering if I can do that without modifying the JSON
Oladon has joined #lisp
robotoad has joined #lisp
jack_rabbit has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
<oni-on-ion> lispClass..
<ealfonso> can a clos object have multiple meta-classes? I'm trying to make a class both json-serializable as well as a db data-acess-object: postmodern:dao-class json-mop:json-serializable-class
<Shinmera> ealfonso: gotta create a new metaclass that inherits from both
<ealfonso> s/clos object/clos class
steiner has quit [Remote host closed the connection]
<Shinmera> note that due to the way slots and such work, more in-depth code might need to be written in order to properly combine the behaviour.
<Shinmera> so the answer is yes, but it likely requires some thought and effort.
<phoe> doesn't seem like much code here
<Shinmera> it defines its slot and I'm assuming so does dao
<Shinmera> so you need to merge slot classes too
<phoe> yes, it also has its slot definitions
jack_rabbit has joined #lisp
<oni-on-ion> oh my
meepdeew has joined #lisp
rumbler31 has joined #lisp
vlatkoB has quit [Remote host closed the connection]
<phoe> the most crazy thing about Lisp is that it allows you to actually merge them
Achylles has quit [Ping timeout: 252 seconds]
jmercouris has joined #lisp
SaganMan has quit [Read error: Connection reset by peer]
random-nick has quit [Read error: Connection reset by peer]
<Younder> Thats is a consequence of CLOS
<jmercouris> Good evening everyone
<Younder> See sonya Keen's book
nowhere_man has joined #lisp
zxcvz has joined #lisp
random-nick has joined #lisp
<ealfonso> phoe for simplicity I tried creating a json-serializable subclass of the dao object, and changing a dao instance to the subclass, but (json-mop:encode obj) => {}. I assume it only considers direct slots
rumbler31 has quit [Remote host closed the connection]
ebzzry_ has quit [Ping timeout: 252 seconds]
<Bike> that's a hell of a bug
<Bike> pretty small program though. seems like you could change the class-direct-slots call in encode, and then most of the actual change would be setting upa json encodable effective slot class
warweasle has quit [Quit: be back later?]
<ealfonso> Bike yeah. or maybe I am lazy and I end up switching back to cl-json, and just dynamically adding the "prototype" key that they require to specify the lisp class to which to encode
<jmercouris> cl-json is a good library, that's my vote
<jmercouris> for whatever it is worth...
<ealfonso> yeah. I find the way to specify the lisp transformation by adding a "prototype" key to the json a bit weird. why not just specify it in lisp itself without requiring changing the json object? maybe it is supported but I couldn't figure it out from the doc
mrblack_ has quit [Remote host closed the connection]
ggole has quit [Quit: ggole]
nanoz has quit [Ping timeout: 244 seconds]
orivej has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
nos has joined #lisp
warweasle has joined #lisp
<nos> Hello. I have spent several hours on the assumption that https://github.com/cbaggers/glsl-spec is a plugin which populates ctags usable through cl-neovim. I am starting to suspect that this is not the case but I don't yet understand what the project is for, then, since that is not mentioned anywhere that I have looked. Could someone with more experience please take a look at that project and tell me what it is f
<nos> or, or if it belongs to a class of projects whith better documenttation that I can adapt.
<nos> I should mention that this is my first exposure to the lisp ecosystem.
<Shinmera> it is a translation of the glsl standard libraries into lisp data/code.
<Shinmera> it has nothing to do with ctags or c code.
<Shinmera> Its purpose is to allow lisp systems to understand the standard library functions, and it's used in one part to support a compiler of a CL subset into GLSL code.
<nos> So the GLSL documentation it formalizes isn't accessible from an IDE? - I am looking to learn GLSL, and constantly having to search for definitions is tedious. I don't have to use any particular IDE.
<Shinmera> It is, if the IDE learns to parse the format.
<Shinmera> It is machine readable after all. In lisp all you need to do is load the files. In everyithing else, you're gonna need a parser.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Balooga_ has joined #lisp
thetemplar has quit [Ping timeout: 244 seconds]
<Shinmera> As I understand, the repository also includes the data in json format, which may be easire to handle from other languages
dale has joined #lisp
<nos> I didn't think of that. Perhaps that would be the best strategy for me.
cage_ has quit [Quit: Leaving]
Achylles has joined #lisp
loli is now known as dolores
dolores is now known as Guest45821
quipa has joined #lisp
Guest45821 has left #lisp [#lisp]
<nos> Thank you for your help Shinmera. Have a nice weekend. :)
nos has left #lisp [#lisp]
katyusha has joined #lisp
meepdeew has quit [Remote host closed the connection]
alchem1st has joined #lisp
frodef has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
quipa has quit [Ping timeout: 272 seconds]
lisbeths has joined #lisp
<lisbeths> Does the common lisp hyperspec include hash tables true or false.
<Josh_2> hash-table-p?
lisbeths has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
<Shinmera> The hell was that
<jmercouris> it's a conversation on #lispcafe
<jmercouris> it honestly doesn't make sense
<jmercouris> that's the conversation for context
rumbler31 has joined #lisp
<Shinmera> That's a line of conversation I wouldn't even bother with
<jmercouris> Yes, my latest response is "I'm sorry, I'm done with this conversation"
warweasle has quit [Quit: exit]
gravicappa has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Ping timeout: 252 seconds]
frodef has joined #lisp
quipa has joined #lisp
quipa has quit [Remote host closed the connection]
lucca has quit [Ping timeout: 252 seconds]
<gendl> what is #lispcafe.
<jmercouris> gendl: a channel for off-topic conversation with #lisp users
CEnnis91 has joined #lisp
<Josh_2> or random people talking about big vs small compilers
ealfonso has quit [Ping timeout: 252 seconds]
Balooga_ has quit [Quit: Balooga_]
rtypo has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
dented42 has joined #lisp
kyby64 has left #lisp [#lisp]
asarch has quit [Quit: Leaving]
kjeldahl has quit [Ping timeout: 276 seconds]
Arcaelyx has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
cl-arthur has quit [Quit: Lost terminal]
Balooga_ has joined #lisp
jack_rabbit has quit [Ping timeout: 252 seconds]
robotoad has quit [Quit: robotoad]
varjag has quit [Remote host closed the connection]
varjag has joined #lisp
kjeldahl has joined #lisp
robotoad has joined #lisp
Arcaelyx has quit [Quit: Textual IRC Client: www.textualapp.com]
ealfonso has joined #lisp
<ealfonso> how do I package a non-lisp data file with asdf?
<jmercouris> ealfonso: into a binary? or what do you mean?
<Bike> what do you want to do with it?
<jmercouris> ealfonso: here is an example of someone accessing a data file within their lisp program: https://github.com/fukamachi/quri
<jmercouris> I think they use a system-relative directory or something, I can't remember
<jmercouris> in that sense, you are using ASDF to load a non-lisp file, but I'm not sure exactly what your question is, so I can't give a better answer
<jmercouris> ealfonso: ASDF:SYSTEM-SOURCE-DIRECTORY may be of interest to you
<jmercouris> so that you can locate files relative to the source directory
Josh_2 has quit [Ping timeout: 244 seconds]
<ealfonso> it is to include an xml database changelog file that needs to be passed to liquibase on startup. currently I'm using (UIOP/LISP-BUILD:CURRENT-LISP-FILE-PATHNAME), which works in a repl to locate the file relative to the current file, but not when loading the asdf. yes, I'll give that a try
lavaflow has quit [Read error: Connection reset by peer]
lavaflow has joined #lisp
Kundry_Wag has joined #lisp
alchem1st has quit [Ping timeout: 252 seconds]
Josh_2 has joined #lisp
dale has quit [Quit: dale]
Oladon has quit [Quit: Leaving.]
varjag has quit [Ping timeout: 252 seconds]
pfdietz has joined #lisp
Balooga_ has quit [Quit: Balooga_]
jmercouris has quit [Ping timeout: 252 seconds]
frodef has quit [Ping timeout: 245 seconds]
siraben has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp