Lord_Nightmare has quit [Ping timeout: 255 seconds]
SuperJen has quit [Remote host closed the connection]
SuperJen has joined #lisp
margeas has quit [Ping timeout: 265 seconds]
pierpa_ has quit [Ping timeout: 260 seconds]
Lord_Nightmare has joined #lisp
makomo has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
ldb has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
warweasle has quit [Quit: Leaving]
wxie has joined #lisp
SuperJen has quit [Remote host closed the connection]
kerrhau has quit [Ping timeout: 260 seconds]
SuperJen has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
quazimodo has quit [Ping timeout: 276 seconds]
quazimodo has joined #lisp
SuperJen has quit [Remote host closed the connection]
SuperJen has joined #lisp
jealousmonk has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
megalography has joined #lisp
megalography has left #lisp [#lisp]
fikka has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
fikka has joined #lisp
SuperJen has quit [Remote host closed the connection]
SuperJen has joined #lisp
k-hos has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 256 seconds]
k-hos has joined #lisp
<z3t0>
hey all, last time I was here I was directed to a diagram flowchart for choosing whether to choose an array/vector etc.
<z3t0>
Does anyone have a link?
jcowan has quit [Remote host closed the connection]
jcowan has joined #lisp
SuperJen has quit [Remote host closed the connection]
SuperJen has joined #lisp
FreeBirdLjj has quit [Ping timeout: 264 seconds]
pierpa has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 256 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
milanj has quit [Quit: This computer has gone to sleep]
fikka has quit [Ping timeout: 260 seconds]
hjudt has quit [Ping timeout: 265 seconds]
hjudt has joined #lisp
Kevslinger has joined #lisp
fisxoj has joined #lisp
quazimodo has joined #lisp
d4ryus1 has joined #lisp
fikka has joined #lisp
d4ryus has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 264 seconds]
quazimodo has joined #lisp
semz has quit [Ping timeout: 265 seconds]
Fare has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
EvW1 has joined #lisp
jcowan_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 265 seconds]
jcowan has quit [Ping timeout: 260 seconds]
sucks has joined #lisp
Fare has joined #lisp
Cymew has joined #lisp
EvW1 has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
quazimodo has joined #lisp
jcowan has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Pixel_Outlaw has joined #lisp
Cymew has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
jcowan_ has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
Cymew has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
<beach>
Good morning everyone!
jcowan has quit [Read error: Connection reset by peer]
quazimodo has quit [Ping timeout: 260 seconds]
<loke>
Hello beach!~
jcowan has joined #lisp
<loke>
Early today?
<beach>
Yes, early sleep last night.
cmecca has quit [Ping timeout: 240 seconds]
<loke>
When did you actually go to sleep?
<beach>
I forget, 21:30 maybe.
<loke>
That's when my kids go to sleep. And they get up at... hmm... before 6
<loke>
5:40?
<loke>
No wayt
<beach>
With age, people need less sleep.
<loke>
Really? I'm still waiting for that to happen :-)
<loke>
If the alarm doesn't ring, I sleep until 11.
<beach>
It's statistical. Individual differences are greater.
<loke>
Back when I was younger, I used to go to sleep at 3 and wake up at 7
<loke>
So I guess it's opposite for me. :-)
<beach>
You are different in many other respects too. :)
Cymew has quit [Ping timeout: 265 seconds]
<jcowan>
beach: My experience (approaching 60) is that I don't *need* less sleep, I just *get* less sleep
<beach>
jcowan: That might be an orthogonal phenomenon, sure.
<beach>
jcowan: I have been contemplating an immediate float format that uses 62 bits or so.
<jcowan>
Did you see my message about nanboxing? It would make fixnum arithmetic a little more expensive but allow IEEE double floats to be immediately represented.
<jcowan>
(on 64-bit systems)
<beach>
I didn't understand the details.
<Bike>
basically you have all values be double float NaNs instead of doing normal tagging.
<beach>
Oh.
<Bike>
or in addition to normal tagging, i guess.
<jcowan>
The idea is to hide a 48-bit pointer (and all nested spaces such as fixnums etc.) within the 2^52 bits of quiet NaNs
<jcowan>
That limits the fixnum range somewhat
<beach>
I'll consider it.
<jcowan>
And in turn to make IEEE double-floats the Lisp single float format
<beach>
Yes, I think I get it.
<Bike>
I'm not sure I understand that part. like, why bother
<Bike>
you want doubles to be quads?
<beach>
I would have to consider the cost of type checking and fixnum arithmetic.
<beach>
Bike: All non-NaN IEEE double floats are immediates.
<beach>
Bike: The NaN space encodes all other data.
<Bike>
I mean, I don't understand making IEEE doubles being lisp single-float.
sjl has joined #lisp
SuperJen has quit [Read error: Connection reset by peer]
<jcowan>
short float would be IEEE 32-bit float
<jcowan>
No, single float would be the same as double float
SuperJen has joined #lisp
<Bike>
why?
quazimodo has joined #lisp
<jcowan>
Because single-float is the default Lisp format
<Bike>
oh.
<jcowan>
it's for good reason that almost all languages now default to (IEEE) doubles.
<beach>
jcowan: Current tagging schemes make fixnum addition and subtraction into a single instruction.
<beach>
I would need to understand how that cost would change.
sjl has quit [Ping timeout: 260 seconds]
<jcowan>
Unfortunately I can't help you with that; I was last concerned with assembly language in PDP-11 days.
<beach>
I fear NaN boxing would make fixnum arithmetic prohibitively expensive.
dieggsy has joined #lisp
<Bike>
not that i'm not also concerned, but i do wonder. the way sicl does fixnum arithemtic now it always involves a branch anyway
<beach>
That's because of the overflow test.
<beach>
Can't do without that I would think.
<Bike>
and i mean, that'll probably be slower than a mere arithmetic operation like masking, right?
<beach>
Sure, if no overflow is possible, things are faster.
dddddd has quit [Remote host closed the connection]
<beach>
But if you want to do correct Common Lisp arithmetic, you have to test for overflow.
<beach>
... unless you can prove it won't happen, of course.
FreeBirdLjj has quit [Ping timeout: 260 seconds]
<Bike>
What I'm saying is that the additional cost from the nanboxing may be tiny compared to the cost of the overflow check, so using nanboxing might not be so bad.
fikka has joined #lisp
<beach>
Wait, am I missing something then?
<Bike>
I'm not talking about whether the overflow check is required.
<beach>
Oh.
<Bike>
I'm saying, if the overflow check is in there, it seems like it would be more expensive than the additional cost due to nanboxing.
<beach>
I am confused.
verisimilitude has joined #lisp
<beach>
Bike: How would fixnum arithmetic be performed with NaN boxing?
fikka has quit [Ping timeout: 240 seconds]
<jcowan>
Carefully. :-)
<Bike>
I think you would have the exponent bits all be 1 for the NaN, so the fixnum is in the low 52 bits, maybe with the low two tag. For unsigned fixnums you could machine add them, and then check... some bit for overflow, and then maybe mask it so it's still a proper NaN.
<jcowan>
Just so
<beach>
Bike: And how is the overflow detected?
sendai___ has joined #lisp
<Bike>
Well... let's say the highest bit is still sign. Then if there's an overflow, it will carry over into the exponent and then into the sign, so maybe it will trip the machine overflow flag normally.
<Bike>
I'm not actually sure when the machine overflow flag is tripped
<beach>
When the result of the addition/subtraction can not be represented in 64 bits.
<Bike>
you'd only have like 48 bits
<beach>
So if the upper bits are 0 (not counting the sign) then the overflow would never be tripped.
<Bike>
but the upper bits are 1 because that's what makes it a NaN.
<beach>
So you would have to test for overflow yourself.
<beach>
Oh, sorry.
<beach>
I see.
<Bike>
i'm new to this too, honestly. i'd have to look up a reference that probably exists.
<Bike>
i mean i first heard of this idea at least a year ago, but i didn't look into it
<beach>
But then, the representation for positive fixnums is wrong.
<Bike>
Wrong?
<beach>
There would be 1s where there should be 0s.
fikka has joined #lisp
<beach>
I'll look into it.
<rme>
Luajit (and I assume its fork raptorjit) uses a NaN-tagging scheme, IIRC.
<jcowan>
And several JavaScript engines (which do not have fixnums)
<verisimilitude>
This is suggesting implementing FIXNUMs as floats within the safe range?
<Bike>
everything as NaNs, including fixnums.
azimut has quit [Ping timeout: 264 seconds]
<Bike>
well. everything except double floats.
<verisimilitude>
Wouldn't it be more pleasant and more efficient to implement integers seperately?
<Bike>
separately?
<rme>
Oh, right, I can see how that might fit well with JavaScript.
nika has joined #lisp
<verisimilitude>
That is, tell the machine to use integer instructions when only integers are involved.
<Bike>
yeah js only has doubles anyway so they don't care about integers
<beach>
verisimilitude: You can't do it separately if you want every Lisp object to be a word.
<verisimilitude>
Explain.
<rme>
I'm kind of willfully ignorant of JavaScript, I have to admit.
<Bike>
the idea is allowing doubles to be immediates
<verisimilitude>
I don't currently see a reason why you couldn't.
<Bike>
you can't use the low bits as tag or anything, doubles fill the whole 64 bits
<beach>
verisimilitude: Common Lisp is dynamically typed.
<verisimilitude>
No, I understand.
<verisimilitude>
See, what I'd do is simply limit the precision of floats until it was convenient.
<jcowan>
Then you can't use the hardware
<beach>
verisimilitude: That's a really bad idea.
<jcowan>
It's been tried, but just truncating bits for a tag upsets the works
<Bike>
single floats kind of suck
<verisimilitude>
I very rarely ever use floats in Common Lisp, so I'm biased in that respect.
<beach>
verisimilitude: I mean, yes, you can do that, but then you would have your own float format.
<verisimilitude>
Yes.
<verisimilitude>
So, that's always an option.
<Bike>
with no machine arithmetic
<rme>
The good thing about single floats is that it's pretty easy to arrange to make them be iimmediate data on a 64-bit Lisp.
<beach>
verisimilitude: The current suggestion is very different.
<jcowan>
the whole point of inexact numbers is performance
<verisimilitude>
The current suggestion seems to be to do what JavaScript implementations do, with careful checking.
<rme>
But otherwise, yeah, they're kind of lacking.
fikka has quit [Ping timeout: 276 seconds]
<jcowan>
With machine performance *and* no boxing *and* decent precision, floats might be more popular
sendai___ has quit [Quit: ZNC 1.6.5 - http://znc.in]
<Bike>
i mean the other possibility is your compiler's good enough to keep doubles unboxed
<Bike>
though you still have problems at function boundaries
<beach>
My current thinking is that it is rare to do double-float arithmetic on values that are passed as arguments and return values. With so called "aggressive" inlining, my guess is that most such arithmetic would be on arrays or on unboxed lexical variables.
<Bike>
coercing <return value> to T [cost 13]
<jcowan>
Right, which is why V8 does not do nanboxing, though the other JS engines do
<jcowan>
it has excellent type inference
azimut has joined #lisp
rumbler31 has joined #lisp
<beach>
jcowan: Perhaps JavaScript does not have specialized arrays?
<jcowan>
It does now, I believe, but only recently
<beach>
I am asking because that would change the data for a decision about encoding.
<beach>
Like I said, I think most double-float arithmetic in Common Lisp would be on arrays specialized to double float and on unboxed lexical variables.
shka has joined #lisp
<jcowan>
That is the Scheme viewpoint, although not all compilers can do unboxing
verisimilitude has quit [Remote host closed the connection]
<beach>
Ours can.
verisimilitude has joined #lisp
<jcowan>
and therefore their float performance sucks
<beach>
I am thinking operations on images and sound, FFT, etc.
Kundry_Wag has joined #lisp
<beach>
Anyway, since all of SICL is implemented in Common Lisp, the exact representation of things is visible in a very small number of places, I don't think this is a decision that has to be made a priori.
rumbler31 has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
<jcowan>
Indeed.
<beach>
We do many of our optimizations on HIR which is representation neutral.
<beach>
HIR is also where boxing/unboxing is explicit.
damke has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
fisxoj has quit [Quit: fisxoj]
<beach>
In fact, one can even imagine several SICL variants. One could be optimized for double-float arithmetic and another for fixnum arithmetic.
<beach>
Such a thing would be much harder with a system that has representation information spread all over the code base.
schoppenhauer has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
schoppenhauer has joined #lisp
rumbler31 has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
azimut has joined #lisp
azimut has quit [Client Quit]
azimut has joined #lisp
BlueRavenGT has quit [Ping timeout: 265 seconds]
wxie has quit [Remote host closed the connection]
fikka has joined #lisp
verisimilitude has quit [Remote host closed the connection]
verisimilitude has joined #lisp
orivej has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
<beach>
LdBeth: Tell us your plan again?
<beach>
LdBeth: Why would start at such a low level, and why would you build a non-GC system first?
fikka has joined #lisp
Kundry_Wag has joined #lisp
<verisimilitude>
You're also working on an implementation, LdBeth?
sucks has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 265 seconds]
Kundry_Wag has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
nika has quit []
<epony>
What do you mean, "assembler" and "implementation"?
<verisimilitude>
I meant a Common Lisp implementation, if that was directed towards me.
Bike has quit [Quit: Lost terminal]
jealousmonk has quit [Quit: Leaving]
<epony>
Train of thought has halted.
SuperJen has quit [Read error: Connection reset by peer]
Jen has joined #lisp
fikka has joined #lisp
fisxoj has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
sjl has joined #lisp
guicho has joined #lisp
rumbler31 has joined #lisp
fikka has joined #lisp
guicho has quit [Remote host closed the connection]
sjl has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 265 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
<beach>
epony: LdBeth wrote this: <LdBeth> So, my plan is an assembler first, and a non-tradition GC subset of Lisp aims only for high performance, and then layers of Common Lisp for user space applications.
<beach>
epony: And I am wondering what that means in greater detail.
<epony>
yes
dieggsy has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
<beach>
epony: I am worried that LdBeth is planning yet another implementation that is built up from some lower-level code. I have seen how writing such an implementation is very painful, and it results in code that is not very maintainable.
<beach>
epony: I am particularly worried, because there seems to be widespread belief that this is the only way to create a Common Lisp implementation.
<epony>
I think I understand why you are concerned, beach
jack_rabbit has quit [Ping timeout: 276 seconds]
<beach>
Good.
<epony>
I would qualify that down-up approach an exercise in pre-processors for assembler though, with lisp driven something above it.
nmajo has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
jack_rabbit has joined #lisp
wxie has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<beach>
Well, here is why I am worried: At some point, Common Lisp code has to be evaluated. That requires an interpreter or a compiler. A compiler can not be reasonably written in anything other than Common Lisp. So the bottom-up approach seems to call for an interpreter. But then, as we know, interpreters are slow. So then a compiler is needed anyway. And now you have two evaluators.
<epony>
It will be interesting to me for the sake of curiosity if this has any practical realisation, or it is a plan that may be difficult to follow up as you explain.
<beach>
epony: what is "this" in "this has any practical realisation"?
quazimodo has quit [Ping timeout: 260 seconds]
<verisimilitude>
I'm inclined to disagree, beach.
<epony>
The low level approach
<beach>
verisimilitude: Yes, of course.
<verisimilitude>
Wouldn't it be fair to write that only the special operators and some other considerations need be treated specially and everything else to be compiled could be treated in a more general matter?
<verisimilitude>
It's not hard to imagine how to compile nested function calls to machine code.
<beach>
Plus, the bottom-up approach requires a lot of the code to be written in a subset of Common Lisp. Then, the maintainer has to keep track of exactly what subset is allowed in every situation. While it may be possible to do that for someone who is writing the system from scratch, it becomes increasingly hard over time.
<epony>
beach Can it have both a compiler and an interpreter?
<beach>
epony: Sure it can. But now you have two evaluators to maintain. So more maintenance.
<epony>
The subset is a different language then, as it will need translation (re-evaluation).
<beach>
... which is one of the problems with this approach.
<verisimilitude>
Now, I've been intending to compile a list of Common Lisp subsets that would be treated like this, in varying orders of dependence and whatnot, as one of the first steps towards my implementation; when I do, would you want me to point the article out to you, beach?
fikka has joined #lisp
nmajo has joined #lisp
<beach>
verisimilitude: No thanks. I have already decided that I am not willing to work in a subset of Common Lisp which is why SICL is built the way it is.
<LdBeth>
beach: I considered use a subset of languages for system programming rather than a full impl of CL, mainly to avoid GC on real time execution.
<verisimilitude>
I'd put FORMAT and FORMATTER and LOOP into their own packages.
<verisimilitude>
Alright, then.
<epony>
I think the down-up approach is applicable to low level languages, as they have no high level abstractions (which they can do as extensions e.g. libraries).
<beach>
LdBeth: I assume you know there are real-time GCs, right?
<verisimilitude>
It's not out of place to think of Common Lisp as an abstract language that is still capable of behaving low level.
<beach>
verisimilitude: How do you plan to evaluate the first Common Lisp code that needs to be evaluated?
<beach>
Do you have an interpreter written in a lower-level language?
<verisimilitude>
I'd intend to take the compiler only approach.
<epony>
Now, question is GC the capability that limits applicability to virtualised machines or is it a prerequisite for these.
onion has joined #lisp
<beach>
verisimilitude: So you write the compiler in a subset of Common Lisp?
<verisimilitude>
I've not yet compiled the precise subsets.
<LdBeth>
beach: yes, I read that paper about real time programming in Lisp. But a parallel language may also gives benefits such as static type.
<verisimilitude>
If, by the compiler, you mean what turns finalized code into machine code, then perhaps.
<beach>
verisimilitude: Good luck with that.
<verisimilitude>
I'm inclined to believe it would be easier to write it as machine code, at that level of it, though.
<beach>
Write a Common Lisp compiler in machine code? You have got to be kidding.
<verisimilitude>
Thank you.
<verisimilitude>
You misunderstand.
fikka has quit [Ping timeout: 265 seconds]
<verisimilitude>
I mean the final step that traverses the processed list and writes the actual machine code.
<beach>
verisimilitude: You are not answering my question.
<verisimilitude>
The MACROEXPANDer, optimizer, and other higher mechanisms would be written in a subset of Common Lisp.
<beach>
verisimilitude: The lowest level Common Lisp code that is going to execute on top of the lowest level non Common Lisp, how will it be executed?
<epony>
Why would a CL compiler be possible only in CL?
onion is now known as on_ion
<verisimilitude>
It would be compiled and jumped to, beach.
<beach>
verisimilitude: What does the compiler look like that would compile it?
<beach>
epony: It is the only reasonable choice.
<epony>
beach I see.
<beach>
epony: Think it through and you will see.
<verisimilitude>
Before we continue, beach, I do want to point out that I've been giving far more thought to the subsets and the calling convention and other details, so I may not yet have fully consistent ideas of this particular aspect of my planned implementation.
<beach>
epony: Think EVAL-WHEN.
<LdBeth>
epony: you might see Haskell, Go, Rust, Ocaml get a lot of benefits from bootstraping
<epony>
I'm asking for the sake of the conversation and ideas presented.
<beach>
verisimilitude: I suspect that is true. Yet that is THE CRUCIAL consideration.
<verisimilitude>
With that written, the compiler only needs to be able to compile special operators and functions.
<beach>
verisimilitude: No macros?
<verisimilitude>
Getting to that point requires more Common Lisp, to MACROEXPAND and whatnot, but it boils down all the same.
<LdBeth>
verisimilitude: I think what you mean is DSLs for extending CL, such as pattern matching syntax?
<verisimilitude>
When I used ``compiler'' in my second to last message, I meant the lowest part of the compiler that only processed what has already been processed by the higher parts of the compiler, which would need Common Lisp.
<beach>
verisimilitude: I suggest you think hard about how this thing will be bootstrapped. Then you write that down. Then I will read it and give you feedback.
<verisimilitude>
Most of the COMMON-LISP package is easily convenience functions; it's what's not that would need to be implemented in machine code.
<epony>
I suspect the goal is a machine that runs to fulfill the features and capabilities of the language, so a subset is in fact a different language in that sense is a pre-processor for low level languages.
<beach>
verisimilitude: It is not possible for me to glue together the pieces of information you are giving into a coherent whole. I would have to look at a complete description of the bootstrapping process.
<beach>
epony: But why on earth would one subject oneself to the pain of not using things like CLOS?
<epony>
I don't have that answer.
<verisimilitude>
You see, beach, I'm particularly interested in optimizing for space, which is what I would use to differentiate my implementation; I've enjoyed considering a Common Lisp implementation in which the entirety of the COMMON-LISP package is written in a different language that can be made very small. However, this would be bothersome, and so implementing enough of the language to implement the rest and working on an efficient compiler for
<verisimilitude>
that rest is the intent.
<epony>
I'm interested in a machine that has the features of LISP, and this is why I am here.
<verisimilitude>
As an example, beach, and I'm thinking a RISC machine such as MIPS, there's no reason NULL shouldn't boil down to just two instructions, or eight bytes.
<beach>
verisimilitude: I'll comment further when I see your technique for bootstrapping this thing. I have given bootstrapping a lot of thought, and I could not possibly build a Common Lisp system this way. It would be too painful for me, and I don't enough remaining life expectancy to make it work.
orivej has quit [Ping timeout: 240 seconds]
d4ryus1 has quit [Quit: WeeChat 2.1]
<verisimilitude>
Well, I look forward to showing you my hard work, when it's in a state for showing, beach.
<verisimilitude>
Good luck with your SICL.
<beach>
Thanks.
<beach>
verisimilitude: The Cleavir part of SICL is already used for the main compiler of Clasp.
<verisimilitude>
Would you care to read the two instructions I believe NULL necessitates, before moving to a different topic?
<beach>
verisimilitude: NULL is a non-issue.
d4ryus has joined #lisp
<verisimilitude>
The SBCL NULL is 30 bytes on my machine.
zooey has quit [Read error: Connection reset by peer]
kushal has quit [Read error: Connection reset by peer]
<beach>
SBCL doesn't do it very well. But NULL is not tested for very often.
<verisimilitude>
But, alright.
fikka has joined #lisp
d4ryus has quit [Client Quit]
<beach>
Why would you build an entire implementation around a test that is almost never performed?
zooey has joined #lisp
d4ryus has joined #lisp
<beach>
By the way, I think in SBCL, NULL is just a comparison with a constant.
<beach>
I may be wrong, but that was my impression.
<epony>
That would be fruitful to rewrite in low level language directly and spawn a number of such primitives as programs?
kushal has joined #lisp
<beach>
epony: It may be too early in the morning for me, but I am missing the context of your utterances. What is "That" in "That would be fruitful"?
fikka has quit [Ping timeout: 240 seconds]
<LdBeth>
epony: low level can still be achieved with high abstraction.
<verisimilitude>
I'm not, beach; it was just an example.
fourier has joined #lisp
fikka has joined #lisp
<epony>
I think the bottom-up approach ends up in a different family of languages, and the choice of example was suited for them.
fikka has quit [Ping timeout: 276 seconds]
<beach>
verisimilitude: Fine. But again, it would be great to see a more detailed des corruption of your bootstrapping stages. That way I can give you feedback.
dmiles is now known as dmiles[m
dmiles[m is now known as dmiles
GreaseMonkey has quit [Ping timeout: 260 seconds]
cyberlard has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
<beach>
"des corruption"???
<beach>
"description" of course. Must have been flyspell correction.
<beach>
Sorry about that.
cylb has joined #lisp
nmajo has quit [Remote host closed the connection]
greaser|q has joined #lisp
Kundry_Wag has joined #lisp
<beach>
So my point is: If someone wants to write a Common Lisp system, presumably, that person likes Common Lisp as a language (why write such a system otherwise?).
<beach>
Then, why would that person inflict pain on himself or herself by writing that system in some other language?
<beach>
And why would that person add to the pain by not being able to use wonderful tools such as CLOS to write most of the system.
<beach>
Especially since, by using this technique, the person would then also create much more code, and code that is much more difficult to maintain.
<rme>
Ils sont fous, ces Romains.
<beach>
Heh, indeed.
<beach>
rme: You see my point, right?
<verisimilitude>
Well, beach, part of the reason I'd write a Common Lisp implementation in the first place is to demonstrate my tool used in part to write it.
cylb has quit [Ping timeout: 260 seconds]
nmajo has joined #lisp
<beach>
verisimilitude: So in fact, the Common Lisp aspect of the thing not that important?
<verisimilitude>
It's important; I'm simply giving further context.
Kundry_Wag has quit [Ping timeout: 264 seconds]
<verisimilitude>
I'm greatly interested by a small Common Lisp implementation.
<rme>
I do see your point, beach. I think it is a good one.
<verisimilitude>
I figure, beach, that a full Common Lisp could easily fit within half a megabyte, and really far less.
<beach>
rme: Thanks. I also realize it is easier said than done.
<beach>
verisimilitude: Including a compiler? The system would not be very fast then.
<verisimilitude>
Yes; speed is explicitly not a concern.
<verisimilitude>
I seek to optimize in ways that lead space to O(1), at the cost of speed, in fact.
cyberlard has joined #lisp
<verisimilitude>
As an example, it's fair to write that a package contains more symbols than it exports, in general.
<rme>
Back in the late 80's, a bunch of my former coworkers and colleagues worked at a tiny software company called Coral Software. They made a (CLTL1) Common Lisp that ran on a 1MB Macintosh Plus, and they worked really hard to get it that small.
<verisimilitude>
So, rather than having a list containing every symbol in that package, why not only maintain the export list, use list, and leave what remains in a global symbol list or table. You save space, that way, since every symbol has a home package anyway.
<verisimilitude>
I figure, even if each function consumed a kilobyte, that would still be less than a megabyte.
<verisimilitude>
I then figure that the vast majority of the functions could fit in far less than a kilobyte.
wigust has joined #lisp
<verisimilitude>
Being careful, my numbers seem perfectly reasonable to me.
sauvin has joined #lisp
oleo has quit [Quit: Leaving]
<verisimilitude>
Would you write any language implementation in itself, beach, or would you recognize that a language isn't necessarily best suited to describe itself, in addition to efficiently? Is this opinion solely towards Lisps?
<beach>
rme: Impressive. So for a full ANSI that would be extremely hard.
Karl_Dscc has joined #lisp
<beach>
epony: BOCL is partly meant as a provocation.
<beach>
verisimilitude: I don't think your package idea would be conforming.
<beach>
But maybe you don't care.
<verisimilitude>
I've not yet made certain, beach.
<verisimilitude>
I'll check now.
<beach>
What would (symbol-package 'some-existing-package::new-symbol) return, for instance?
SuperJen has joined #lisp
Jen has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
fourier has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
<verisimilitude>
That would be SOME-EXISTING-PACKAGE.
<phoe>
you can't do (symbol-package 'cl::foo) though for example since this is undefined behaviour
<phoe>
'cl::foo will intern symbol FOO in CL at read-time and interning anything in CL is undefined
<phoe>
anything new*
<verisimilitude>
I'm inclined to believe, from what I've checked through the HyperSpec, that this would work, beach.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<verisimilitude>
The basic idea is to make constant the amount of other storage necessary to store a certain type of symbol, by heuristically choosing which is likely to be the most numerous.
<verisimilitude>
It would be entirely reasonable in this scheme to treat the COMMON-LISP package differently, which I've already considered.
<verisimilitude>
The special code for this case would easily be dwarfed by the list or other structure, justifying it.
FreeBirdLjj has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
makomo has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
<verisimilitude>
So, COMMON-LISP would only contain symbols that would be external and so code using this would treat it differently, to save more space.
fikka has joined #lisp
vlatkoB has joined #lisp
sjl has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
red-dot has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
Karl_Dscc has quit [Remote host closed the connection]
fisxoj has quit [Quit: fisxoj]
rumbler31 has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 255 seconds]
jack_rabbit has quit [Ping timeout: 245 seconds]
jack_rabbit has joined #lisp
sukaeto has quit [Ping timeout: 246 seconds]
mflem has quit [Read error: Connection reset by peer]
fikka has joined #lisp
mikecheck has joined #lisp
<phoe>
This should work. There is no requirement that there are any non-external symbols in the CL package.
mikecheck has quit [Ping timeout: 260 seconds]
sukaeto has joined #lisp
<jackdaniel>
ECL's core is written in C, so it may be simply bootstrapped from a C compiler
<jackdaniel>
libecl.so which provides complete Common Lisp implementation when stripped occupies 4MB of memory
Fare has quit [Ping timeout: 240 seconds]
<jackdaniel>
cmp.fas (which provides compiler -> C -> native code) adds additional 1.2MB (without it code is interpreted)
<jackdaniel>
what is noteworthy since libecl is a shared object multitude of applications may use it (so it is not 100 apps x 4MB but rather 100 apps + 4MB in term of space)
milanj has joined #lisp
wxie has quit [Remote host closed the connection]
damke has joined #lisp
sjl has joined #lisp
sjl__ has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
sjl has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
sjl__ has quit [Ping timeout: 276 seconds]
d4ryus has quit [Quit: WeeChat 2.1]
d4ryus has joined #lisp
tokik has quit [Quit: leaving]
tokik has joined #lisp
tokik has left #lisp [#lisp]
Fare has joined #lisp
varjag has joined #lisp
greaser|q has quit [Changing host]
greaser|q has joined #lisp
greaser|q is now known as GreaseMonkey
Kundry_Wag has joined #lisp
schweers has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
shka has quit [Quit: Konversation terminated!]
figurehe4d has joined #lisp
<phoe>
that is already pretty small
Fare has quit [Ping timeout: 260 seconds]
<flip214>
I get "A function with declared result type NIL returned: bordeaux-threads:condition-wait" and the SBCL process stops.
energizer has quit [Ping timeout: 240 seconds]
<phoe>
flip214: stops? as in, completely dies?
<phoe>
what is your SBCL version and BT version?
<phoe>
AFAIR this is an intermittent bug that #sbcl has been hunting for in a while. You could go there and help them debug it.
mingus has quit [Read error: Connection reset by peer]
typose_ has quit [Remote host closed the connection]
loke` has joined #lisp
loke has quit [Remote host closed the connection]
troydm has quit [Ping timeout: 255 seconds]
heisig has joined #lisp
<phoe>
beach: I ran into an issue when defining protools for conditions. They aren't STANDARD-OBJECTs and therefore cannot subclass protocol classes. A possible workaround I think of is to define an equivalent protocol condition type that is instead meant to be subclassed by conditions only.
drunkencoder has joined #lisp
<jackdaniel>
conditions are not objects hence they can't be subclassed
<jackdaniel>
conditions may inherit from other conditions
<jackdaniel>
clhs gives no guarantees that condition object has anything to do with clos
<phoe>
yep, s/subclassed/subtyped/
<jackdaniel>
s/are not objects/are not clos objects/
<Shinmera>
Is there actually any implementation that doesn't implement them using CLOS?
<phoe>
SBCL
<phoe>
I tested many of the other ones, and they have conditions being standard-objects.
glv has joined #lisp
<jackdaniel>
writing correct programs is not the same as writing programs that seem to work most of the time
troydm has joined #lisp
<jackdaniel>
phoe: SBCL uses CLOS to implement conditions (but they come from condition-class hierarchy)
<Shinmera>
jackdaniel: I'm asking because 1) conditions not being under CLOS is in my opinion an oversight of the spec 2) I am curious what implementations do because of 1)
<phoe>
Shinmera: not an oversight
<Shinmera>
Fine, let's call it unfortunate then.
<jackdaniel>
Shinmera: I can imagine hardware having support for condition handling
<phoe>
X3J13 thought that some kind/subset of CL could be delivered without CLOS, and they nonetheless wanted to keep conditions in even if CLOS is out
<Shinmera>
phoe: That wouldn't be CL though, so that's irrelevant.
<jackdaniel>
then conditions could be implemented in terms of this hardware primitives
<Shinmera>
jackdaniel: That doesn't answer my question.
<jackdaniel>
well, it partially does – it may be a reason conditions are not defined as being clos objects.
<Shinmera>
It does not. My question is what current implementations do.
<Shinmera>
I don't care what the spec says in this case. I want a case-study.
<jackdaniel>
oh, so when you do it please share your insights
<phoe>
Shinmera: SBCL wants to have conditions early in its build phase, earlier than it builds its PCL - that is a major issue that I have identified
<jackdaniel>
ECL has conditions before PCL is even loaded, so in principle it supports non-clos conditions (as well as clos ones which are prevalent)
<phoe>
hm
<Shinmera>
phoe: That's fine, but as long as they are tied into CLOS once we hit user-land it doesn't really matter.
dmiles has quit [Ping timeout: 260 seconds]
<phoe>
Shinmera: so what do we do? Write a set of tests for verifying if conditions are standard-objects and all associated functionality, write a CDR that holds the same assertions as the test suite, run the tests on all implementations and then try to hammer the impls until the tests pass?
<phoe>
since that's what I think it would take to have it implemented.
_cosmonaut_ has joined #lisp
<Shinmera>
Well first survey what implementations do -- record the type, class, and potentially metaclass of CONDITION.
<jackdaniel>
phoe: what you propose is writing CDR to make incorrect programms magically correct?
<Shinmera>
Once we have that info we can determine whether it's possible to paper-over or whether implementations actually would need change.
<jackdaniel>
shouldn't it be the other way around?
<phoe>
jackdaniel: what I propose is extending the language via a CDR in the same way some implementations already extend it
loke has joined #lisp
dorothyw has joined #lisp
<Shinmera>
Conditions being under CLOS would be an extension in the same way that extensible sequences are.
<jackdaniel>
I think it is not an extension but rather implementation detail. maybe I've missed the part of *any* implementation manual about "extension" making conditions clos objects
loke` has quit [Remote host closed the connection]
dmiles has joined #lisp
<phoe>
while I understand that X3J13 did not find it meaningful to make conditions standard-objects back then (reading the notes, I assume backward compatibility with previous lisps) , I find it meaningful nowadays to do that nonetheless
fikka has quit [Ping timeout: 240 seconds]
<Shinmera>
phoe: From reading what you linked it seemed to me that they pretty heavily favoured making it CLOS, but then didn't have time to finalise the details of it.
<phoe>
Shinmera: I need to read it again when I'm not at work. I didn't get that impression when I read it.
eschatologist has quit [Ping timeout: 276 seconds]
myrkraverk has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
dorothyw is now known as johnnymacs
<beach>
phoe: Sounds good.
fikka has quit [Ping timeout: 276 seconds]
DataLinkDroid has quit [Quit: Ex-Chat]
<phoe>
Shinmera: I actually did a thing and things seem to "somewhat" work for the little bit of testing I have done so far. This thing is (defmethod sb-mop::validate-superclass ((class sb-mop::standard-class) (superclass sb-pcl::condition-class)) t)
<phoe>
And now I can (defclass foo (standard-object condition) ())
runejuhl has joined #lisp
hhdave has joined #lisp
* Shinmera
raises an eyebrow
eschatologist has joined #lisp
<phoe>
that is some SBCL hackery that I'm doing now
<beach>
I don't think it's conforming.
<phoe>
beach: of course it's not.
<beach>
Just making sure you know.
<phoe>
The standard no longer helps me here, yes. (:
pagnol has joined #lisp
fikka has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
<Xof>
phoe: you might have some difficulty getting slot locations right for such a hybrid object
<phoe>
Xof: I actually don't think I want to pursue this thing since it's not exactly that I would like.
fikka has quit [Ping timeout: 264 seconds]
dddddd has joined #lisp
kdridi has joined #lisp
<phoe>
Instead of cross-breeding standard-class and condition by means of objects that subclass both, I wonder if it would be possible to make condition a subclass of standard-object.
<phoe>
And diving into SBCL code, this will in no way be trivial.
kdridi has quit [Remote host closed the connection]
<Xof>
indeed
kdridi has joined #lisp
<Xof>
it's not completely impossible, but: is the effort worth it?
fikka has joined #lisp
kdridi has quit [Ping timeout: 260 seconds]
mn3m has joined #lisp
<phoe>
Xof: the ability to drive conditions via CLOS and MOP, even partially, sounds worth it in my opinion
kdridi has joined #lisp
nowhere_man has joined #lisp
eschatologist has quit [Ping timeout: 264 seconds]
sukaeto has quit [Ping timeout: 264 seconds]
cyberlard has quit [Ping timeout: 260 seconds]
sukaeto has joined #lisp
kdridi has quit []
myrkraverk has joined #lisp
cyberlard has joined #lisp
random-nick has joined #lisp
inoperable has quit [Quit: ZNC 1.6.6 - http://znc.in]
inoperable has joined #lisp
<Xof>
what does that mean?
eschatologist has joined #lisp
<phoe>
I hit a wall today because I can't make constructors for conditions that work out-of-the-box with the stock #'make-condition
<phoe>
where I'd normally write (defmethod initialize-instance :after ...) for standard-objects
* Shinmera
remembers doing something about that recently but can't recall where
<phoe>
and workarounds like (:shadowing-import-from :my-package #:make-condition) doesn't work universally
kerrhau has quit [Ping timeout: 260 seconds]
cmecca has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
cmecca is now known as Guest7212
wxie has joined #lisp
python476 has joined #lisp
Guest7212 has quit [Ping timeout: 255 seconds]
<Xof>
Hm.
Guest7212 has joined #lisp
wigust- has joined #lisp
wigust has quit [Ping timeout: 256 seconds]
margeas has joined #lisp
siraben has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
davsebamse has quit [Ping timeout: 256 seconds]
<wxie>
，test
<wxie>
,test
milanj has quit [Quit: This computer has gone to sleep]
mbrock has quit [Disconnected by services]
fikka has joined #lisp
DVSSA has quit [Ping timeout: 245 seconds]
damke_ has joined #lisp
pyericz has joined #lisp
damke has quit [Ping timeout: 264 seconds]
pyericz has quit [Client Quit]
wxie has quit [Quit: Bye.]
milanj has joined #lisp
krasnal has joined #lisp
mingus` has joined #lisp
mingus has quit [Ping timeout: 260 seconds]
mingus`` has joined #lisp
tessier_ has quit [Ping timeout: 255 seconds]
tessier has joined #lisp
mingus` has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
knicklux has quit [Quit: Leaving]
tessier has quit [Remote host closed the connection]
tessier has joined #lisp
Bike has joined #lisp
mingus`` has quit [Remote host closed the connection]
<phoe>
TIL I can do (defmethod initialize-instance :after ((warning style-warning) &key) (print "boo"))
<phoe>
and this works on sbcl ccl ecl clisp abcl
<Bike>
why wouldn't it
<Bike>
oh, you mean because conditions are in the separate hierarchy
<phoe>
yes
Fare has joined #lisp
sjl__ has joined #lisp
<Bike>
there's not a lot of reason to not make conditions basically standard objects, so
mingus has joined #lisp
pyericz has joined #lisp
sjl__ has quit [Ping timeout: 268 seconds]
<Shinmera>
phoe: You can but, if I remember correctly, initialize-instance is not always called.
<Bike>
on sbcl make-condition doesn't go through the initialization methods, it looks like
<phoe>
...well, shit
<phoe>
that's correct, make-instance would need to be called by make-condition
<phoe>
and I can't force not-my code to use make-instance instead of make-condition.
DVSSA has joined #lisp
cylb has joined #lisp
DVSSA has quit [Ping timeout: 264 seconds]
pierpa has left #lisp [#lisp]
pierpa has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
<jackdaniel>
that is not a correct way of "catching" style warnings either way
<jackdaniel>
because someone could create a condition
<jackdaniel>
and signal it multiple times
<jackdaniel>
you want to handle these with handler-bind
<phoe>
I don't want a constructor to catch anything, I want a constructor to do things whenever a my-condition is instantiated
fikka has joined #lisp
Oberon4278 has quit [Ping timeout: 264 seconds]
Oberon4278 has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Guest7212 has joined #lisp
Kundry_Wag has joined #lisp
jcowan_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
jcowan has quit [Ping timeout: 264 seconds]
pyericz has quit [Quit: This computer has gone to sleep]
Achylles has joined #lisp
giraffe has quit [Remote host closed the connection]
itruslove has quit [Remote host closed the connection]
davsebamse has joined #lisp
xaotuk has quit [Quit: WeeChat 2.0.1]
quazimodo has quit [Ping timeout: 240 seconds]
Bike is now known as Bicyclidine
quazimodo has joined #lisp
DVSSA has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
DVSSA has quit [Ping timeout: 260 seconds]
damke has joined #lisp
<dlowe>
I kind of don't get why conditions are in a separate hierarchy anyway.
Kevslinger has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
<phoe>
dlowe: we discussed about that a tiny bit up above.
<dlowe>
so much effort to scroll back...
oleo has joined #lisp
<dlowe>
okay, yeah, that sounds believable.
<oleo>
evening
EvW has quit [Ping timeout: 260 seconds]
LiamH has joined #lisp
EvW1 has joined #lisp
warweasle has joined #lisp
Kundry_Wag has joined #lisp
<oleo>
why is movitz.pdf forbidden ?
<oleo>
wth
elderK has joined #lisp
elderK has quit [Changing host]
elderK has joined #lisp
<elderK>
Hey guys.
<elderK>
After a rather horrible mistake, I am here pondering stuff.
<dlowe>
how horrible?
<elderK>
I've been working on a tool to help me play with grammars. I spent my mid-semester break making several iterations of said tool. I just finished it. It let you compute the first/follow sets for an arbitrary grammar it read from stdin. It also allowed you to produce an LL(1) parse table, if possible, for said grammar. It was written in C++.
<elderK>
I just erased it all thanks to a space before a wildcard.
<elderK>
So, pretty horrible.
<elderK>
I *just* got it to the point where I was ready to call it done, too.
<elderK>
Of course, I had no commits yet. Since, it would have been the initial.
<elderK>
ANYWAY.
<elderK>
I will have to rewrite it some time in the future. As, it would have been a useful tool for me to have.
<dlowe>
no snapshots?
<elderK>
Except I have decided: Next time, I will write it in CL.
ghard``` has quit [Read error: Connection reset by peer]
<elderK>
Nope.
<dlowe>
sounds great. The rewrite will be faster anyway.
<elderK>
Yeah.
<elderK>
Still, it kinda hurts.
<elderK>
I really wanted to show a lecturer of mine the finished product. As well as some others.
<dlowe>
I once deleted an entire product at work, so I feel your pain.
<semz>
something about two kinds of people and backups
<elderK>
Normally I treat VCS as backup. If only I had committed my work *as* I was building it, as usual, I could have just reverted.
<elderK>
But I didn't. Because stupidly, I wanted to have a "clean initial import."
<dlowe>
semz: people who sympathize and people who like to assert their superiority?
<phoe>
see both of these for lots of sudo rm -rf fun
<semz>
dlowe: no superiority asserted, i've been there as well once
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
<elderK>
In any case, as much as this sucks, at least I know I can produce such a program. And that's worth something, the know-how too.
<dlowe>
if you use git and emacs, there's a nice git-wip library that will save every edit in a "work in progress" branch
<elderK>
Anyway, I do have a real question for you guys :)
<elderK>
Based on this experience.
<elderK>
I was here a few days ago, asking how to represent a state machine in CL. I was told that tagbody and gotos are a common way to do that in CL.
FreeBirdLjj has quit [Remote host closed the connection]
<elderK>
However, there is an approach I like to use from the C world and I'm not sure if it maps well to CL - and if it does, how.
<dlowe>
really? that sounds terrible.
<elderK>
A TAGBODY and GOs makes me think of switches and gotos. I don't really like that, so usually I have a 2D array. One axis is the current state, the second axis is the input. That let's me transition just by accessing.
<dlowe>
the way you represent a state machine in CL is with state functions that return the next state function
<elderK>
Say, some function f. You call f with some input, f returns the next function.
<dlowe>
(labels ((a () (return b)) (b () (return a)) (loop for state = a then (state))
<elderK>
Rinse, repeat.
<elderK>
Neat :)
<elderK>
Next question! :D
<dlowe>
you can also use multiple values if you want to accumulate results like a parser
<dlowe>
so a function returns a result AND the unparsed sequence AND the next state
<Shinmera>
dlowe: I don't see how that's a significant improvement over tagbody and go
rumbler31 has joined #lisp
<dlowe>
Shinmera: well for one thing you can test each function's behavior in isolation
<phoe>
^
<elderK>
Again from C, let's say for a lexer I'm accepting some input character. Generally, I don't care about characters. I care about entire classes of characters so I have a LUT that translates a given code-point to a given class. Say, "=" to "equals" and all of the numbers and alphabet as "alphanumeric."
<elderK>
I was wondering what the accepted way is to do that in CL.
<Shinmera>
dlowe: Fair enough.
<elderK>
I see people doing that with giant switches in C/C++. I;d like to avoid that in CL if possible.
<dlowe>
also, you have constrained the problem to that of a state machine, whereas there are no such guarantees with tagbody
<elderK>
There's just something weirdly relaxing to me about LUTs.
<phoe>
elderK: read the chracter and dispatch based on it
<dlowe>
elderK: we have nice hash tables in CL
Bike has joined #lisp
EvW1 has quit [Ping timeout: 255 seconds]
<elderK>
phoe: I'm not reading anything here. The functions that do stuff based on input, accept input as an argument.
<elderK>
They don't read themselves.
<dlowe>
there's also a unicode library that handles all that for you
<rumbler31>
cl methods can dispatch on 'eql parameters
<elderK>
I don't think I've made myself clear.
Bronsa has joined #lisp
<elderK>
I'm not interested in the actual "class" of a character. I'm interested in translating a character into something useful to me, in a sense, they become low-level tokens.
<dlowe>
elderK: right. build a hash table keyed on characters
<rumbler31>
elderK: you're asking essentially if there is language support for dispatching on X, where X is some thing
<dlowe>
the value is a symbol denoting the character class
<elderK>
dlowe: Okay. I thought I'd hae to use the hash tables.
<rumbler31>
you can do it with a hash table by hand, or if you can dispatch on eql, you can use generic functions
FreeBirdLjj has joined #lisp
<dlowe>
dispatching on eql sounds considerably more "by hand"
<rumbler31>
you get the benefit of not having to program much.
<elderK>
rumbler31: How? You'd have to create a specialization for each code point, no?
<rumbler31>
elderK: well with what you want to do, you have to do that anyways
<elderK>
Yes but I can automate that very easily.
<rumbler31>
in what way?
<elderK>
Let's say I care about all code points < 128. I create a hash table. Initialize it so all 128 code points are say, 'invalid. Then, I build the proper mappings.
<dlowe>
technically you can automate defining a bunch of methods too
<elderK>
say, 0x30-0x39, etc.
<dlowe>
but involving the CLOS dispatch mechanism for zero benefit seems like a poor tradeoff
<elderK>
Yeah, my feelings exactly.
<elderK>
We're just moving the "table lookup" elsewhere, really.
<rumbler31>
yes, with less code
<elderK>
It's not less code.
<elderK>
Either you have some read-time thing that generates the methods.
<elderK>
Or you have some thing that generates the hash table.
<elderK>
rumbler31: To be fair though, I will play with your approach when I do it.
<elderK>
I'll try both :)
<elderK>
But this does raise another question: What is the accepted way to get a given character's code point? I have found char-code and char-int. And, am a little confused with the difference between them.
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<elderK>
(I've also seen cl-unicode. Does it override char-code and char-int?)
<dlowe>
no, you use its api
mrpat has joined #lisp
<dlowe>
I mean, if your cl implementation supports unicode (and most of them do, if not all of them), char-code and code-char will do the right thing
<dlowe>
it'll return the codepoint, though, not a byte encoding.
warweasle has quit [Quit: back later]
<elderK>
That's all good. Code-point would be great.
<elderK>
Then I don't have to do the decoding myself :) (I wrote a library for that some time ago. I'd certainly be happy to avoid that! :D)
DVSSA has joined #lisp
* elderK
takes a look at cl-unicode API in closer detail.
dieggsy has joined #lisp
itruslove has joined #lisp
<dlowe>
I was talking more about the unicode character classification
<elderK>
Weird. I can't see anything in cl-unicode's API about it, itself, doing any kind of reading of characters. It lets you determine a lot of interesting properties about characters based on their name or code-point. But, that depends on the implementation giving you a code-point.
<elderK>
dlowe: Fair point.
<phoe>
elderK: then dispatch only
DVSSA has quit [Ping timeout: 256 seconds]
giraffe has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
Guest7212 is now known as cmecca
cmecca has quit [Changing host]
cmecca has joined #lisp
FreeBirdLjj has joined #lisp
sjl__ has joined #lisp
damke_ has joined #lisp
fikka has joined #lisp
sjl__ has quit [Ping timeout: 264 seconds]
damke has quit [Ping timeout: 264 seconds]
dieggsy has quit [Ping timeout: 276 seconds]
milanj has quit [Quit: This computer has gone to sleep]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
nsrahmad has joined #lisp
rk[ghost] has joined #lisp
<rk[ghost]>
... i just typed '/ 640 12' in to google search -.-
<rk[ghost]>
apparently lisp has rotted my brain..
<TMA>
rk[ghost]: I have had trouble telling why that should be wrong for a moment
fikka has quit [Ping timeout: 240 seconds]
<rk[ghost]>
:)
papachan has joined #lisp
schjetne has joined #lisp
<_death>
should've typed it at your repl instead.. you do have a repl open, right?
glv has quit [Quit: Leaving]
<rk[ghost]>
of course, but i am dual computing
<rk[ghost]>
and the other machine, doesn't have a repl
<phoe>
_death: no parens
<rk[ghost]>
right, i didn't go that far.. i knew i was in google.. but when i went to type a math equation.. my mind said... operator first!
BlueRavenGT has joined #lisp
<phoe>
rk[ghost]: ssh from the second machine to the one that has the repl, or go for remote swank
warweasle has joined #lisp
<rk[ghost]>
i once set up a readline config to have a hotkey to prepend and postpend ( )s
<phoe>
there, lisp everywhere
<rk[ghost]>
but it isn't so useful except for silly small math equations as such..
<rk[ghost]>
aye, there are oodles of options.. i was just quickly questioning something..
fikka has joined #lisp
milanj has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
fikka has joined #lisp
fourier has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
damke_ has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
damke_ has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
heisig has quit [Quit: Leaving]
fourier has quit [Ping timeout: 265 seconds]
DVSSA has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
rotty has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
Kundry_Wag has joined #lisp
DVSSA has quit [Ping timeout: 240 seconds]
<elderK>
Hey guys, what's the best way to "build" a stirng, character by character?
<dlowe>
I guess you can be forgiven for forgetting one out of the 752 common lisp functions.
* Shinmera
uses w-o-t-s frequently
rotty has joined #lisp
damke_ has joined #lisp
schjetne has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 260 seconds]
DVSSA has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
damke has quit [Ping timeout: 264 seconds]
<mrpat>
I have an issue with parsing a uri from JSON. Once it is parsed, the repl evals it and counts the : as a package delimiter and spews an error. Is there a simple fix?
Kundry_Wag has joined #lisp
Cymew has joined #lisp
<dlowe>
keep the uri as a string and don't evaluate it
fikka has joined #lisp
<dlowe>
I don't even know how you're doing that by accident
<mrpat>
I am only asking for it to be parsed into an alist
<Bike>
"{" config ": { ... " will read as two strings with a symbol in the middle
<mrpat>
create a function to preparse?
<Bike>
no
<mrpat>
its the gs:// that makes it barf
<Bike>
it's the whole thing
<dlowe>
just put a \ before each internal "
<Bike>
why do you even have this literally in your code? will this not be like, a variable with a string in it, later?
cylb_ has joined #lisp
<dlowe>
since we don't have curly quotes in our code (and maybe we should!) it can't figure out where your quotations begin and end
<mrpat>
thats JSON man
<Bike>
I know it's json.
<dlowe>
that's string embedding man
cylb has quit [Ping timeout: 255 seconds]
<Bike>
if you write "foo" bar "baz" in your code obviously the code parser is going to think it's two strings.
<dlowe>
if you can't be convinced, try reading your json from a file and get back to us
<mrpat>
Thanks for the snark
<Bike>
So escape the internal quotation marks if you write it literally in the code like that.
<dlowe>
same to you
<Bike>
I'm just asking because having literal json in your code seems unusual. Usually you'd be reading it off the wire or something, I would think.
nsrahmad has quit [Quit: Leaving]
fikka has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
<mrpat>
I am just trying to get used to dealing with it. I will be sending and receiving JSON through a socket connection.
Cymew has joined #lisp
<Bike>
So this isn't permanent.
<Bike>
In that case just escaping the quotes should be fine.
<Bike>
(with-input-from-string (s "{\"config\": ...") ...)
<mrpat>
what is the function to escape quotes?
<Bike>
just do like what i wrote.
<mrpat>
so it is a preparse!
<Bike>
Whatever you want to call it.
<Bike>
But you won't be doing it when you get the json off the wire.
<mrpat>
OK thanks for the help.
Guest69321 has quit [Read error: Connection reset by peer]
<Bike>
The escaping is for the Lisp reader, which won't be touching json you get that way.
<mrpat>
exactly
<Bike>
Which is why I wouldn't have a separate "preparse" function or whatever.
<mrpat>
escape == turn the reader off?
<Bike>
No.
fikka has quit [Ping timeout: 260 seconds]
<Bike>
When you write "foo" "bar" the parser obviously interprets it as two strings.
Guest69321 has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
<mrpat>
I get that
<Bike>
If you write "foo\" \"bar", the parser sees the backslashes and accumulates a literal double quote character into one string instead.
<Bike>
So you have one string of length nine.
<mrpat>
So my function needs to inject \ into the raw json? that seems odd.
<Bike>
No.
<Bike>
No, look.
Cymew has joined #lisp
<Bike>
Right now i'm talking about how the parser of lisp code reads your code.
<Bike>
When you actually are getting raw json, that will just be a string in your program, and the lisp parser won't get anywhere near it.
<easye>
Is there any portable way to read user input from a terminal without echoing the characters typed? (I need to input a passphrase).
<Bike>
So you won't have to escape anything.
<Bike>
But right NOW what you're doing is putting a string literally in your code.
<Bike>
And for that you do have to escape it, because otherwise it can't be parsed with the code, because "foo" "bar" would obviously read as two strings and so on.
<mrpat>
Yes Bike I see that.
<mrpat>
It's actually the : creating the error
<Bike>
You'd get another error without the :
<mrpat>
Also won't be affected later
terpri has quit [Ping timeout: 260 seconds]
<Bike>
because with-input-from-string would go hey wait, why are you giving me like eight strings instead of one string.
<mrpat>
Ahhh
<mrpat>
good point
fikka has joined #lisp
<mrpat>
I will make some changes. Thanks for your help.
<Bike>
if you expect to be using literal json a lot, you could alter the parser a bit so that you don't need to escape things.
Cymew has quit [Ping timeout: 260 seconds]
<semz>
easye: Unices have getpass (unistd.h), and while I'm not aware of any CL wrapper it's a simple FFI call. Whether FFI is "portable" is another question though.
Guest36573 is now known as kolb
Cymew has joined #lisp
<mrpat>
I was looking for an example of parser manipulation
<Bike>
you should probably just use an existing one. cl-interpol should do.
fikka has quit [Ping timeout: 240 seconds]
<Bike>
then you can do #?{{"config": { ...}}} and it should be okay, i think.
damke has joined #lisp
<mrpat>
I will look into that package
<semz>
then again, terminal control isn't very portable anyway.
<easye>
semz: getpass() should work (I just need a macos/linux solution). Thanks!
damke_ has quit [Ping timeout: 264 seconds]
Achylles has quit [Remote host closed the connection]
damke__ has joined #lisp
shka has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
al-damiri has joined #lisp
Cymew has joined #lisp
fikka has joined #lisp
damke has quit [Ping timeout: 264 seconds]
loli has quit [Quit: WeeChat 2.1]
Karl_Dscc has joined #lisp
_cosmonaut_ has quit [Quit: Leaving.]
loli has joined #lisp
Cymew has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
DVSSA has joined #lisp
damke_ has joined #lisp
mflem has joined #lisp
papachan has quit [Ping timeout: 268 seconds]
damke__ has quit [Ping timeout: 264 seconds]
verisimilitude has quit [Remote host closed the connection]
fikka has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
earl-ducaine has quit [Read error: Connection reset by peer]
damke_ has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 264 seconds]
grumblr has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
grumble is now known as Guest46633
grumblr is now known as grumble
Guest46633 has quit [Killed (leguin.freenode.net (Nickname regained by services))]
xrash has joined #lisp
Cymew has joined #lisp
earl-ducaine has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
razzy has quit [Remote host closed the connection]
razzy has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
damke has joined #lisp
Cymew has joined #lisp
fikka has joined #lisp
azimut has quit [Ping timeout: 276 seconds]
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
azimut has joined #lisp
Cymew has quit [Ping timeout: 255 seconds]
Cymew has joined #lisp
azimut has quit [Ping timeout: 260 seconds]
mn3m has quit [Quit: mn3m]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
k-stz has joined #lisp
Cymew has joined #lisp
Cymew has quit [Ping timeout: 268 seconds]
igemnace has joined #lisp
Kundry_Wag has joined #lisp
fourier has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
pagnol has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
azimut has joined #lisp
hhdave has quit [Ping timeout: 260 seconds]
fourier has quit [Ping timeout: 265 seconds]
nowhere_man has quit [Ping timeout: 260 seconds]
janivaltteri has joined #lisp
makomo has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
varjag has joined #lisp
fisxoj has joined #lisp
jcowan_ is now known as jcowan
fikka has joined #lisp
fourier has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
dyelar has quit [Ping timeout: 260 seconds]
disumu has joined #lisp
dyelar has joined #lisp
krasnal has quit [Ping timeout: 256 seconds]
figurehe4d has quit [Quit: Leaving]
rumbler31 has quit [Ping timeout: 260 seconds]
krasnal has joined #lisp
song46 has joined #lisp
siraben` has joined #lisp
damke_ has joined #lisp
song46 has quit [Quit: WeeChat 1.4]
damke has quit [Ping timeout: 264 seconds]
siraben has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
sjl has joined #lisp
nowhere_man has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
terpri has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
disumu has quit [Quit: ...]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
energizer has joined #lisp
fikka has joined #lisp
SaganMan has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
krasnal has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
damke has joined #lisp
earl-ducaine has quit [Ping timeout: 256 seconds]
earl-ducaine has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
dented42 has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Read error: No route to host]
epony has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
epony has joined #lisp
fikka has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<aeth>
Is anyone else unable to run static-vectors with ECL?
fikka has quit [Ping timeout: 260 seconds]
jealousmonk has joined #lisp
fourier has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
makomo has quit [Quit: WeeChat 2.0.1]
papachan has joined #lisp
sauvin has quit [Remote host closed the connection]
Eray has joined #lisp
Eray has quit [Client Quit]
fourier has joined #lisp
azimut has quit [Ping timeout: 255 seconds]
paul0 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fisxoj has quit [Quit: fisxoj]
Kundry_Wag has quit [Remote host closed the connection]
azimut has joined #lisp
Kundry_Wag has joined #lisp
milanj has joined #lisp
fikka has joined #lisp
<phoe>
aeth: what is the issue you experience?
fikka has quit [Ping timeout: 256 seconds]
fourier has quit [Remote host closed the connection]
SaganMan has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
jonh has left #lisp ["WeeChat 1.4"]
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
gigetoo has quit [Ping timeout: 240 seconds]
gigetoo has joined #lisp
fikka has joined #lisp
jcowan has quit [Ping timeout: 268 seconds]
random-nick has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
wtjones has joined #lisp
wtjones has quit [Client Quit]
nalik891 has joined #lisp
nullniverse has quit [Read error: Connection reset by peer]
vlatkoB has quit [Remote host closed the connection]
nalik891 has quit [Ping timeout: 264 seconds]
nowhere_man has joined #lisp
damke has joined #lisp
fikka has joined #lisp
kolko has quit [Ping timeout: 260 seconds]
<aeth>
The two ECLs (one in roswell and one from the distro package manager) that I have installed failed differently, which suggests a cached fasl issue. I managed to fix the one from the package manager.
fikka has quit [Ping timeout: 240 seconds]
<aeth>
It looks like the one in roswell fails in process-grovel-file with ":INPUT argument to RUN-PROGRAM does not have a file handle:\n#<a SWANK/GRAY::SLIME-INPUT-STREAM>"
pierpa_ has joined #lisp
<aeth>
hmm, I thought deleting the caches for slime, static-vectors, and cffi would fix it but it did not.
* LdBeth
sorry, wrong channel, please just ignore that
fikka has joined #lisp
<on_ion>
aeth: hmm ive never tried roswell, but maybe delete more stuff ?
Karl_Dscc has quit [Remote host closed the connection]
mrpat has quit [Quit: Konversation terminated!]
fikka has quit [Ping timeout: 260 seconds]
_paul0 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
warweasle has quit [Quit: later]
Kundry_Wag has joined #lisp
damke_ has joined #lisp
paul0 has quit [Ping timeout: 240 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
damke has quit [Ping timeout: 264 seconds]
_paul0 has quit [Ping timeout: 240 seconds]
jcowan has joined #lisp
paul0 has joined #lisp
sucks has joined #lisp
sucks has quit [Max SendQ exceeded]
fikka has joined #lisp
ninegrid has quit [Quit: brb]
Jen has joined #lisp
ninegrid has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
SuperJen has quit [Ping timeout: 260 seconds]
wigust- has quit [Ping timeout: 240 seconds]
<joh11>
hi guys, anyone tried to livecode on a remote machine using slime and tramp mode ?
<joh11>
I keep having errors like "17 is not valid index into the object "_""
igemnace has quit [Quit: WeeChat 2.1]
<on_ion>
hmm, update slime/swank ?
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
fortitude has joined #lisp
<joh11>
already did
<joh11>
it seems to be something with the autocompletion, it triggers only when I type
<fortitude>
if I want to invoke a restart from a handler, and I want the same handlers to remain in effect, is the only way to do that to invoke the restart from some call-with-handlers function to re-establish them?
guaqua has quit [Ping timeout: 260 seconds]
guaqua has joined #lisp
<on_ion>
joh11: try to disable eldoc[-mode] if you've got it on? it errors for me in a different way but ive got a fix in the code on my machine for it
cylb_ has quit [Remote host closed the connection]
cylb_ has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
jealousmonk has quit [Ping timeout: 264 seconds]
<joh11>
on_ion: disabled it, but I still have the errors. However now the company-mode small autocompletion is popping, so I think it was still part of the problem
milanj has quit [Quit: This computer has gone to sleep]
comborico1611 has joined #lisp
dyelar has quit [Quit: Leaving.]
shuysman has joined #lisp
shuysman has quit [Quit: WeeChat 2.1]
Fare has quit [Ping timeout: 245 seconds]
shka has quit [Ping timeout: 256 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
asarch has joined #lisp
Folkol has joined #lisp
orivej has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Fare has joined #lisp
rumbler31 has joined #lisp
damke_ has joined #lisp
disumu has joined #lisp
<LdBeth>
joh11: what CL you use?
damke has quit [Ping timeout: 264 seconds]
Fare has quit [Ping timeout: 264 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
paul0 has quit [Remote host closed the connection]
asarch has quit [Ping timeout: 268 seconds]
dented42 has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Jen has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 264 seconds]
jibanes has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
comborico1611 has joined #lisp
paul0 has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
damke has joined #lisp
comborico1611 has quit [Ping timeout: 260 seconds]
paul0 has quit [Ping timeout: 260 seconds]
malice has joined #lisp
kerrhau has quit [Ping timeout: 255 seconds]
creat has quit [Ping timeout: 256 seconds]
damke_ has joined #lisp
fikka has joined #lisp
paul0 has joined #lisp
damke has quit [Ping timeout: 264 seconds]
creat has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
paul0 has quit [Ping timeout: 260 seconds]
nalik891 has joined #lisp
paul0 has joined #lisp
comborico1611 has joined #lisp
malice has quit [Remote host closed the connection]
khisanth_ has quit [Ping timeout: 265 seconds]
joh11 has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 264 seconds]
rumbler31 has joined #lisp
EvW has joined #lisp
fikka has joined #lisp
Fare has joined #lisp
random-nick has quit [Remote host closed the connection]
xrash has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 240 seconds]
_paul0 has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
paul0 has quit [Ping timeout: 265 seconds]
cylb_ has quit [Ping timeout: 260 seconds]
Fare has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
khisanth_ has joined #lisp
Bicyclidine is now known as Bike
_paul0 has quit [Remote host closed the connection]
LiamH has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 260 seconds]
janivaltteri has quit [Quit: leaving]
paul0 has joined #lisp
quazimodo has joined #lisp
disumu has quit [Remote host closed the connection]