<stacksmith>
makomo: I am just cleaning it up, will put it online somewhere shortly. I was considering making a pull request with cffi as it does not break anything and adds considerable capabilities...
<stacksmith>
aeth: (with-c (:temp point p1) (setf x 1 y 2) ...) (:struct point) works too, or 'point although it barks about bare structures. I do (defparameter point (cffi::parse-type (:struct point)) and just use point - it works in everything except with-foreign-slots for some reason quotes the type instead of evaluating it...
ebrasca has quit [Remote host closed the connection]
<dialectic>
is USE-PACKAGE limited to a single file or do I have to UNUSE-PACKAGE at the end?
<dialectic>
You know what, I should just not do that
Xach has quit [Ping timeout: 245 seconds]
<stacksmith>
Damn, how do you avoid emojis here? I couldn't google anything at all for that...
<stacksmith>
Although I can appreciate cffi::parse-type.
<stacksmith>
aeth: so instead of (foo bar), to differentiate accessors for different instances and types, I have per-instance prefixes. So if you are creating two points, you can set prefixes to "P1-" and "P2-" and it will bind p1-x and p2-x. You can also manually bind symbols of your choice to any slot, and use any name you please.
abhixec has quit [Quit: leaving]
dialectic has quit [Ping timeout: 258 seconds]
Lycurgus has joined #lisp
khisanth_ has quit [Ping timeout: 245 seconds]
dacoda has joined #lisp
keep_learning_M has joined #lisp
khisanth_ has joined #lisp
kushal has quit [Ping timeout: 260 seconds]
dialectic has joined #lisp
kushal has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<stacksmith>
aeth: makomo: I made a repo for with-c at http://github.com/stacksmith/cl-with-c I have not exhaustively tested it, but it seems pretty close to good.
dacoda has quit [Ping timeout: 245 seconds]
akoana has left #lisp ["Leaving"]
_whitelogger has joined #lisp
<makomo>
stacksmith: cool, thanks :)
dale has joined #lisp
nanoz has joined #lisp
dddddd has quit [Remote host closed the connection]
v88m has joined #lisp
karlosz_ has joined #lisp
ym555_ has joined #lisp
linli has joined #lisp
ym555 has quit [Ping timeout: 246 seconds]
linli has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
linli has joined #lisp
dialectic has quit [Ping timeout: 245 seconds]
linli has quit [Remote host closed the connection]
linli has joined #lisp
nanoz has quit [Read error: Connection timed out]
<beach>
Good morning everyone!
nanoz has joined #lisp
linli has quit [Read error: Connection reset by peer]
Bike has quit [Quit: Lost terminal]
dialectic has joined #lisp
vlatkoB has joined #lisp
torbo has quit [Remote host closed the connection]
<dialectic>
I know this is not necessarily that popular in this community because most people use paredit but I have been thoroughly enjoying parinfer
koenig has quit [Ping timeout: 264 seconds]
koenig has joined #lisp
<dialectic>
However, one minor irritation, which is my fault - sometimes when I refactor, I am still in indent-mode, and I didn't have the good-sense to switch to paren-mode, and I accidentally change the indentation in certain places, which rebalances parens and gives me a nasty bug
<dialectic>
Just venting.
<no-defun-allowed>
I mean, I'd rather work on structure than dealing with either parens or whitespace. I think paredit is closer to that.
<dialectic>
I never could get used to paredit. Felt too much like learning to play an instrument. I'm sure you get the muscle memory for it eventually.
<dialectic>
parinfer is definitely better for "beginners"
<no-defun-allowed>
And I wonder how parinfer would work for Lisp, rather than Clojure. You'll typically want two left parens at the start of a let binding list, for example.
Oladon has quit [Ping timeout: 248 seconds]
<dialectic>
I think I know what you're getting at. I type (let ((b1 f1), and then on the next line I can hit tab twice to get to the inside of the bindings list.
<dialectic>
In other words, it's knows where the lists are and has "smart tabbing".
<beach>
no-defun-allowed: There is a good use case for (LET (VAR1 ...) ...)
<no-defun-allowed>
That's why I said "typically".
<beach>
I see.
<no-defun-allowed>
You use bare symbols when you are going to set the initial value later, but often I'd say I already have an initial value.
<beach>
Yes, that's the most frequent case
froggey has quit [Ping timeout: 258 seconds]
<equwal>
Is there something like 'symbol-function' and 'boundp' for the macro namespace?
<equwal>
I've seen that before. I find the name "macro-function" a bit unintuitive.
nanoz has quit [Ping timeout: 258 seconds]
<equwal>
Neat that it is in fact a function.
<beach>
Why is that?
<equwal>
I didn't expect macros to be a function.
<equwal>
I suppose it makes sense though, since it is just shifting around a list.
<beach>
A macro is a function that, when applied to a form and an environment, returns a new form.
<beach>
Look in the glossary under "macro function".
<dialectic>
equwal: Are you using any books? Like Practical Common Lisp or Common Lisp the Language
<equwal>
I've read PCL, though I don't have a copy handy. Perhaps I should go find a PDF right now.
<dialectic>
It's free online.
<equwal>
Of course it is. I've just bookmarked it, I'll look there the next time I have a trivial question, thanks.
<dialectic>
"Is there an analogous function that does for macros what fboundp does for symbols" wasn't really trivial and I doubt MACRO-FUNCTION even shows up in PCL. :P
<equwal>
well...I don't remember it :P
<dialectic>
CLtL2 does a better job at giving you a succinct tour of the whole language. And this will sound wacky but I have willed myself to sit down over two weekends and read straight through the hyperspec chapters and I found that to be quite illuminating. Kent Pitman is an excellent communicator.
<dialectic>
I actually asked "are you using a book?" because of your earlier question about the THE special form.
krkini is now known as kini
karlosz_ has left #lisp [#lisp]
anewuser has quit [Ping timeout: 244 seconds]
<stacksmith>
dialectic: Let Over Lambda is one of my favorite sources of inspiration. And On Lisp, of course.
<beach>
Godel[m]: You can communicate with minion using private messages.
<Godel[m]>
Thanks.
<no-defun-allowed>
Göd.el: You can be more polite to minion too.
<no-defun-allowed>
minion: Sorry Göd.el doesn't say their pleases and thank-yous.
<minion>
you should be sorry
<Godel[m]>
I'm having trouble with registration. Neither am I able to login into my (not registered via minion's link) account, nor can I register under the same email or username anymore.
<Godel[m]>
I was polite the last time I asked.
<Godel[m]>
Didn't work.
<no-defun-allowed>
minion: Can we have registration please?
<minion>
does torturing a poor bot with things beyond its comprehension please you?
<Godel[m]>
No, I meant, the registration didn't (finally) work out :)
<Godel[m]>
My unregistered account has been blocked, is this the right place to complain about that?
<aeth>
is that because you had the link in here instead of private messaging the bot so someone else accessed it too?
<aeth>
idk how that bot thing works
<no-defun-allowed>
Also struggling to get 2FA working again.
Arcaelyx has quit [Quit: Arcaelyx]
<Godel[m]>
aeth: No, I registered, then it asked me to ask minion for a link. I followed the link and found that somebody (me) had registered an account under my username and that username has been blocked now.
Inline has quit [Quit: Leaving]
CloseToZero has joined #lisp
Ricchi has quit [Remote host closed the connection]
keep_learning_M has quit [Ping timeout: 245 seconds]
keep_learning_M has joined #lisp
kdas_ is now known as kushal
varjag has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
karswell has quit [Remote host closed the connection]
cosimone has joined #lisp
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
hhdave has joined #lisp
Necktwi has quit [Ping timeout: 272 seconds]
<LdBeth>
#'no-defun-allowed: what’s the registration for?
<no-defun-allowed>
LdBeth: for gitlab.common-lisp.net
Bormotuhin has joined #lisp
<LdBeth>
I registered earlier, via my GitHub account, but no longer works.
amerlyq has joined #lisp
Bormotuhin has quit [Remote host closed the connection]
Bormotuhin has joined #lisp
Necktwi has joined #lisp
atgreen has quit [Ping timeout: 252 seconds]
keep_learning_M has quit [Ping timeout: 258 seconds]
keep_learning_M has joined #lisp
Bormotuhin has quit [Remote host closed the connection]
v0|d has quit [Remote host closed the connection]
Folkol has quit [Ping timeout: 246 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
Necktwi has quit [Ping timeout: 244 seconds]
Folkol has joined #lisp
atgreen has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
m00natic has joined #lisp
Bormotuhin has joined #lisp
Bormotuhin has quit [Remote host closed the connection]
keep_learning has joined #lisp
torlakur has joined #lisp
chens has joined #lisp
elfmacs has quit [Ping timeout: 268 seconds]
atgreen_ has joined #lisp
random-nick has joined #lisp
scymtym has quit [Ping timeout: 252 seconds]
Folkol has quit [Ping timeout: 245 seconds]
Folkol has joined #lisp
atgreen has quit [Ping timeout: 268 seconds]
lavaflow has quit [Ping timeout: 272 seconds]
szmer has joined #lisp
q3d has joined #lisp
q3d has quit [Client Quit]
cosimone has quit [Ping timeout: 250 seconds]
cosimone has joined #lisp
xkapastel has joined #lisp
chens has quit [Remote host closed the connection]
jmercouris has joined #lisp
makomo has joined #lisp
atgreen_ has quit [Ping timeout: 276 seconds]
Necktwi has joined #lisp
<flip214>
Godel[m]: which username?
ym555_ has quit [Ping timeout: 246 seconds]
elfmacs has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
<carmack>
Hi! Imagine I have some kind of associative array that is essentially configuration data. Is there a convenient associative array in Common Lisp that is easy to work with?
<ck_>
? weren't you asking about looking up things in alists the other day
<ck_>
there's also hash-table, maybe more the speed you want
<dim>
associative array sound a lot like hash-table to me too
<White_Flame>
if configuration data is intended to be literal human written data, then alists or keyword-based plists are generally fine
<White_Flame>
hashtables have no literal format in plain CL
<White_Flame>
*literal representation
<carmack>
I know about the hash tables, but is there anything else?
<xristos>
carmack: alists and plists
<jackdaniel>
alists are lists in a form ((key . value) (key . value) …)
<jackdaniel>
plists are lists in a form (:key value :key value …)
<jackdaniel>
CL has functions to work on such structures
<xristos>
use prin1 to serialize them and read to read them back
<White_Flame>
you can use (destructuring-bind (&key ...) plist ...) to extract all the plist keys at once
<carmack>
well and everytime if i want get some i need use (assoc `key` list)?
<xristos>
or write your own macro
<carmack>
sure macro ;)
<White_Flame>
or convert it into a hashtable after you read it
<White_Flame>
alexandria has routines to convert to/from hashtables & a|p-lists
<carmack>
because (gethash &key ht) look so bad
<carmack>
why i can't just like (ht:key
TMA has quit [Ping timeout: 258 seconds]
<jackdaniel>
this syntax is reserved for package:symbol access)
<jackdaniel>
now (define-hash-table foobar ()); (foobar :xxx)
<jackdaniel>
writing setf function is left as an excercise for the reader
heisig has joined #lisp
<carmack>
jackdaniel: ok thx
TMA has joined #lisp
<jackdaniel>
if CL were Lisp-1 one coulde define a funcallable class and you could put the instance as the first atom in the application
<jackdaniel>
but nvm that
<jackdaniel>
you still could define such class and work with (funcall ht :key). that said using gethash will be easier for the eyes to anyone who reads your code
<jackdaniel>
so I'd suggest sticking to it (of course it is your program, so you are free to do whatever you want)
<carmack>
I'd like to read this code
<carmack>
Only I will read this code.
dddddd has joined #lisp
<jackdaniel>
another way to tackle the issue is defining a generic function ref: (defgeneric ref (elt &rest accessors)) which has specialization for arrays, lists, simple vectors, hash tables and other arbitrary objects
<carmack>
I saw an example where a hash table is created using #H(...), but I have this causes mistake.
<jackdaniel>
and then you'd be able to specialize it on your own object as well without chaning the call semantics
<dim>
cl21 has reader macros for hash-table and some utilities such as the generic function above
v88m has quit [Ping timeout: 244 seconds]
<carmack>
dim: where i can read cheat sheet?
<carmack>
dim: these macro?
<dim>
http://cl21.org ; though I don't like that very much, and I think most people here don't either
<heisig>
I wonder why that issue with hash table literals comes up so often. I never had any need for it myself, and I'm using CL a lot.
<heisig>
And, should I ever need it, #.(alexandria:alist-hash-table '((foo . 5) (bar . 9))) doesn't seem so bad.
<no-defun-allowed>
oh yeah, cl21 is also cl21 so jackdaniel's advice is probably less controversial
<jackdaniel>
to be honest I always stop for a second or two wondering what is the argument order
<carmack>
dim: i already read ANSI Common Lisp
notzmv has joined #lisp
<jackdaniel>
(in gethash)
<no-defun-allowed>
It's one of those things where if you really need it, you really need it, but if you don't, you don't notice.
<dim>
that's good, now read Norvig's advice for CL code style, you will like it! it answers many questions you seem like you would have at this point
<no-defun-allowed>
*... if you need it, you really need it ...
<no-defun-allowed>
I can't remember why I wanted literal-ish hash tables once, but I know I did for one project.
<carmack>
dim: i mean i already reading book
<carmack>
dim: sorry bad english
<shrdlu68>
no-defun-allowed: What type were your keys?
<no-defun-allowed>
I really don't remember.
<jackdaniel>
subtype of T for sure ,)
<no-defun-allowed>
It was #.(aref (make-array 1 :element-type nil) 0) from memory.
<shrdlu68>
I'm experiencing a lot of "popular language" envy these days for CL :(
<no-defun-allowed>
What do you mean by that?
<jackdaniel>
no-defun-allowed: can't be, such arrays have maximum length 0
<shrdlu68>
Seems everyone is blogging about Rust and Golang.
<no-defun-allowed>
jackdaniel: Really? Then again, an array with element-type NIL isn't much use.
<pjb>
heisig: I guess, from other programming languages that have hash-table literals or syntax to build hash-table. The distinction is not always clear!
<no-defun-allowed>
Of course they are. Computer science is a pop culture. But where does CL tie into that?
<jackdaniel>
no-defun-allowed: well, even nil is not of type nil, it is an empty set of types
<shrdlu68>
I wish it were more popular. Silly sentiment, really.
<surrounder>
because populair is better?
<pjb>
Just write popular programs in it!
<jackdaniel>
so you can't have anything in such array, hence the only possible size is 0
<no-defun-allowed>
Yep, gotta love bottom types, jackdaniel.
<no-defun-allowed>
That's true. Good point.
<heisig>
no-defun-allowed: CL is like Jazz. There aren't so many fans, but it has some of the best musicians :)
<no-defun-allowed>
heisig: I agree.
<jackdaniel>
and, as like jazz, it ain't dead, it just smells funny ^_^
<ck_>
I prefer that to the "Quick, let's code everything in ReAngular! It's super easy all you need to do is ..." alternative
<carmack>
Does anyone here have a job related to CL programming?
<Godel[m]>
Improvisers...
<dim>
I think we should work on infrastructure level programs, such as proxies or web API things, something powerful and dynamic where CL would shine and be fast and people would love it...
<no-defun-allowed>
"The CL Is The Ultimate Solution"
<heisig>
jackdaniel: About the array of type NIL - I am pretty sure that they can have any size. It is just that you can't access the elements.
<jackdaniel>
carmack: yes
<carmack>
jackdaniel: What's your work experience?
<heisig>
Something like (length (make-array 9 :element-type 'nil)) is well defined.
<jackdaniel>
heisig: I think you are wrong, but I'm not eager too look into the spec for it
<jackdaniel>
because array stores something and it can't store nothing
jmercouris has joined #lisp
<jackdaniel>
carmack: I do CL consultancy and maintain free software. I don't think this is a place to boost about it though.
<heisig>
jackdaniel: Yes, let's not discuss this absolutely pointless data structure.
<no-defun-allowed>
I currently have Quicklisp set up to play Spider of Destiny whenever I load hunchentoot for some reason. It was funny for a week I guess.
* jackdaniel
looks at the clip right now, it is funny indeed
<no-defun-allowed>
It may be helpful to note that Hunchentoot is the spider referenced by the song's title.
elinow has joined #lisp
<jmercouris>
It may be helpful to note that Hunchentoot is incorrect German
<no-defun-allowed>
But we were talking about literal hash tables or something? If someone writes a reader macro, my only real demand is that it plays nicely with backquote, so I could write `#h((foo ,foo)).
elinow has quit [Remote host closed the connection]
<ck_>
jmercouris: that's supposed to be german?
elinow has joined #lisp
<jmercouris>
Its pseudo German
<jmercouris>
It is really supposed to be Huenchen which means little chicken
<ck_>
Huehnchen, you mean? ah.
<jmercouris>
and of course "toot" for fart, chicken fart or something
<jmercouris>
Yes, I know where Edi Weitz named his programs, it doesn't make it any more correct German
<jackdaniel>
it is a story of a space-girl known as Drakma :-)
<jmercouris>
and it bothers me every single time I see it
<jackdaniel>
what makes you think the name is not made up but rather a mispelled german word?
<ck_>
I never even made that connection.
<jmercouris>
Ah yes, just like the english word Fuk, which is of course not made up, just sounds and looks exactly like another similar word
<jmercouris>
it means to grace another with deep love
<jmercouris>
so if you tell someone to go "Fuk" themselves, you are wishing them very well
<ck_>
well, I'm very sorry you're bothered by the name of some software
<no-defun-allowed>
Well, good luck tracing the etymology of the name Hunchentoot. Good night everyone.
<jackdaniel>
to "Fuk" in Polish means to blab
<jmercouris>
that's hilarious :D
<jackdaniel>
nie fucz, nie fukaj
<ck_>
'infart' in swedish means driveway! woah!
<jackdaniel>
neverless it is offtopic, so I'll disengage
<no-defun-allowed>
Oh, in Greek, φακο means torch (or something like that, Greek school didn't grab my attention), yet it sounds similiar to something you would tell someone you don't like to do.
<no-defun-allowed>
*φακός
<jmercouris>
no it doesn't at all, I speak Greek and they sound very distinctly different to me
<no-defun-allowed>
It did when I was eight and I learnt what it was called.
<no-defun-allowed>
Anyways, have fun discussing how a fictional giant spider got named, how bottom-typed arrays work or something like that. Night.
<ck_>
nn, no-defun-allowed
pfdietz has joined #lisp
LiamH has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
milanj has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
jmercouris has quit [Ping timeout: 248 seconds]
<schweers>
I have kyotocabinet on disk (think of an on-disk hashtable), which contains data in a binary format. I have a few functions to recreate lisp objects from this store. Is there a simple way to use the debugger on such an object?
<schweers>
I basically want a function which will open this store, retrieve an object from it and point the slime inspector to this objejct. Is this possible?
<shka__>
schweers: do you have some binding to this kyoto cabinet?
frgo_ has joined #lisp
<schweers>
yes. Actually I should have left the kyotocabinet out of this altogether. I have a short function which creates an object from disk. I want to inspect this object.
atgreen_ has joined #lisp
cosimone has joined #lisp
<schweers>
Basically I want to abuse the slime inspector to help me build a data-debugging tool.
<shka__>
schweers: there was something about that in slime manual, give me a second
frgo_ has quit [Remote host closed the connection]
frgo_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
<shka__>
schweers: could you please try (swank:inspect-in-emacs "string") ?
<schweers>
I want to inspect DBM-OBJECT. The problem is, that for some reason this variable is not available in the debugger.
<shka__>
schweers: optimize debug 3
<schweers>
"string" being the variable/object/expression in question?
<schweers>
yeah, I have that already (at least I should)
<shka__>
schweers: "string" being string literal
<shka__>
you can pass any object to it though
<schweers>
YEAH! That did it!
<schweers>
Thank you very much
<shka__>
you are welcome, glad i could help
<schweers>
For future reference, where did you find it?
cosimone has quit [Ping timeout: 252 seconds]
<shka__>
schweers: swank backend.lisp file
<schweers>
k, thanks
Folkol has quit [Ping timeout: 246 seconds]
cosimone has joined #lisp
<shka__>
swank exports useful symbols and has docstings
<shka__>
so it is usable
random-nick has quit [Ping timeout: 272 seconds]
Bike has joined #lisp
frgo has joined #lisp
<shka__>
schweers: this kyoto cabinet thing looks pretty dope though
<schweers>
I’m not sure what you mean?
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
<shka__>
schweers: cl-kyoto-cabinet
<schweers>
I don’t mean what you mean by “looks pretty dope”
<shka__>
how does it work? does it need a server?
<schweers>
no, it’s just a library.
<shka__>
yeah, that's why i like it
<shka__>
it is supposed to be fast, right?
<schweers>
They claim that it is very fast. I can’t really compare it to the alternatives, as I have not worked with any other.
<schweers>
It does some things which are nice, but which I do not (always) need. It takes good care not to lose or corrupt data.
<schweers>
Sometimes I wish I could turn that off.
<schweers>
But overall I guess it is okay.
<shka__>
hm, i should try it
<shka__>
what data types it stores?
<schweers>
In general just byte arrays, but it has convinience functions for strings.
<schweers>
I used to store strings which contained an sexp, now I use CBOR.
<schweers>
both were not exactly my choice.
<shka__>
ok sounds about right
Folkol has joined #lisp
<schweers>
I got some weird behaviour regarding concurrency. One cannot use multiple processes if one of them wants to write, and I got some weird behaviour when using multiple threads. I’m not entirely sure what is supposed to happen, so this could very well be by design.
warweasle has joined #lisp
lucasb has joined #lisp
Lord_of_Life_ has joined #lisp
peterhil has quit [Quit: Must not waste too much time here...]
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
* dmiles
is working on a system in which most all structures and class properties are backed by a database instead of ram
random-nick has joined #lisp
* dmiles
though is using ram to do it as the database is prolog
Inline has joined #lisp
glv has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
sjl_ has joined #lisp
sjl_ has quit [Client Quit]
sjl_ has joined #lisp
hortiel has joined #lisp
<hortiel>
hi
<pjb>
hi
Xach has joined #lisp
<hortiel>
pjb: how is she bang a machine code or binary? I am not talking about UNIX permissions lol....
<hortiel>
it's an interpreter question
<hortiel>
just like py2exe how do I "append " a script to an interpreter to get the compiled binary without using a compiler, the new short hand way of converting an interpreter into a compiler!!
wxie has joined #lisp
notzmv has quit [Ping timeout: 258 seconds]
dale_ has joined #lisp
dale_ is now known as dale
elfmacs has quit [Quit: WeeChat 2.5]
heisig has quit [Ping timeout: 245 seconds]
saravia has joined #lisp
seok has joined #lisp
shrdlu68 has quit [Ping timeout: 246 seconds]
wxie has quit [Quit: wxie]
atgreen_ has quit [Ping timeout: 276 seconds]
anewuser has joined #lisp
notzmv has joined #lisp
notzmv is now known as Guest94202
hortiel has left #lisp ["WeeChat 2.4"]
torlakur has quit [Remote host closed the connection]
schweers has quit [Ping timeout: 252 seconds]
CloseToZero has quit [Ping timeout: 248 seconds]
tsandstr has quit [Ping timeout: 248 seconds]
hackware has joined #lisp
smazga has joined #lisp
dale has quit [Quit: dale]
martylake has joined #lisp
Guest94202 is now known as notzmv
ggole has quit [Quit: Leaving]
ebrasca has joined #lisp
CloseToZero has joined #lisp
glv has quit [Remote host closed the connection]
karlosz_ has joined #lisp
andrei-n has joined #lisp
elinow has quit [Ping timeout: 246 seconds]
martylake has quit [Remote host closed the connection]
martylake has joined #lisp
karswell has joined #lisp
manualcrank has joined #lisp
karlosz_ has quit [Quit: karlosz_]
<ober>
transpiler
m00natic has quit [Remote host closed the connection]
martylake has quit [Read error: Connection reset by peer]
elinow has joined #lisp
karlosz_ has joined #lisp
karlosz_ has quit [Client Quit]
anewuser has quit [Ping timeout: 258 seconds]
hhdave has quit [Quit: hhdave]
<Xach>
ober: please no!
<edgar-rft>
Let's transmutate Lisp code
CloseToZero has quit [Ping timeout: 246 seconds]
karlosz_ has joined #lisp
martylake has joined #lisp
CloseToZero has joined #lisp
atgreen_ has joined #lisp
Arcaelyx has joined #lisp
siarhei has joined #lisp
nanoz has joined #lisp
elinow has quit [Ping timeout: 268 seconds]
v88m has joined #lisp
kdas_ has joined #lisp
frgo has joined #lisp
kushal has quit [Ping timeout: 260 seconds]
kdas_ is now known as kushal
<ebrasca>
Is it ok to use eql for comparing numbers?
<Xach>
ebrasca: yes.
frgo_ has quit [Ping timeout: 268 seconds]
frgo has quit [Ping timeout: 248 seconds]
martylake has quit [Remote host closed the connection]
martylake has joined #lisp
* ebrasca
don't undestand why "eql" for numbers instead of "=".
<Xach>
ebrasca: = is also ok and has different behavior for non-numbers
<Xach>
it depends on the behavior you want in the areas where they differ
<ebrasca>
Can you give some example?
<Xach>
(eql 1 nil) => false
<Xach>
(= 1 nil) => error
<Xach>
(eql 1 1.0) => false
<Xach>
(= 1 1.0) => true
<Xach>
I dare not continue
<ebrasca>
I am sure "(unless (not ..." instead of "(when ..." is not ok.
<ebrasca>
I don't undestand why people use "(when (not ..." instead of "(unless ..." .
<Xach>
ebrasca: i think i have seen and forgotten some rationalization for the practice
<Xach>
nearly any practice can be rationalized
heisig has joined #lisp
Lycurgus has joined #lisp
* ebrasca
don't undestand.
<carmack>
(loop ...) is the macro?
<carmack>
macros
dale has joined #lisp
lavaflow has joined #lisp
<semz>
ebrasca: I sometimes do that because WHEN sounds more natural for optional actions while UNLESS sounds like it is in the ballpark of ASSERT.