<nirved>
jdz: translation might happen, but char-code will still be a single integer
robdog has joined #lisp
<jdz>
nirved: Yes, the question was: what exactly is that integer.
robdog has quit [Ping timeout: 252 seconds]
marcoecc has quit [Ping timeout: 240 seconds]
crsc has quit [Quit: leaving]
orivej has quit [Ping timeout: 250 seconds]
<jackdaniel>
in other words encoding and decoding happens at the implementation discretion and from the program perspective newline is a #\newline
<jackdaniel>
(what gives you an extra bonus for portability ,-)
<jackdaniel>
it is worth noting, that I'm not sure what would be a purpose of learning the char-code of this character on windows
<no-defun-allowed>
Could just be curiosity into how implementations deal with it.
<no-defun-allowed>
I think the least surprising solution would be to magically make any newlines Unix newlines, converting Windows-style newlines as they come, but there's certainly something I'm missing.
<jackdaniel>
what kind of insight gives you a char-code of newline?
<no-defun-allowed>
Non-portable insight?
<nirved>
for (char-code #\Newline) sbcl, ccl, and clisp all return 10
<jackdaniel>
no-defun-allowed: I simply do not understand what knowledge do you gain from the fact, that newline code is 10, 42 or 666
z3t0 has joined #lisp
<z3t0>
Hi!
<no-defun-allowed>
I don't either.
<jackdaniel>
z3t0: hey
<no-defun-allowed>
That's why I'm not asking, I suppose.
<z3t0>
I'm trying to do some research on different programming languages with unique features that allow for more expressiveness or neat different styles of programming
<jackdaniel>
from the implementation point of view a way to deal with it would be adding :external-format argument to open (defaulting to :default)
<z3t0>
A few languages I have looked at are cl, racket, nim and red
<jackdaniel>
and depending on its value choosing encoder/decoder which translates the output
<z3t0>
Can someone direct me to some reading material I can use to learn more?
<jackdaniel>
minion: please tell z3t0 about paip
<minion>
z3t0: paip: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp
<jackdaniel>
minion: please tell z3t0 about onlisp
<minion>
z3t0: please look at onlisp: An advanced textbook on Common Lisp, with special focus on macros. at http://www.cliki.net/On%20Lisp
<no-defun-allowed>
minion: please tell z3t0 about pcl
<minion>
z3t0: please see 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).
* no-defun-allowed
crosses her fingers
<no-defun-allowed>
YES! good bot!
<z3t0>
My end goal is to find an expressive language that I can use for a new project. I'm looking for something that's fairly high performance but mainly expressive. I want something that I can do high level and low level programming if needed
<z3t0>
Thank you! I'll look at those resources
<no-defun-allowed>
well, SBCL and CCL are very fast but you won't need too much low level twiddling
<jackdaniel>
so: paip gives you a good feel how it is to program real systems in CL; let over lambda gives you somewhat chaotic overview on how you can (but imo shouldn't) use closures; onlisp has some nice insight into macros; pcl gives you a good overview about the language with a good focus on CLOS
<z3t0>
What kind of control does sbcl give over managing things like threads, and the garbage collector?
<jackdaniel>
by the way, is there any CL book which puts condition system on a pedestal and discusses various possible usages for them?
<z3t0>
One of the issues I had with common lisp I the past is struggling to do anything meaningful with Gui libraries. Specifically on mac
<jackdaniel>
sbcl has native operating system threads (no n-to-m mapping nor green threads)
<jackdaniel>
as of the garbage collector, I have no good experience to say anything interesting
<jackdaniel>
regarding GUIs – most implementations give you ffi and there are bindings to other gui toolkits
<_death>
jackdaniel: PCL has that chapter about them.. but I don't know of other book discussion at length ('cept CLtL2 I guess).. the best is Pitman's papers
<jackdaniel>
as of native solutions there is mcclim
<no-defun-allowed>
the best GUI library around is McCLIM, but if you can't use XQuartz, then the typical C libraries are still pretty good
<jackdaniel>
I think I've skimmed through it at some point of time, but I will reread it later today
<easye>
And for some reason, the practical details of using conditions didn't fully sink in until I read the relevant chapters of _Common Lisp Recipes_ <http://weitz.de/cl-recipes/>
<_death>
his reference implementation is also easy to read
lavaflow_ has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
igemnace has quit [Quit: WeeChat 2.4]
_whitelogger has joined #lisp
orivej has joined #lisp
orivej has quit [Ping timeout: 255 seconds]
lumm has joined #lisp
robdog has joined #lisp
robdog_ has joined #lisp
beaky has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 252 seconds]
beaky_ has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
beaky_ is now known as beaky
xkapastel has joined #lisp
dddddd has joined #lisp
m00natic has joined #lisp
robdog has joined #lisp
ym555 has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
mrcom_ has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
mrcom_ has joined #lisp
orivej has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
mrcom_ has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
mrcom_ has joined #lisp
marvin2 has joined #lisp
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
wanz has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
wanz has quit [Quit: wanz]
terpri_ has joined #lisp
terpri has quit [Read error: Connection reset by peer]
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
quazimodo has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
ym555 has quit [Ping timeout: 250 seconds]
quazimodo has joined #lisp
robdog has joined #lisp
varjagg has joined #lisp
mrcom__ has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
robdog has quit [Ping timeout: 252 seconds]
mrcom_ has quit [Ping timeout: 245 seconds]
hlavaty has quit [Ping timeout: 240 seconds]
wanz has joined #lisp
python476 has joined #lisp
robdog has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
<varjagg>
i want make-instance to return an existing instance for a particular class sometimes, depending on the arguments
<varjagg>
what's the best way to do that, around method for make-instance?
robdog has quit [Ping timeout: 252 seconds]
Lord_of_Life has joined #lisp
robdog has joined #lisp
<jackdaniel>
I'd define a new metaclass and specialize make-instance
<jackdaniel>
imagine two people add around method on make-instance for standard-class, the second one overwrites the first one and you have a sad programmer debugging weird issues
<Xach>
jackdaniel: specializing on the name of the class via eql seems like an option
robdog has quit [Ping timeout: 252 seconds]
<varjagg>
yes i was thinking to specialize on my own class in particular
<jackdaniel>
yes, that works too
<_death>
returning an existing instance violates make-instance's contract
<varjagg>
you mean protocol :p
<jackdaniel>
contract as an agreement between a compiler and a programmer
<_death>
or spec and programmer
<jackdaniel>
right, spec fits the bill better here
<jackdaniel>
varjagg: can't you have make-foobar?
<jackdaniel>
fwiw asdf did follow this way: they forbidden "external" make instance and demand you to use make-operation
<jackdaniel>
(which, indeed, looks first if it can get lazy and return something existing on the system as in memoization)
<varjagg>
good point
themsay has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
robdog has joined #lisp
ym555 has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 245 seconds]
terpri has joined #lisp
terpri_ has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
lucasb has joined #lisp
peterhil has quit [Read error: Connection reset by peer]
peterhil has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
themsay has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
<gendl>
Hi, I have a bash script which is calling curl to invoke a URL which responds with an s-expression.
<gendl>
the s-expression is a plist and can contain (... ... :STATUS :OK ... ...) or (... ... :STATUS :ERROR ... ...)
juristi has quit [Quit: Konversation terminated!]
<gendl>
can anyone recommend the most straightforward way to have the bash script parse the s-expression to understand if the status is :OK or :ERROR, and have the script return either 0 exit code for :OK or a nonzero code for :ERROR
<gendl>
Xach: you may recognize where this is coming from ;)
<gendl>
I know an alternative is to use a lisp script instead of a bash script - I might also move in that direction before too long, but i'd also like to be able to do something simple like this just with a bash script
* jackdaniel
tries to find the "problem statement"
<jackdaniel>
ah, nvm
<jackdaniel>
I've skipped one line apparently
<gendl>
i guess just using normal regular expression parsing from bash. I'm just spoiled being able to use simple 'read' to parse s-expressions, i seize up a bit when faced with anything else...
robdog has joined #lisp
robdog_ has quit [Ping timeout: 240 seconds]
<TMA>
gendl: if you want to be bash specific then eval "a=$sexpr" ; set fnord "$a[@]" ; for i do shift ; case $i in :STATUS) status=$1; break ;; *) ;; esac ; done
jmercouris has joined #lisp
<TMA>
gendl: the hell breaks loose if some of the values in the proplist are not symbols
<jmercouris>
Ah, so you must get the customer object!
<jmercouris>
it works against the customer object and the ID is not enough, yes
<jmercouris>
s/strange/makes sense
<gendl>
TMA: i do have control over the s-expression though. Come to think of it, actually I can control it to the point of reducing the bash parsing to something trivial. I'll just do that for now..
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
Bike has joined #lisp
aeth has quit [Ping timeout: 252 seconds]
<jmercouris>
now I have an unknown stripe parameter!
<jmercouris>
lol, however it is definitely documented as trial_period_days...
aeth has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
warweasle has joined #lisp
andrei-n has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
flazh has quit [Ping timeout: 240 seconds]
jprajzne has quit [Quit: Leaving.]
FreeBirdLjj has joined #lisp
milivoj has quit [Quit: milivoj]
rippa has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
robdog has joined #lisp
python476 has quit [Ping timeout: 252 seconds]
anewuser has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
shrdlu68 has quit [Quit: WeeChat 2.3]
robdog_ has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
trafaret1 has joined #lisp
<trafaret1>
o/
<jackdaniel>
hey
<trafaret1>
need your help. Recently I have installe sbcl and configured slime-mode in emacs. All working good but few days ago I get this problem while starting slime in emacs. Socket error in "bind": 99 (Cannot assign requested address)
<trafaret1>
<trafaret1>
debugger invoked on a SB-BSD-SOCKETS:SOCKET-ERROR in thread
akater has quit [Remote host closed the connection]
<trafaret1>
Socket error in "bind": 99 (Cannot assign requested address)
wanz has quit [Remote host closed the connection]
<trafaret1>
any clue?
akater has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
<jackdaniel>
can you ping "localhost"?
<trafaret1>
jackdaniel: yes
jmercouris has quit [Remote host closed the connection]
<jackdaniel>
then no clue, you may try at #slime channel maybe
robdog has quit [Ping timeout: 252 seconds]
<trafaret1>
jackdaniel: ok thanks
varjagg has quit [Ping timeout: 245 seconds]
Inline has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
robdog_ has joined #lisp
ym555 has quit [Ping timeout: 240 seconds]
<pjb>
varjag: jackdaniel: you cannot use make-foo ; make-… is like make-instance, it must return a new thing. Instead, use intern-foo, which like intern(-symbol) can internalize things, and return them. Provide also a find-foo to find it without making and internalizing it.
trafaret1 has quit [Remote host closed the connection]
<jackdaniel>
pjb: you may come up with any contract to make as you want. like with make on autotools, for some definitions when all is built, then it doesn't take any action
<pjb>
I didn't came up with it, it's in CL.
robdog_ has quit [Ping timeout: 252 seconds]
<jackdaniel>
does standard discuss make- name convention? or you just extrapolate from make-instance?
orivej has joined #lisp
<Bike>
well there's also make-array, make-hash-table, and so on... i think it's a reasonable idea to stick with.
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<pjb>
jackdaniel: (apropos "MAKE-""CL")
<jackdaniel>
while "reasonable idea" sounds like an OK statement (like something you may agree or disagree with) you say "you cannot", as if it were written in the standard
<jackdaniel>
to provide an example: untrue statement: "you cannot omit earmuffs from special variables" – yes you can, there is nothing in the standard preventing that
<jackdaniel>
even despite *most* special variables being defined that way in cl package
<pjb>
You have to give some strict rules to children…
orivej has quit [Ping timeout: 244 seconds]
Ricchi has quit [Read error: Connection reset by peer]
robdog has joined #lisp
<_death>
imagine if they used proper english for MAKUNBOUND ;)
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
* dreamcompiler
Anybody know how to get meta-dot in Emacs/SLIME to find SBCL source code? I've recompiled SBCL from source. Does meta-dot in SBCL depend on a tags table or does it hook into an internal mechanism in SBCL like it does in CCL?
<_death>
have something like (sb-ext:set-sbcl-source-location "/path/to/sbcl/") in your ~/.sbclrc
hhdave has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
* dreamcompiler
Did that, but emacs is still asking me if I want to visit a tags table. Is this normal or does it indicate I'm still doing something wrong?
<_death>
are you in a lisp-mode buffer?
<_death>
(and do you have sbcl/slime running?)
robdog has quit [Ping timeout: 252 seconds]
* dreamcompiler
yes and yes
* dreamcompiler
I type "open" (without the quotes) and press m-.
* dreamcompiler
Emacs throws up a tags table message
* dreamcompiler
(This is in the listener)
<_death>
if you `C-h k M-.` does it says it runs the command slime-edit-definition?
<_death>
*say
* dreamcompiler
"M-. runs the command xref-find-definitions ..."
* dreamcompiler
So I must have that borked up in my .emacs somewhere.
<_death>
slime-mode sets up the right keymap
Fare has joined #lisp
* dreamcompiler
Somehow on my system m-- m-x slime sbcl doesn't invoke slime-mode.
<jackdaniel>
dreamcompiler: could you please write "normally", i.e not via /me command? at least on irssi it is unnaturally highlighted
<sjl_>
yeah emoting everything is really weird
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
phenoble_ has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]
* dreamcompiler
Sorry. Colloquy is treating every <lf> as a new posting.
Fare has quit [Ping timeout: 246 seconds]
ggole has quit [Quit: Leaving]
dale_ has joined #lisp
dale has quit [Ping timeout: 246 seconds]
dale_ is now known as dale
robdog has joined #lisp
<Fade>
strange times on the internet.
vms14 has joined #lisp
<dreamcompiler>
Is this better?
robdog has quit [Ping timeout: 252 seconds]
<dreamcompiler>
I was hitting ctrl-return instead of fn-return (enter). It was sending /me. Sorry.
dale_ has joined #lisp
<Fade>
yes
dale has quit [Disconnected by services]
<vms14>
guys
dale_ is now known as dale
<vms14>
what you did to master car and cdr?
<vms14>
I understand how they work, but it's a pain for me to use them in nested lists inside nested lists
<vms14>
like when you end with thinks like (cadddr (cddr value ))
<Fade>
unpack the 'a's and 'd's
<vms14>
I try it, also doing some exercises
<Fade>
cadr = "first of the rest"
<vms14>
like making a simple list, then making some nested lists
<Fade>
caddr = "first of the rest of the rest"
<vms14>
but with nested lists inside nested lists I'm lost
<Fade>
car = first and cdr = rest
<vms14>
and I just try by trial and error
<sjl_>
I generally don't use them to do nested stuff very often. Either I use destructuring-bind, or I convert a giant nested list-of-lists-with-particular-strucuture into a class.
<Fade>
I think about it in these terms and I can unpack them on the fly.
verisimilitude has quit [Remote host closed the connection]
<vms14>
thanks to both
Fare has joined #lisp
<vms14>
Idk what does destructuring bind yet, but I see it a lot of times
<vms14>
also I should be able to use car and cdr properly
<Fade>
are you working through "practical common lisp" ?
<Fade>
you should read it in the beginning, in my opinion.
<vms14>
I'd like to still reading the land of lisp
robdog has joined #lisp
<vms14>
So I let land of lisp and go for pcl instead?
Zaab1t has joined #lisp
<sjl_>
If you're enjoying land of lisp, finish it and then go for PCL. If you're strugging, switch over to PCL (or the Gentle Intro book if PCL is feeling tough too)
<Fade>
I think PCL is a better introduction, but land of lisp is good too.
<vms14>
land of lisp is a bit funny, but idk which one has better "teaching style"
<vms14>
I've tried pcl, and did the first exercise
<vms14>
the cd database
<Fade>
if it's working for you, then keep at it.
<Fade>
but PCL covers the basics in a straight forward pedagogical style.
<pjb>
vms14: you can use "the little schemer" to learn about car and cdr (and recursion).
<jackdaniel>
vms14: I get lost for anything but car cdr and cddr
<vms14>
a json object I receive from telegram api
<sjl_>
I think most folks here would say PCL has better style, but there's something to be said for Land of Lisp's "fun". If you're having fun, keep at it.
<vms14>
well I like the imagination that guy had to write land of lisp
robdog has quit [Ping timeout: 252 seconds]
<Fade>
run through it, then.
<vms14>
also I've read the comic in last pages
<vms14>
but I guess I'll go for pcl
<Fade>
you could use things like PCL and Gentle Guide as supplementary material.
karlosz has joined #lisp
<vms14>
well I'll need to practice and follow Fade's advice
<vms14>
just go step by step with cdr and car and know where I'm going with them
CCDelivery has joined #lisp
pmc_ has joined #lisp
<vms14>
but this json is fucking me xD
<pmc_>
Anyone know how many built-in functions and macros there are in Common Lisp?
<_death>
pmc: you can count them.. (let ((n 0)) (do-symbols (s "CL") (when (fboundp s) (incf n))) n)
<pmc_>
Cool. 875.
<pjb>
vms14: actually, you can ignore almost completely car and cdr. Just consider: list list* first rest second third … tenth endp nth
<cl-arthur>
Fun learning is usually oddly efficient learning :)
<pjb>
_death: pmc_: but be careful, because implementations are allowed to add fbindings to symbols exported from CL!
<pjb>
better to grep clhs…
<Fade>
vms14: the compound forms of car and cdr are good to know, but if it's getting in the way of actually accomplishing your task, you can compose the accesses in terms of #'first #'rest and #'nth
<_death>
pjb: indeed, here I get 752
<pjb>
vms14: and foremost, write your own abstractions.
<phoe>
so the news is: the Lisp WORDNET library finally got assigned a license by the MIT licensing office.
<pjb>
(let ((n 0)) (do-symbols (s "CL") (when (fboundp s) (incf n))) n) #| --> 749 |# in ccl.
<phoe>
It was only half a year of wait!
milivoj has joined #lisp
<Fade>
Nice. :)
robdog has joined #lisp
vlatkoB has joined #lisp
andrei-n has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
<vms14>
(cdaddr (cdaddr (cdadar (cddadr oh))))
<vms14>
this is to take the username in that json
robdog has joined #lisp
<beach>
vms14: That is silly.
<vms14>
the json will change and add stuff with time, so what I should do?
<beach>
vms14: Lists should not be nested like that.
dvdmuckle has quit [Quit: Bouncer Surgery]
<Fade>
the json libs are exporting a poor data structure.
<vms14>
this is from tg api, using drakma and cl-json
<Fade>
not that I've looked very closely at it.
<Fade>
I suspect that I'd reach for pattern matching in that case.
<_death>
write a function that takes a list of keys and traverses the json structure to get at the value
<vms14>
_death, yeah, thanks
<Fade>
optima
<vms14>
that's what I should do really
<vms14>
a list eater searching for keyword
Zaab1t has quit [Quit: bye bye friends]
robdog has quit [Ping timeout: 252 seconds]
dvdmuckle has joined #lisp
<jackdaniel>
o/win 2
<sjl_>
vms14: that looks like an alist, ASSOC or a little helper function might be handy
<sjl_>
You definitely shouldn't rely on car/cdr for JSON objects converted into alists. JSON objects don't have any ordering between their keys, so what might be (third obj) today could be (second obj) tomorrow
<phoe>
these two JSON objects are equal to each other via JavaScript equality, but the resulting parsed structures are not equal to each other via CL:EQUAL.
<phoe>
that's a trivial example.
<sjl_>
I like yason. With a little bit of configuration you can get it to parse things pretty sanely.
karlosz has quit [Quit: karlosz]
<sjl_>
It parses objects as hashtables by default, which sidesteps that whole ordering problem.
<sjl_>
(let ((yason:*parse-json-booleans-as-symbols* t) (yason:*parse-json-arrays-as-vectors* t)) (yason:parse string)) will get you something roundtrippable, I think
robdog has joined #lisp
Ricchi has joined #lisp
<Fade>
that looks much saner to me.
<Fade>
fwiw
robdog has quit [Ping timeout: 252 seconds]
Denommus has joined #lisp
LiamH has joined #lisp
robdog has joined #lisp
dreamcompiler has quit [Quit: dreamcompiler]
robdog has quit [Ping timeout: 252 seconds]
hiroaki_ has joined #lisp
random-nick has quit [Ping timeout: 255 seconds]
sauvin has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
Ricchi has quit [Ping timeout: 252 seconds]
vlatkoB has quit [Remote host closed the connection]
cage_ has quit [Ping timeout: 240 seconds]
robdog has quit [Ping timeout: 252 seconds]
python476 has joined #lisp
CCDelivery has quit [Ping timeout: 250 seconds]
ravenousmoose has joined #lisp
charh has quit [Ping timeout: 240 seconds]
akoana has joined #lisp
charh has joined #lisp
<vms14>
sorry I was afk, thanks for the hints, see you later
vms14 has quit [Quit: Doing something with my shit life :D]
nanoz has joined #lisp
ym555_ has joined #lisp
ym555 has quit [Ping timeout: 252 seconds]
im0nde has quit [Ping timeout: 259 seconds]
polezaivsani has joined #lisp
cl-arthur has quit [Remote host closed the connection]
<polezaivsani>
hey! what's the difference between (function (lambda ...)) and just (lambda ...)?
<no-defun-allowed>
none, lambda is a macro that expands to #'(lambda ...)
<no-defun-allowed>
the only difference is just using LAMBDA might not work on Genera but that's its fault for being non-compliant iirc
<polezaivsani>
oh, thanks! and i was trying to see why there is so many uses of #'(lambda)
<polezaivsani>
wait, no doesn't the #'(lambda) get expanded to (function (lambda))?
<polezaivsani>
s/no/now/
<add^_>
s/(function/(funcall
<no-defun-allowed>
#'foo is shorthand for (function foo), similar to ' and quote
<add^_>
actually, no
<add^_>
nevermind me
izh_ has joined #lisp
random-nick has joined #lisp
lumm has quit [Quit: lumm]
im0nde has joined #lisp
<polezaivsani>
seem to make all these three forms to equal to me, doesn't it?
lumm has joined #lisp
nanoz has quit [Read error: Connection reset by peer]
<add^_>
(lambda ...) will just give you a function.. object?
<add^_>
#'(lambda ...) will actually "use" the function
<add^_>
?
<add^_>
I'm a bit rusty, I should shut up
<Inline>
lambda is a macro
<Inline>
#'foo is for referring to the function namespace
<polezaivsani>
why would one might want to write #'(lambda ...) ?
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<fortitude_>
add^_: the difference is what the reader returns
<add^_>
I was somehow confusing function and funcall though
<add^_>
apply is similar to funcall, right?
<add^_>
I think I confused function for apply for some reason..
<fortitude_>
add^_: yes, except that the last argument to APPLY is a list of arguments to pass to the function
<add^_>
ah
<polezaivsani>
thanks for all the help! will go pry at the spec some more
Arcaelyx has joined #lisp
robdog has joined #lisp
ym555_ has quit [Quit: leaving...]
Posterdati has quit [Read error: Connection reset by peer]
Posterdati has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
<polezaivsani>
fyi, description of lambda macro says right away - (lambda ...) = (function (lambda ...)) = #'(lambda ...)
Aruseus has joined #lisp
<buffergn0me>
25.97
<fortitude_>
polezaivsani: good point, I was wrong about the result of reading the #'(lambda ...) form
<fortitude_>
that's what I get for free-handing
Kevslinger has joined #lisp
<Xach>
fortitude_: that ain't right!!
<Xach>
oh, sorry.
* Xach
is way lagged
<fortitude_>
Xach: at least you caught it
<fortitude_>
I just send somebody a paper with that mistake in it
<fortitude_>
(even though its inconsistent with every other description I have of reader macros in there)
robdog has joined #lisp
amerlyq has quit [Ping timeout: 250 seconds]
gxt has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
pmc_ has quit [Quit: Leaving]
warweasle has quit [Quit: later doodz.]
robdog_ has quit [Ping timeout: 252 seconds]
undiscovered has quit [Remote host closed the connection]
charh has quit [Ping timeout: 252 seconds]
ravenousmoose has quit [Ping timeout: 252 seconds]
Posterdati has quit [Read error: Connection reset by peer]
Posterdati has joined #lisp
robdog has joined #lisp
Josh_2 has quit [Ping timeout: 250 seconds]
Posterdati has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 252 seconds]
fnord__ has joined #lisp
Posterdati has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
scymtym has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
robdog has joined #lisp
robdog_ has joined #lisp
Posterdati has quit [Ping timeout: 250 seconds]
ravenousmoose has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
Posterdati has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
kdas_ has joined #lisp
kushal has quit [Ping timeout: 256 seconds]
random-nick has quit [Read error: Connection reset by peer]
robdog_ has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
gxt has quit [Quit: WeeChat 2.4]
lumm has quit [Quit: lumm]
lumm has joined #lisp
karlosz has quit [Client Quit]
robdog has joined #lisp
milivoj has quit [Quit: milivoj]
gigetoo has quit [Ping timeout: 240 seconds]
lumm has quit [Quit: lumm]
robdog_ has joined #lisp
lumm has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 252 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
robdog has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 252 seconds]
gigetoo has joined #lisp
izh_ has left #lisp [#lisp]
robdog has joined #lisp
matijja has joined #lisp
ebrasca has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
hlavaty has joined #lisp
aeth has quit [Ping timeout: 255 seconds]
aeth has joined #lisp
lumm has quit [Quit: lumm]
lumm has joined #lisp
random-nick has joined #lisp
Fare has quit [Ping timeout: 255 seconds]
random-nick has quit [Ping timeout: 255 seconds]
<phoe>
Xach: you freaked the hell out of me
<phoe>
I am walking through town
<phoe>
Then my phone buzzes once, then twice
<phoe>
Then like twenty times in a row
<phoe>
I freak out, open the phone, and notice all the issue-was-closed notifications on quicklisp-projects
<phoe>
Congrats for nearing yet another Quicklisp release, and congrats for scaring the holy McCarthy outta me
matijja has quit [Ping timeout: 255 seconds]
<Xach>
i was slack in closing issues for a few months
<Xach>
I had a nightmare about someone pretending to attack me with a knife at a lisp meeting
quazimodo has quit [Ping timeout: 246 seconds]
scymtym has joined #lisp
<phoe>
what for?
guicho has joined #lisp
robdog has joined #lisp
<Xach>
There is a person who persistently labels me a horrible influence on Lisp and the leader of a conspiracy/mafia, and it stresses me out - the dream was a manifestation of the stress
<no-defun-allowed>
:(
guicho has quit [Ping timeout: 252 seconds]
verisimilitude has joined #lisp
slyrus has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
slyrus_ has quit [Ping timeout: 240 seconds]
xkapastel has joined #lisp
Denommus has quit [Remote host closed the connection]
sjl_ has quit [Ping timeout: 255 seconds]
<moldybits>
:s
robdog has joined #lisp
ravenousmoose has joined #lisp
slyrus_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Bike has quit []
slyrus has quit [Ping timeout: 252 seconds]
kushal has joined #lisp
kdas_ has quit [Ping timeout: 256 seconds]
robdog has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
wxie has joined #lisp
<stylewarning>
Our quantum simulator and optimizing compiler are on Quicklisp! \o/
<aeth>
If you could update the standard in 2021, what would you update?
<aeth>
Personally, I'd lower the short-float precision from 13 to 11 bits so IEEE half-precision is a conforming short-float, I'd mandate (unsigned-byte 8) or octet arrays like bit/character arrays are, and I'd split most minimums (like fixnum) into 32-bit and 64-bit versions so there can be more guarantees, e.g. a 58-bit fixnum minimum if a 64-bit implementation or something. I'd also put bordeaux-threads into the standard.
Josh_2 has joined #lisp
robdog has joined #lisp
<stylewarning>
aeth: i want arbitrary precision long-floats, and a way to extend the numeric hierarchy
robdog has quit [Ping timeout: 252 seconds]
<aeth>
stylewarning: I think long-float should probably be split so extended-precision (80-bit) and quadruple-precision (128-bit) can be represented if there's hardware support, obviously rounding down to double-float just like if you use long-float right now on an implementation that only goes up to double.
<aeth>
Right now long-precision could mean hardware extended precision, hardware, quadruple precision, or arbitrary precision so there's too much confusion as to what you could get.
<aeth>
Strangely, if you had an extended-double-float type in CL, you'd probably never want to actually use directly it. You'd want to use quadruple-float and have it round down to extended-double-float so you'd get quadruple-float instead on hardware where that exists.
lemoinem has joined #lisp
wxie has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
themsay has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
<aeth>
with-float-traps-masked is fairly big. Last I checked, every other library basically seems to hardcode its own #+sbcl sb-int:with-float-traps-masked #-sbcl slow-path
<Josh_2>
With Postmodern I use :generated-as-identity-by-default if I want to have an autoincremented id column?
<Josh_2>
says "Malformed plist, odd number of elements"
<aeth>
That's exactly what it is. A malformed plist, odd number of elements.
<aeth>
perhaps ":identity-by-default t"?
<aeth>
The tail is a plist. At the moment you have (in traditional programming syntax) :col-type=int, :identity-by-default=:accessor, and sql-user-id with no value.
<verisimilitude>
I'd also want arbitrary-precision floats, along with other things.
<verisimilitude>
Ada has decimal fixed point numbers, but Common Lisp is stuck using INTEGER if you want to manipulate things such as money.
<aeth>
decimal might be too controversial.
<aeth>
I definitely agree that languages can learn a lot from Ada, though.
robdog has joined #lisp
mrcom__ has quit [Ping timeout: 245 seconds]
mrcom has joined #lisp
<aeth>
Ada's another language that suffered from the "$~D" most-positive-fixnum compilers to be less popular than it deserved.
<Josh_2>
aeth: yes
<Josh_2>
adding t fixed it, however that's not how it was written in the docs, hence why I didn't xD
<Josh_2>
Thanks tho
<aeth>
you're welcome
<aeth>
the confusing part there with that error is that the *tail* is the plist, starting at the first key. Not starting at id.