<PuercoPop>
saravia: ok, then what is the issue, anaphora seems to load just fine
zmt01 has joined #lisp
<saravia>
mmm when run the program anaphora uses, return this = Error loagind /home/saravia/.config/stumpwm/config: end of file on #<SB-SYS:FD-STREAM for "file /home/saravia/.slime/fasl/2.23/sbcl-1.3.15-linux-x86-64
zmt00 has quit [Ping timeout: 250 seconds]
<PuercoPop>
saravia: can you past your config file? From the error I'm guessing there is an unclosed parenthesis
<PuercoPop>
saravia: don't see anything wrong in that file, it may be in one of the conf files it loads. Btw alexandria comes with when-let which is the 'readable' version of AWHEN.
<saravia>
Error: en of file on #<SB-SYS:FD-STREAM for "file /home/saravia/.slime/fasl/sbcl-1.3.15-linux-x86-64/swank.fasl" {1002DD3FD3}>
<PuercoPop>
saravia: you can always delete the fasl and try to load it again
<defunkydrummer>
how can a FASL get corrupted like that ?! :/
<saravia>
mmm how do that, how reinstall fasl
<defunkydrummer>
saravia when you compile a .lisp file, the output is a "fast load" (.fasl) file
<defunkydrummer>
you can recompile swank by using (asdf:compile-system "swank" :force T)
<defunkydrummer>
this forces recompilation
<z3t0>
hi, what are the recommended framework libraries for creating a gui?
<defunkydrummer>
@zt30 we have a lot of threads on this on Reddit, let me fetch you the latest ones...
<defunkydrummer>
z3t0 does it need to be multi-OS?
<defunkydrummer>
z3t0 do you want to do a regular GUI app, or you are thinking of a game?
<defunkydrummer>
z3t0 do you want to pay ?
<defunkydrummer>
please answer all three questions so we can give you our best customer support
<z3t0>
ideally it would be something free, or at least with an evaluation version so I can determine whether it is a good fit. Multi-OS is a requirement. We are doing a GUI app but do have a quite a bit of graphics rendering. Our current app (web/js) manages to handle this using some wrappers around webgl, so ideally a layer of abstraction on top of opengl would be desired
<z3t0>
I am currently looking into commonqt, it seems like the only mature library (at least from my brief googling)
<defunkydrummer>
thank you for standing by. Our support team is processing your request, please stand by...
<defunkydrummer>
@z3t0 one option can be IUP. IUP is a binding to the IUP library by TecGraf (brazil). This is a cross-platform gui library and has OpenGL bindings as well. The lib is well documented and the IUP common lisp library looks elegant. It's in the making right now, so just hot from the oven
<defunkydrummer>
we have many other options, a very common one is Qt bindings, for which there are plenty of lisp libs like CommonQt. Or the EQL implementation, which is ECL + QT
<defunkydrummer>
take a look at this discussion, 4 days ago
<defunkydrummer>
this topic has been discussed a lot really. z3t0 besides GUI libraries, there are also libs dedicated to OpenGL as well
<defunkydrummer>
i think IUP is peculiar because it's a GUI lib that also includes OpenGL bindings
<defunkydrummer>
haven't tried it yet but the sample code looks elegant and it's a fresh (right now. april 2019) lib so it isn't stale
<defunkydrummer>
the actual C library comes from a university in brazil and has been used for several production software, for engineering stuff AFAIK
rumbler31 has quit [Ping timeout: 258 seconds]
<defunkydrummer>
then there are GTK bindings (see discussion), wxWindows bindings if i recall correctly. Then, for the non-cross-OS you have McClim (only works through an X Server), and several Windows (Win32 API) bindings.
<defunkydrummer>
then if you wanna pay you have CommonGraphics on Allegro CL, and CAPI on LispWorks.
<defunkydrummer>
ah, forgot to mention: another option is LTK which is a binding to Tcl/Tk. Code is elegant, it is thoroughly documented, and "just works", however you need to have Tcl/Tk installed in your machine (or bundle it with your application)
<defunkydrummer>
there's a FLTK binding too; FLTK is minimal. I don't know if it works, on the other hand.
<defunkydrummer>
you'll find more (but not all) libs there
varjag has joined #lisp
<z3t0>
thank you for all the information :)
<z3t0>
I am looking through the different options and am starting to realize its a complicated scenario to evaluate
<z3t0>
from what I can see a lot of the libraries don't have a lot of documentation and/or aren't more than a wrapper around a C api
<z3t0>
the nice thing in commonqt/qtools (from what I grokked on the README) is that it does offer lispy abstractions, which I think is quite valuable
varjag has quit [Ping timeout: 258 seconds]
<defunkydrummer>
@z3t0 thank you for choosing Lisp, satisfied customers since 1958. Eternal salvation, or triple your money back!
<defunkydrummer>
@z3t0 IUP also has good abstractions. LTK too. IUP is well documented IMO since it closely follows the original lib, which is well documented.
<defunkydrummer>
as for Qt, i see lately that some of the frequently used libs use QML, so you mostly will be OK if you learn how to use QML from the Qt website
<z3t0>
defunkydrummer: sorry i was away for a bit, i'll take a look
<defunkydrummer>
@zt30 i've submitted some issues to IUP. Still, it looks good.
<defunkydrummer>
... if i can get the iup-controls asd to load.
<defunkydrummer>
z3t0 i mean.
<z3t0>
one thing, I don't think @nick works when trying to ping someone
<z3t0>
at least on my client it only works when you type z3t0 rather than @z3t0 , not sure if that's just my client or a common thing
<z3t0>
uip looks really neat!
<z3t0>
iup*
<beach>
z3t0: I highly recommend McCLIM. It is not perfect, but it has some great advantages compared to some others. For one thing, it is pure Common Lisp, so you don't have the impedance mismatch between a Common Lisp and a language without automatic memory management.
<beach>
z3t0: And CLIM has a very detailed specification, though we do not have a good user manual for McCLIM yet.
<z3t0>
I'll have to discuss with my team ahha, if it was up to me we would probably be going with something like that, but its a hard enough sell to use lisp in the first place
<beach>
z3t0: By using McCLIM, and hopefully improving it as well, you help with the common free Common Lisp toolbox that we are aiming to create.
<z3t0>
currently we are doing js/react, which has the advantage of getting something shipped very quickly but as soon as you try to do something not described in some blog post, or the react team introduces a breaking change, or theres some weird bug you need to debug... well then you're out of luck
<z3t0>
I'm just really trying to find a stable solution that has good documentation
<z3t0>
I am hesitant to look into most of the cl libraries because they either seem inactive, or in alpha/beta stage
<z3t0>
anyways im out for the night, if you have any more thoughts feel free to tag me. I'll read my messages the next time im on
<beach>
And there is the #clim channel which is very active.
<beach>
The people currently working on McCLIM are very helpful, but with answering questions and providing fixes for problems you may have.
<defunkydrummer>
beach : z3t0 is looking for something that will work on any OS, that's why I didn't steer him to McClim ("the stuff really boring dreams are made of")
<beach>
I see.
<defunkydrummer>
beach : i really wish for the day the windows backend for McClim is ready
<beach>
I really wish for the day when people would stop using Windows and other proprietary operating systems.
<defunkydrummer>
that would be a major milestone. On the other hand, GUI development is old stuff nowadays. All frontend now is either javascript or a custom Android/Iphone app
<defunkydrummer>
beach i really wish for the day Lisp is again used by the industry, not just in an academic setting. And the industry has a large usage of Windows
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<defunkydrummer>
beach besides, Unix is a regression in the state of the art. And you know it perfectly: You wrote "lispos.pdf" where you rightly show how a lisp operating system should be, and it leaves the unix/posix world lacking in comparison
sauvin has joined #lisp
<defunkydrummer>
@beach: if there's any OS people should switch, it should be one free from the posix legacy. Maybe Mezzano or whatever
<beach>
Yes, but the comparison is not Windows.
<defunkydrummer>
beach i'm all for suggestions as long as don't get me back to 1968 and "everything's a text file"
<defunkydrummer>
beach in any case, our discussion is pointless, since everything is moving to containers and "serverless"
<defunkydrummer>
@beach
<beach>
You are right, it is pointless indeed.
<defunkydrummer>
i work in a company. This is a major company, part of a very, very big company. 1200 users on my office. All on windows. I want to create tools useful for them, so i need GUI in the first place. I can't change stuff to linux, it's not an option.
<defunkydrummer>
beach so I can't use McCLIM if I want to use Common Lisp.
<defunkydrummer>
i need to look elsewhere (iup, etc). Or ditch Common Lisp.
<beach>
You don't have to apologize.
<beach>
... or explain.
<defunkydrummer>
:/
Kundry_Wag has quit [Ping timeout: 246 seconds]
<defunkydrummer>
well, bye folks
defunkydrummer has left #lisp [#lisp]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
Oladon has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 246 seconds]
akoana has left #lisp [#lisp]
Kundry_Wag has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
karlosz has quit [Quit: karlosz]
Bike has quit [Quit: Lost terminal]
karlosz has joined #lisp
slac-in-the-box has joined #lisp
emacsomancer has quit [Read error: Connection reset by peer]
Nilby has joined #lisp
emacsomancer has joined #lisp
saravia has quit [Remote host closed the connection]
gravicappa has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
dddddd has quit [Remote host closed the connection]
vlatkoB has joined #lisp
nanoz has joined #lisp
defaultxr has quit [Ping timeout: 246 seconds]
stacksmith has quit [Ping timeout: 250 seconds]
nanozz has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
fckit has joined #lisp
nanozz has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 250 seconds]
gbiesiad has joined #lisp
dale has quit [Quit: dale]
rumbler31 has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
rumbler31 has quit [Ping timeout: 250 seconds]
<phoe>
z3t0: I am using commonqt + qtools as a layer above it, and I enjoy it so far
Kundry_Wag has joined #lisp
nowhere_man has joined #lisp
Kundry_Wag has quit [Ping timeout: 258 seconds]
nowhere_man has quit [Ping timeout: 258 seconds]
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
nowhere_man has joined #lisp
Kundry_Wag has joined #lisp
nowhere_man has quit [Ping timeout: 258 seconds]
Kundry_Wag has quit [Ping timeout: 258 seconds]
igemnace has quit [Quit: WeeChat 2.4]
slac-in-the-box has quit [Remote host closed the connection]
slac-in-the-box has joined #lisp
Lord_of_Life has quit [Ping timeout: 255 seconds]
Lord_of_Life has joined #lisp
<jeosol>
beach?
<jeosol>
you there?
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<beach>
I am.
deng_cn has quit [Ping timeout: 246 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
<beach>
jeosol: What can I do for you?
Arcaelyx has quit [Ping timeout: 245 seconds]
slac-in-the-box has quit [Ping timeout: 250 seconds]
Kundry_Wag has joined #lisp
<jeosol>
I want to give you a shout-out. Just watched Schafmeister video using Cleavir for his work and reference you
<beach>
Yes, he often does.
<beach>
Is this a new video?
<jeosol>
very impressive work and demonstrates the power of lisp. hahah
<jeosol>
I think it was 2018 on Youtube. It was a LLVM dev talk.
<beach>
I think I have seen it.
<beach>
We work fairly closely together, so I hang out in the #clasp channel and he is present in #sicl.
Kundry_Wag has quit [Ping timeout: 250 seconds]
oni-on-ion has quit [Remote host closed the connection]
<no-defun-allowed>
Around 15:00 Schafmeister name-drops beach and an "Alex Wood" for their Cleavir compiler framework.
fanta1 has joined #lisp
SaganMan has joined #lisp
lumm has quit [Quit: lumm]
lumm has joined #lisp
cosimone has joined #lisp
selwyn has joined #lisp
shka_ has joined #lisp
Kundry_Wag has joined #lisp
igemnace_ has joined #lisp
igemnace has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
SaganMan has quit [Ping timeout: 276 seconds]
_whitelogger has joined #lisp
Folkol has joined #lisp
gareppa has joined #lisp
fckit has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 246 seconds]
<pjb>
minion: memo for defunkydrummer: on MS-Windows, you can use Clozure CL; with it's FFI (using CFFI), you can access all the MS-Windows API, including to implement native GUI.
<minion>
Remembered. I'll tell defunkydrummer when he/she/it next speaks.
Achylles has joined #lisp
<phoe>
no-defun-allowed: Alex Wood is Bike
<no-defun-allowed>
Thanks phoe
lumm_ has joined #lisp
lumm has quit [Ping timeout: 250 seconds]
lumm_ is now known as lumm
lumm has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 246 seconds]
argo has joined #lisp
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<splittist>
morning
Folkol has joined #lisp
cyberoctopi has quit [Ping timeout: 246 seconds]
q3d has joined #lisp
arduo has joined #lisp
selwyn has quit [Ping timeout: 244 seconds]
cyberoctopi has joined #lisp
izh_ has joined #lisp
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
kajo2 has quit [Ping timeout: 276 seconds]
kajo2 has joined #lisp
nowhere_man has joined #lisp
scymtym has joined #lisp
selwyn has joined #lisp
dddddd has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
Inline has quit [Quit: Leaving]
Inline has joined #lisp
vlatkoB_ has joined #lisp
igemnace_ is now known as igemnace
vlatkoB has quit [Ping timeout: 246 seconds]
<phoe>
morniiiing
<Inline>
morning phoe
<selwyn>
good morning
<jeosol>
no-defun-allowed: Yes, it was that video. Very nice. He said a "Robert ..." a professor at University of Bordeaux.
<jeosol>
I liked the talk, especially for the application and that CL help with difficulties. He also had some benchmark with other languages (perl and python)
<shka_>
what talk?
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<shka_>
jeosol: this article is rather boring
<shka_>
excluding vector instructions, cpu time = energy
Bike has joined #lisp
milanj has joined #lisp
<jeosol>
hahaha, I agree with his energy. I'll need that when I fight trolls who ask me why I use CL
McParen has joined #lisp
<jeosol>
shka_: ok you read the article. I only linked it for those who may be interested in it. I read articles/papers and just get some info. As a reviewer, I have come across many boring papers, so I know what you mean.
<shka_>
well, i don't like measuring IT articles
<shka_>
most of it is not that useful
<shka_>
there are exceptions, obviously
pankajgodbole has joined #lisp
argo has quit [Ping timeout: 264 seconds]
fivo has joined #lisp
Kundry_Wag has joined #lisp
lucasb has joined #lisp
Kundry_Wag has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
caltelt has joined #lisp
egp_ has joined #lisp
izh_ has quit [Quit: Using Circe, the loveliest of all IRC clients]
t58 has joined #lisp
macdavid313 has joined #lisp
brundleticks has joined #lisp
grumble has quit [Quit: Well, would you look at the time. I've almost missed my ambiguous, non-existent appointment that I have scheduled just when I start to lose interest in my current conversation.]
Inline has quit [Ping timeout: 264 seconds]
grumble has joined #lisp
macdavid313 has quit [Quit: macdavid313]
nowhere_man has quit [Ping timeout: 255 seconds]
bitch has quit [Ping timeout: 245 seconds]
bitch has joined #lisp
egp_ has quit [Quit: Leaving]
Oladon has joined #lisp
test1600 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
brundleticks has quit [Remote host closed the connection]
macdavid313 has joined #lisp
FreeBirdLjj has joined #lisp
macdavid313 has quit [Client Quit]
macdavid313 has joined #lisp
X-Scale has quit [Ping timeout: 246 seconds]
elderK has joined #lisp
selwyn has quit [Remote host closed the connection]
nirved_ is now known as nirved
Inline has joined #lisp
macdavid313 has quit [Quit: macdavid313]
macdavid313 has joined #lisp
X-Scale has joined #lisp
pierpal has quit [Ping timeout: 255 seconds]
q3d has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
sdumi has joined #lisp
lemoinem has joined #lisp
macdavid313 has quit [Remote host closed the connection]
ricekrispie has joined #lisp
ricekrispie2 has quit [Ping timeout: 245 seconds]
argo has joined #lisp
quazimodo has quit [Ping timeout: 255 seconds]
quazimodo has joined #lisp
cosimone has quit [Ping timeout: 276 seconds]
makomo has joined #lisp
sdumi has quit [Quit: Quit]
cosimone has joined #lisp
stacksmith has joined #lisp
saravia has joined #lisp
v88m has joined #lisp
defunkydrummer has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cyberoctopi has quit [Ping timeout: 245 seconds]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
cosimone has quit [Client Quit]
defunkydrummer has quit [Ping timeout: 258 seconds]
manualcrank has joined #lisp
Achylles has quit [Remote host closed the connection]
cosimone has joined #lisp
manualcrank has quit [Client Quit]
manualcrank has joined #lisp
neeasade has joined #lisp
gareppa has quit [Quit: Leaving]
<neeasade>
hi all
<pjb>
hi one
<neeasade>
first time slime user here -- is there a way to get eval overlays like cider
<beach>
neeasade: People probably don't know what cider is, so you are better off explaining what you want.
cyberoctopi has joined #lisp
<saravia>
hello, here share the pdf or better txt, of the book, practical common lisp?
<p_l>
minion: tell saravia about pcl
<minion>
saravia: look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<p_l>
have HTML version
<p_l>
(legal, published by author)
<saravia>
ow, thanks
<saravia>
its ok
<saravia>
someone dev of gnu guile
<saravia>
?
<beach>
saravia: This channel is dedicated to Common Lisp.
<beach>
saravia: And Guile is more close to Scheme.
<saravia>
ow sorry im very new, too at IRC, in my country is some rare, IRC, Lisp, etc
<beach>
No need to be sorry. Just explaining to you.
<neeasade>
beach: thanks, I will clarify -- there is an emacs package, eros, that displays eval result overlays in the buffer. it looks like this: https://0x0.st/zb4q.png . I was hoping for something similar for slime/CL
<saravia>
but surprice, but, two friends of my country
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
lumm has joined #lisp
kajo2 has quit [Ping timeout: 258 seconds]
q3d has quit [Ping timeout: 256 seconds]
cosimone has quit [Quit: WeeChat 2.3]
cosimone has joined #lisp
cosimone has quit [Client Quit]
scymtym has quit [Ping timeout: 250 seconds]
nanoz has joined #lisp
defunkydrummer has joined #lisp
<defunkydrummer>
minion: memo to pjb: minion isn't working, thanks for the memo (read it on lisp logs instead)
<minion>
Remembered. I'll tell pjb when he/she/it next speaks.
<minion>
defunkydrummer, memo from pjb: on MS-Windows, you can use Clozure CL; with it's FFI (using CFFI), you can access all the MS-Windows API, including to implement native GUI.
<defunkydrummer>
whoops, seems minion needed to be notified first to flush output to me.
<defunkydrummer>
saravia, PuercoPop and myself are in the same city. This brings me most-positive-fixnum happiness.
<defunkydrummer>
3 lispers here
pierpal has joined #lisp
Nilby has quit [Remote host closed the connection]
<neeasade>
> The assumption may not be warranted, but this is the real world.
<neeasade>
heh
<neeasade>
phoe: thanks, I'll look into it, I may just end up posting the final thing on #emacs or #lisp
cosimone has quit [Client Quit]
<neeasade>
er, s|#|/r/|g
defunkydrummer has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
<phoe>
neeasade: #lisp might like it
Arcaelyx has joined #lisp
klltkr has quit [Remote host closed the connection]
brundleticks has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
brundleticks has quit [Client Quit]
terpri_ has quit [Remote host closed the connection]
terpri has joined #lisp
hvxgr has quit [Ping timeout: 250 seconds]
puchacz has joined #lisp
<puchacz>
hi, is Clasp easy to use (say like SBCL) or it is more for adventurous people who know C++ etc.? somebody said here that ECL is for adventurous people, and I saw youtube video about Clasp where drmeister said the Clasp code was largerly taken from ECL....
<pjb>
Nah, you can use ecl like any other implementation, it has a normal REPL.
<minion>
pjb, memo from defunkydrummer: minion isn't working, thanks for the memo (read it on lisp logs instead)
abhixec has joined #lisp
<shka_>
puchacz: it is just not as widely used as sbcl
<shka_>
but it is standard CL
<pjb>
puchacz: the only thing that will look different to a normal lisper, is that ecl doesn't save lisp images. So when you launch a program build from ecl, you don't restore a lisp image, but it's like if you loaded all the object files.
miatomi is now known as femi
<shka_>
and compiler is not that fast, but that's because it delegates actual compilation to GCC
<shka_>
and well, GCC is not fast
<pjb>
puchacz: on the other hand, when you need to interface with C or C++, you see the advantages of ecl. Or when you use it in a foreign program as the libecl library.
<puchacz>
ABCL does not use images either, it would be a problem if I was deploying applications (even to a server) but when I use it at work to script around our huge Java application locally to investigate or test something, it is no problem at all.
hvxgr has joined #lisp
<puchacz>
okay then, thanks pjb and shka_ - all sounds good :)
<shka_>
anyway ECL is mature implementation, i think that clang is the one for adventures
<puchacz>
clasp you mean?
<shka_>
clasp
<shka_>
sorry
nirved_ has joined #lisp
kajo2 has joined #lisp
nirved has quit [Ping timeout: 252 seconds]
scymtym has quit [Remote host closed the connection]
saravia has quit [Ping timeout: 244 seconds]
saravia has joined #lisp
kenu has joined #lisp
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
Nilby has quit [Remote host closed the connection]
<TheWild>
okay, it's not about parentheses. It's about the Lisp's prefix notation. How do you read it?
kenu has quit [Remote host closed the connection]
random-nick has quit [Remote host closed the connection]
<pjb>
TheWild: you watch the first symbol in the list. If it's the name of a special operator, you interpret the rest according to the special rules of this special operator.
<pjb>
TheWild: if it's a macro, you interpret the rest according to the rules of the macro.
<shka_>
and the rest is practice
lucasb has quit [Quit: Connection closed for inactivity]
<shka_>
you can get used to it
<pjb>
TheWild: otherwise, it must be a function name, or a lambda-expression designating an anonymous function. Then you must evaluate the remaining elements in the list in order, keep the main results, and pass them as argument to the function named by the first element.
<TheWild>
sure thing for very small programs. When the program gets a little bigger, all I see is a soup or numbers, keywords and operators.
<pjb>
There are some conventions, like, we usually introduce bindings first.
<pjb>
TheWild: just consider each list in turn!
<shka_>
TheWild: you can get used to it, if find lisp programs very easy to read
<TheWild>
shka_: yeah, like you were reading my mind.
v88m has quit [Read error: Connection reset by peer]
<shka_>
seriously though, syntax is skin deep
gareppa has joined #lisp
v88m has joined #lisp
<shka_>
don't get overly attached
abhixec has quit [Ping timeout: 246 seconds]
<TheWild>
shka_: thanks for giving me some faithm. pjb, thank you too.
<pjb>
TheWild: you can always ask here or in #clschool if you have a problem with a specific example.
<shka_>
i like lisp syntax
<shka_>
it is simple and uniform
<shka_>
but this is a matter of taste
<pjb>
TheWild: I would advise an exercise: write a lisp function to take a lisp expression, and print out an explaination of it.
<pjb>
TheWild: once you've done that, you won't have any problem reading lisp.
gareppa has quit [Remote host closed the connection]
<shka_>
start by learning how to write your everyday code decently well
<phoe>
also what shka_ said - if you want to see what they can do, take a look at them; but never start learning Lisp by learning how to write macros
<TheWild>
ah, \( and \). I thought I could just overwrite the bare fundamentals and... well, I couldn't imagine it.
<shka_>
also, some people are fixated on macros
<phoe>
you actually have to have a good understanding of list processing in Lisp to be able to write somewhat complicated ones.
<phoe>
TheWild: no no
<phoe>
look lower
<shka_>
and will keep telling you how amazing they are
<phoe>
at the parts wrapped in #{ #}
<shka_>
but the key is the perspective
<phoe>
these are the reader macros that activate C syntax that this module provides.
<TheWild>
#{ format (t, "Hello World!"); }#
<TheWild>
whaaaaaaat?
<phoe>
exactly
<shka_>
your macros don't make lisp powerful, your macros can be powerful thanks to everything else in the lisp
<TheWild>
yikes! That's just pure awesomeness.
<TheWild>
I have to look inside how it was made
<phoe>
oh no
<phoe>
TheWild: do you know how the Lisp reader works?
defaultxr has joined #lisp
<shka_>
TheWild: don't waste your time, learn how to write your usual code good enough, once you have that learning everything else will become just that much easier
<shka_>
because you won't be puzzled by lisp semantics
<shka_>
for instance, you won't understand once-only if you don't understand lisp scopes
<shka_>
and given that you may be JS programmer, you can have very weird ideas
<TheWild>
I'm curious how ( and ) inside #{ }# has not been inrepreted as subexpression... or maybe it was?
<MichaelRaskin>
You can change everything
<xantoz>
basically you can rewrite the parser
<MichaelRaskin>
You can redefine what ( means
<phoe>
TheWild: reader macros are functions that take arbitrary input from the input stream and pop out Lisp expressions
<phoe>
how they do that - it's up to them, they can execute arbitrary Lisp code as a part of their processing
<shka_>
they pop out lists
defunkydrummer has joined #lisp
<shka_>
plain and simple
<xantoz>
they pop out lisp data structures
<TheWild>
about month ago I was learning lambda calculus and SK combinator calculus. I've no idea how I ended up there though.
<phoe>
so you can say that Lisp has a programmable reader
<phoe>
woo boy, Lisp is a practical language, somewhat far from theory like LC and SKCC
<shka_>
TheWild: once again, you don't know how lisp lexical scope works, how special variables work, how packages work and what is the symbol datatype
<shka_>
just save yourself time, learn basics and then move forward
<TheWild>
so even if I'm not going to write any good Lisp code, I'd like to see what others have invented.
<TheWild>
and maybe jump into another trip
<defunkydrummer>
TheWild: better don't get distracted by reader macros for now. Or CLOS.
<phoe>
TheWild: basically, learn yourself some Lisp, and a) you will be able to write crazy shit like this, b) you will learn yourself a stable, interactive and bendy programming language along the way
<defunkydrummer>
TheWild: or even macros. Start with the real basics like let, defun, cond, format, then maybe loop, then some list operations like mapcar, append, reverse, push
<defunkydrummer>
and what skha_ said as well
<TheWild>
I'll do. I'll have fun.
<defunkydrummer>
reader macros are cool but in practice they are used very sparingly
<defunkydrummer>
i guarantee you'll find pleasant surprises even by doing regular lisp code without clos or reader macros.
<shka_>
i literally wrote one practical reader macro
<phoe>
so did I, and it doesn't do any weird syntax shit - it just marks some expressions as test steps in my library for describing test cases/test steps
<phoe>
all the magical REPL variables are + ++ +++ * * *** / / /// -
<TMA>
++ and +++ are the butlast and butbutlast
<aeth>
You basically never need reader macros. e.g. Let's say you're writing a bunch of hash-tables that start with certain values and you want to make that easier. Is #h(:foo 42 :bar 43) as a hash-table reader-macro really better than (hash :foo 42 :bar 43) as a hash-table regular-macro? The reader macro makes everything harder, and the editor probably thinks ":foo" is special, and what if :foo is (+ x y) instead?
<TheWild>
ah, this explains why the weird thing was happening. I thought I'll get a reference to the body of +
<jackdaniel>
reader macros are useful when you want to augument syntax (i.e parse commas as separators), it is never needed for ordinary lisp code
<phoe>
TheWild: also, Common Lisp is a Lisp-2 - in very basic terms, it means that + can name multiple things - in standard CL, the symbol + names both a variable and a function
<TheWild>
if all the code is a list then in theory I could (execute-here function-body) or (translate-to-something-else function-body)
<phoe>
the 2 in Lisp-2 means that it has two namespaces
<phoe>
(even though it has N namespaces, because there are a few more namespaces in the standard and then also programmers can define their own)
<neeasade>
phoe: one for variables and one for symbols/functions, right?
<neeasade>
o
<jackdaniel>
it means that it has two different namespaces for variables and functions, there are certainly more namespaces
<neeasade>
neat
<phoe>
neeasade: variables, functions, classes, tagbody tags, catch tags, restarts... I forgot one I think, but whatever
<neeasade>
I'm coming to cl from elisp, which is also a lisp-2, so it feels a little natural already
<jackdaniel>
namespaces are quite arbitrary, you may assign a special meaning to a name in your own interface and you have one new namespace
<phoe>
^
<phoe>
TheWild: "all the code is a list" this is a bit more complicated
<phoe>
functions are defined via DEFUN forms or LAMBDA forms which are lists, but once these forms are evaluated, function objects are created
<phoe>
and usually they contain compiled code, which isn't a list
<jackdaniel>
code is data would be more accurate
vlatkoB_ has quit [Remote host closed the connection]
<aeth>
TheWild: I think you mean (eval function-body) and that can only happen if you save the function's source somewhere (the function is compiled). You could have a macro that has two effects, though, one being a defun and the other saving the definition. It's not quite as simple as a direct eval because that would only work for (defun foo () "Hello") and not (defun foo (x) (format nil "Hello, ~A~%" x)) because (eval `(format nil "Hello, ~A~%"
<neeasade>
that's why macros are fun, because in that phase you can treat the code as a list and do those kinds of transformations
<phoe>
but just as jackdaniel said - since Lisp code is lists, it can be treated as data, and you can operate on it using normal list-processing functions
<aeth>
in case that got cut off: because (eval `(format nil "Hello, ~A~%" x)) won't know what x is.
lnostdal has quit [Remote host closed the connection]
<jackdaniel>
phoe: I did not mean that. I meant what I said: you may take a function, assign it to a variable and pass it to another function, and that code is manipulated with macros (so it is treated as argument). not that you may code-walk it
<jackdaniel>
you can code walk it of course, but that's not what I've said
<phoe>
jackdaniel: oh - I misunderstood in that case
<phoe>
probably should go to sleep now
McParen has left #lisp [#lisp]
Nilby has quit [Read error: Connection reset by peer]
gbiesiad has quit [Quit: gbiesiad]
wigust has joined #lisp
nirved has joined #lisp
saravia has joined #lisp
wigust- has quit [Ping timeout: 250 seconds]
nirved_ has quit [Ping timeout: 258 seconds]
scymtym has joined #lisp
TheWild has quit [Quit: TheWild]
Jesin has joined #lisp
orivej has joined #lisp
pierpal has quit [Ping timeout: 258 seconds]
Younder has quit [Remote host closed the connection]
moldybits has quit [Quit: WeeChat 2.4]
saravia has quit [Quit: Leaving]
saravia_ has joined #lisp
defunkydrummer has quit [Ping timeout: 246 seconds]
<neeasade>
hello #lisp, I'm trying to grok quicklisp -- as a test, I randomly picked the package "cl-speedy-queue".
<neeasade>
after I run (ql:quickload "cl-speedy-queue"), what else do I need to do?
<no-defun-allowed>
now cl-speedy-queue has been loaded, so you can probably use the library from the package cl-speedy-queue (or check which packages are loaded in the printout)
<neeasade>
what does that look like? I tried calling (cl-speedy-queue)