<LdBeth>
ebrasca: a book about Common Lisp, which has a section talks about how to code walk with locally bind macros
<LdBeth>
ebrasca: I believe the link you give talks about C preprocessor macros
<LdBeth>
Which is different to Common Lisp's macro, CL's macro does a little code walking to ensure some macro expansions are properly done
<LdBeth>
And Scheme's hygienic macro system is totally different, it does manipulating at syntax level
<LdBeth>
and even the limitations mentioned such as function can't take data type, I believe there're already some programming languages can do that, either with template, dynamic typing, dependent typing etc
abarbosa has quit [Read error: No route to host]
aeth_ is now known as aeth
bexx has joined #lisp
<ebrasca>
LdBeth: Thanks!
FreeBirdLjj has joined #lisp
bexx has quit [Remote host closed the connection]
quazimodo has quit [Remote host closed the connection]
igemnace has quit [Ping timeout: 248 seconds]
bexx has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
quazimodo has joined #lisp
bexx has quit [Remote host closed the connection]
Fare has quit [Ping timeout: 272 seconds]
igemnace has joined #lisp
pillton has joined #lisp
zotan has quit [Ping timeout: 258 seconds]
FreeBirdLjj has joined #lisp
zotan has joined #lisp
moldybits has quit [Quit: WeeChat 2.4]
milanj has quit [Quit: This computer has gone to sleep]
Fare has joined #lisp
moldybits has joined #lisp
oni-on-ion has quit [Quit: Leaving]
libertyprime has joined #lisp
Bike has quit [Quit: Lost terminal]
pillton has quit [Read error: Connection reset by peer]
anewuser has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
nydel has quit [Read error: Connection reset by peer]
quazimodo has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
FreeBirdLjj has joined #lisp
<dmiles>
whom has used a Planner lately ? And on what CL?
<dmiles>
I been trying to get OPTOP or 3T to run on clisp .. whithout luck .. their defpackage systems are just too complex
<dmiles>
by planner i mean a program that load a domain.pddl and problem.pddl file
<dmiles>
of cours ei've had success runing 3T on AllegroCL
<dmiles>
just would be too difficualt to run on any other lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
vlatkoB has joined #lisp
<didi>
So... how do I know the sign of -0.0?
<didi>
FLOAT-DECODE?
<didi>
Eeer, DECODE-FLOAT?
<jeosol>
Good morning beach
<jeosol>
beach: What's the latest with SICL? I have been here in a while
<didi>
Ah, there is FLOAT-SIGN.
<beach>
jeosol: Hard to describe. I made a resolution to have a native executable by the end of the year. That involved re-thinking the way I generate AST and HIR, so it influences bootstrapping. I am about to design the new bootstrapping phases, and then I will attack code generation.
torbo has quit [Remote host closed the connection]
<jeosol>
beach: Thanks. I realize my question is very broad and vague. But your response is a good summary.
<beach>
If you are interested in daily progress, I often blab a lot in #sicl.
<jeosol>
I was here briefly yesterday and saw some expansion you posted ( I don't recall), maybe for defclass and I wanted to ask the reason for the [ and ( brackets. But had to run. I am not expert in compiler design and just stay in the application side of things
<beach>
Oh, that's the external format for the ASTs.
<beach>
And I decided a while ago that the FASL format was just going to be the external representation of the AST.
<beach>
The Common Lisp HyperSpec requires the file compiler to do "minimal compilation" and this is as minimal as it gets.
pankajgodbole has joined #lisp
<jeosol>
Very impressive.
<beach>
The external format is very simple. The left bracket is a reader macro character that reads a class name and a bunch of keyword/value pairs. It then calls make-instance on all that.
dddddd has quit [Remote host closed the connection]
<jeosol>
Thanks for that. Just refreshed the page and it was updated
<beach>
Yes, more source information now.
<beach>
I worked on that yesterday.
<beach>
Instead of source information being a file name, it is a position into a list of lines of text.
makomo has joined #lisp
<jeosol>
Yes, more information. I see that
donotturnoff has joined #lisp
anewuser has quit [Quit: anewuser]
orivej has joined #lisp
powerbit has quit [Read error: Connection reset by peer]
Oddity has quit [Read error: Connection reset by peer]
ym555 has quit [Ping timeout: 248 seconds]
<aeth>
beach: What are the chances of your work eventually ending up in SBCL/CCL/ECL/ABCL/etc.? Or would it require too many changes?
varjag has joined #lisp
Oddity has joined #lisp
<beach>
I don't think it ever will.
<beach>
I mean, some of my research probably will, but not the code.
sauvin has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 252 seconds]
FreeBirdLjj has joined #lisp
JohnMS_WORK has joined #lisp
varjag has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
jprajzne has joined #lisp
Fare has quit [Quit: Leaving]
varjag has joined #lisp
hiroaki has quit [Ping timeout: 272 seconds]
themsay has joined #lisp
xantoz has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
xantoz has joined #lisp
varjag has quit [Ping timeout: 248 seconds]
mingus has quit [Ping timeout: 248 seconds]
mingus has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
karlosz has quit [Quit: karlosz]
datajerk has quit [Ping timeout: 268 seconds]
libertyprime has quit [Ping timeout: 248 seconds]
copec has quit [Ping timeout: 258 seconds]
kayront has joined #lisp
varjag has joined #lisp
nowhereman has quit [Ping timeout: 245 seconds]
copec has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
scymtym has joined #lisp
schweers has joined #lisp
bgardner has quit [Ping timeout: 252 seconds]
hjudt has quit [Ping timeout: 245 seconds]
rozenglass has joined #lisp
python476 has joined #lisp
shrdlu68 has joined #lisp
Necktwi has joined #lisp
ricekrispie has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
heisig has joined #lisp
HDurer has quit [Remote host closed the connection]
HDurer has joined #lisp
ricekrispie has quit [Read error: Connection reset by peer]
ricekrispie has joined #lisp
hjudt has joined #lisp
techquila has quit [Quit: Leaving]
<LdBeth>
Good evening
<beach>
Hello LdBeth
powerbit has joined #lisp
<shangul>
Good afternoon
<Josh_2>
It's 940
<beach>
Josh_2: Please don't do that.
<Josh_2>
Do what?
<beach>
Start commenting on the time zone you are in. If we go there, it will never end.
<Josh_2>
oh right, sorry
vutral has joined #lisp
hhdave has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 248 seconds]
hhdave_ is now known as hhdave
themsay has quit [Ping timeout: 268 seconds]
<shangul>
:D
<LdBeth>
I guess it's allowed to have the interpreted and compiled code behaviors differently
vutral has quit [Remote host closed the connection]
vutral has joined #lisp
jcob has quit [Ping timeout: 245 seconds]
jcob has joined #lisp
themsay has joined #lisp
vutral has quit [Remote host closed the connection]
v88m has quit [Ping timeout: 252 seconds]
vutral has joined #lisp
ggole has joined #lisp
gxt has quit [Ping timeout: 258 seconds]
gxt has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
dpl has joined #lisp
dpl has quit [Remote host closed the connection]
dpl has joined #lisp
vutral has quit [Remote host closed the connection]
orivej has joined #lisp
vutral has joined #lisp
rippa has joined #lisp
amerlyq has joined #lisp
nanoz has joined #lisp
nanoz has quit [Client Quit]
nanozz has joined #lisp
cosimone has joined #lisp
libertyprime has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
Lord_of_Life has quit [Ping timeout: 248 seconds]
Lord_of_Life has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
cosimone has quit [Quit: WeeChat 2.3]
datajerk has joined #lisp
cosimone has joined #lisp
alca has quit [Ping timeout: 272 seconds]
JohnMS has joined #lisp
alca has joined #lisp
JohnMS_WORK has quit [Ping timeout: 272 seconds]
vaporatorius has joined #lisp
vutral has quit [Remote host closed the connection]
dddddd has joined #lisp
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
kajo has joined #lisp
vutral has joined #lisp
<didi>
Question: If you were writing an IEEE 754 floating-point reader, how would you deal with reading an infinity datum? That is, there isn't infinity in Common Lisp, so if you read one from a stream, would you raise a signal or return a keyword like :infinity?
<aeth>
didi: Most implementations have it. nan is harder to get.
<didi>
aeth: oic So you would write specific code to deal with each specific implementation.
<aeth>
You could just use infinity from that library, too.
<aeth>
NaN is trickier, which is probably why that library doesn't have it.
<aeth>
Iirc it's because there's more than one NaN
<aeth>
You could use my advice for NaN and float-features for infinity, maybe.
vutral has quit [Remote host closed the connection]
<didi>
aeth: There are. There are two and possibly properties for one of them. Anyway, thank you.
<p_l>
does anyone have a summary sheet for when one will get a newly consed object vs a copy? Recently found myself in conundrum like that where I couldn't figure out if I'm getting a new atom based on template value or modifying a literal :|
vutral has joined #lisp
voidlily has quit [Ping timeout: 252 seconds]
voidlily has joined #lisp
<shka_>
p_l: remove vs delete?
<beach>
didi: We don't "raise a signal" in Common Lisp. We "signal a condition".
<didi>
beach: True true. Thanks.
<p_l>
shka_: I'm manipulating arrays and atoms of (unsigned-byte 40)
<aeth>
p_l: 40?
<p_l>
aeth: yeah, 40bit words
<p_l>
I need to load them from external 5byte-per-word files as well as bit-manipulate
cosimone has quit [Quit: WeeChat 2.3]
bgardner has joined #lisp
nanozz has quit [Ping timeout: 248 seconds]
FreeBirdLjj has joined #lisp
stux|RC has joined #lisp
vutral has quit [Remote host closed the connection]
amerlyq has quit [Quit: amerlyq]
vutral has joined #lisp
nowhereman has joined #lisp
vutral has quit [Remote host closed the connection]
fivo has joined #lisp
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
nowhereman has quit [Ping timeout: 248 seconds]
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
shrdlu68 has quit [Ping timeout: 245 seconds]
pfdietz has quit [Ping timeout: 256 seconds]
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
voidlily has quit [Ping timeout: 248 seconds]
vhost- has quit [Ping timeout: 272 seconds]
nanoz has joined #lisp
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
cosimone has joined #lisp
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
voidlily has joined #lisp
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
ricekrispie has quit [Ping timeout: 258 seconds]
Necktwi has quit [Ping timeout: 272 seconds]
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
Necktwi has joined #lisp
nowhereman has joined #lisp
vlatkoB_ has joined #lisp
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
vlatkoB has quit [Ping timeout: 272 seconds]
Bike has joined #lisp
nowhereman has quit [Ping timeout: 272 seconds]
q9929t has joined #lisp
wxie has joined #lisp
q9929t has quit [Quit: q9929t]
dale_ has joined #lisp
dale_ is now known as dale
FreeBirdLjj has quit [Remote host closed the connection]
<schweers>
I think ebrasca saw this code somewhere and wants to understand it?
karlosz has joined #lisp
steiner has quit [Ping timeout: 246 seconds]
<ebrasca>
schweers: Yes I have read it in mezzano code and I like to undestand it.
<schweers>
ebrasca: Were our comments helpful to you? I.e. do you now understand?
<ebrasca>
Why is it good to evaluate someting in read time ?
hvxgr has quit [Quit: leaving]
<schweers>
It can be good for performance to evaluate something early. Basically the same reason why one might evaluate something at compile time (besides of course generating code).
<sjl_>
I rarely find myself needing #.
fivo has quit [Quit: WeeChat 1.9.1]
<ebrasca>
Is read time before compile time?
<sjl_>
I have used it in (case ...) statements before where I want to substitute in a constant instead of typing in a raw integer.
<beach>
ebrasca: Er, yes. How could you compile something that is not read.
<sjl_>
e.g. (case next-opcode (#.+opcode-foo+ ...) (#.+opcode-bar+ ...) ...)
eminhi_ has joined #lisp
<sjl_>
otherwise those would be interpreted as symbols
<ebrasca>
cl have syntax
<schweers>
CL has many syntaxes. But it has one default syntax.
<schweers>
Which happens to include such the aforementioned read macros
eminhi has quit [Ping timeout: 252 seconds]
<ebrasca>
Can you make c syntax in cl with read macros?
longshi has joined #lisp
<schweers>
Well. You can design a set of read macros and the like in order to read a syntax tree from C source code. But that alone is not enough to compile or even evaluate said code.
<schweers>
That would be an uphill battle though
<housel>
If parsing C with readmacros were possible somebody would have done it in the past 30 years
<Xach>
housel: i don't think that is true.
<Xach>
not all worthwhile things are done. someone must do them.
<sjl_>
(me linking that is not an endorsement of it as a Good Idea)
<sjl_>
Xach: I've been sick the past few days, but I did get your ping about the pgp stuff. I'm still willing to be a guinea pig.
<schweers>
It is questionable whether or not C was a good idea in the first place :-P
edgar-rft has quit [Quit: Leaving]
<Xach>
sjl_: thanks. right now i'm expanding from RSA-only keys and signatures to DSA and ElGamal keys and signatures. After that there might be something to play with.
<sjl_>
cool
<Xach>
I think I may factor this out into something standalone, too. It has IMHO useful compact/extractable SHA routines for one.
<ebrasca>
schweers: I like to have programs in Mezzano and I am lazy to make everiting.
<Xach>
I like ironclad but it is very difficult to use just part of its hashing code. It's tied together.
<sjl_>
Yeah, those could be handy. Also easier to audit a standalone package if anyone ever decided to pay a security person to audit.
<Xach>
If you can accept not being as fast as ironclad I think a self-contained library to copy is useful.
<Xach>
There's a SHA1 library but I coer 1/256/512 also.
<Xach>
and maybe something else. i forget.
<ebrasca>
sjl_: How much it cost for 1 audit?
<sjl_>
No idea. Probably depends on the size/scope of the audit.
<sjl_>
and how difficult it would be to find a security person willing/able to look at Common Lisp
karlosz has quit [Quit: karlosz]
elinow has quit [Read error: Connection reset by peer]
<ebrasca>
Can someone port usocket to Mezzano ? ( I can pay ~100$ )
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<ebrasca>
Is it good place to ask this?
nanoz has joined #lisp
hvxgr has joined #lisp
<_death>
wonder what would happen if you place CL tasks on a site like fiverr.. with enough tasks, CL could become popular ;)
<sjl_>
I think there are a couple of things on bountysource
manualcrank has joined #lisp
oni-on-ion has joined #lisp
ravenousmoose has joined #lisp
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl_ has joined #lisp
ravenousmoose has quit [Client Quit]
FreeBirdLjj has quit [Remote host closed the connection]
ravenousmoose has joined #lisp
ravenousmoose has quit [Client Quit]
FreeBirdLjj has joined #lisp
ravenousmoose has joined #lisp
zulu-inuoe has joined #lisp
eminhi_ has quit [Ping timeout: 252 seconds]
<markasoftware>
say I try to access the billionth element of a small circular array...will sbcl optimize it properly?
<markasoftware>
using nth
<markasoftware>
*circular list
<schweers>
markasoftware: Try it ;)
<Xach>
markasoftware: what would the proper optimization be?
<markasoftware>
modulo the lengt hof the list
<markasoftware>
then access that element
<sjl_>
I would be surprised if it did, but yeah, try it and see.
<jackdaniel>
wouldn't that require testing each cdr address against all traversed cdrs yet?
<jackdaniel>
at runtime
<markasoftware>
nah, it's just traversing the list
<markasoftware>
i'll just add the modulo logic myself
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<markasoftware>
interestingly, sbcl length hangs while clisp length detects the circle
<sjl_>
is required to detect circular lists, unlike length
<sjl_>
You could probably do something clever by keeping tortoise/hare pointers as you go, and if you detect a cycle and still have N elements remaining back up and do the modulo version
<sjl_>
But that's a lot of extra bookkeeping for a pretty rare case, so it would surprise me if any implementations did it by default.
<jackdaniel>
by tartoise/hare you mean the algorithm where one pointer goes i.e by cdr and the second by cddr and testing for their equality?
<pfdietz>
Floyd's fate was a sad one. Not the way I'd want to go.
schweers has quit [Ping timeout: 250 seconds]
nowhereman has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
longshi has quit [Ping timeout: 248 seconds]
v88m has joined #lisp
varjag has joined #lisp
milanj has joined #lisp
moei has joined #lisp
q9929t has joined #lisp
<pjb>
see com.informatimago.common-lisp.cesarum.list:list-lengths
<pjb>
(com.informatimago.common-lisp.cesarum.list:list-lengths '(a b c . #1=(1 2 3 4 5 . #1#))) #| --> 3 ; 5 |#
q9929t has quit [Remote host closed the connection]
q9929t has joined #lisp
pankajgodbole has quit [Ping timeout: 268 seconds]
q9929t has quit [Read error: Connection reset by peer]
pankajgodbole has joined #lisp
<oni-on-ion>
are you sure thats not some java
q9929t has joined #lisp
elinow has joined #lisp
pauljb has joined #lisp
warweasle has joined #lisp
bexx has joined #lisp
pauljb has quit [Quit: pauljb]
whartung has joined #lisp
sebboh has joined #lisp
<sebboh>
What are some lisp implementations that don't have GC?
<sebboh>
I think a GC that can be disabled doesn't count unless there is a compelling argument that cycles and storage are simply not used in the first place when it is disabled.
orivej has quit [Ping timeout: 248 seconds]
Zaab1t has joined #lisp
<Bike>
i don't know that there are any.
<Bike>
it doesn't seem very practical.
ggole has quit [Quit: Leaving]
<didi>
If I recall correctly, PAIP talks about not using the GC in some old implementations because they were inefficient, but I think they still had them.
orivej has joined #lisp
<zulu-inuoe>
GOAL had GC for the compiler but not the runtime iirc
q9929t has quit [Quit: q9929t]
Zaab1t has quit [Quit: bye bye friends]
nowhereman has quit [Ping timeout: 258 seconds]
saravia has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
sauvin has quit [Ping timeout: 248 seconds]
pankajgodbole has quit [Ping timeout: 248 seconds]
<sebboh>
I see, thank you.
ravenousmoose has joined #lisp
<sebboh>
(Surely there are toy lisps that don't have GC. And to answer 'why?', I dunno, microcontroller?)
<pjb>
Try to write some lisp function without a GC (ie. by calling free for each cons, make-array, make-string, format, etc).
<oni-on-ion>
Bike, sebboh, quite a few
<oni-on-ion>
not "CL" however
<Bike>
toy, sure, but not common lisp
<Josh_2>
I used Picolisp on the mizar32b
<jackdaniel>
pjb: that could be somehow made easier with enforcing object scope (i.e no function like #'cons but rather macro (with-cons …), or (with-objects ((a cons) …) …) not that I would be thrilled to use such system
<didi>
jackdaniel: Sounds like Rust. /me evidently knows nothing about Rust
<p_l>
sebboh: ancient lisp had no GC because GC wasn't invented yet, so they had to do it
<p_l>
didi: Rust is pretty much "compile-time GC"
<oni-on-ion>
jackdaniel, why not reference count let? =P
<oni-on-ion>
i heard earlier someone said that SBCL is mostly "compile-time lisp"
cosimone has quit [Quit: WeeChat 2.3]
elinow has quit [Remote host closed the connection]
ym555_ has joined #lisp
elinow has joined #lisp
ym555 has quit [Ping timeout: 245 seconds]
<didi>
p_l: Interesting. How do you read an unknown number of bytes?
<p_l>
what do you mean "read an unknown number of bytes"? With compile-time GC? You either ultimately use constant-size memory for this, or just ensure that you cons objects that can't have references and your compile time GC only tracks references (Rust model)
edgar-rft has joined #lisp
<didi>
p_l: Say I want to read text files but I don't know their sizes during compilation.
clothespin has joined #lisp
Jesin has quit [Quit: Leaving]
<p_l>
didi: your buffers can be compile-time known to have specific amount of references, you're tracking those references not memory
<p_l>
that's, afaik, how Rust's model works actually
<didi>
ic Thanks.
<p_l>
BTW, GOAL had a very simple GC scheme where they didn't track anything
<p_l>
it simply had, iirc, two (maybe few more) areas that were fixed size at compile time, and used simple bump allocator inside of them (i.e. the "raise top of heap" pointer kind), with collection that worked by dropping a whole region
<dlowe>
There's nothing that says you can't make a lisp with a EXT:FREE function
<dlowe>
you could even use some macros to auto-free objects dynamically
Jesin has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
donotturnoff has quit [Read error: Connection reset by peer]
<didi>
I'm not sure the scope and extend rules would survive these.
pyx has joined #lisp
pyx has quit [Client Quit]
pyx has joined #lisp
pyx has quit [Client Quit]
elinow has quit [Remote host closed the connection]
clothespin has quit [Ping timeout: 248 seconds]
elinow has joined #lisp
ym555_ is now known as ym555
scymtym has quit [Ping timeout: 250 seconds]
<oni-on-ion>
but since parens() survive by needing both an open *and* close, surely malloc/free under the same assumption could be just fine.
<oni-on-ion>
(this is why i was OK with refcounting)
cosimone has joined #lisp
python476 has quit [Ping timeout: 258 seconds]
Blukunfando has joined #lisp
nanoz has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
<pjb>
didi: you can read a maximum number of bytes.
elinow has quit [Read error: Connection reset by peer]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
q-u-a-n2 has joined #lisp
libertyprime has quit [Ping timeout: 268 seconds]
oni-on-ion has quit [Quit: Leaving]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nydel has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
amerlyq has quit [Quit: amerlyq]
<dlowe>
shrug. a free is a promise, like a type declaration
q-u-a-n2 has quit [Ping timeout: 272 seconds]
abarbosa has joined #lisp
ym555 has quit [Ping timeout: 272 seconds]
sjl_ has quit [Quit: WeeChat 2.3-dev]
akoana has joined #lisp
Bike has quit []
ym555 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
dxtr has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
LiamH has quit [Quit: Leaving.]
ckonstanski has joined #lisp
<ckonstanski>
Having an issue running a lisp process inside a docker container. Using SBCL. As soon as the lisp image is done loading and comes to rest at the REPL, the container dies. If I run the container interactively I cannot reproduce the behavior. Is there a trick to running a lisp image in docker?
vutral has joined #lisp
vutral has quit [Remote host closed the connection]
rdh has joined #lisp
<no-defun-allowed>
prolly try `--non-interactive` if you don't intend to use the REPL
<ckonstanski>
OK thanks!
<rdh>
is there good documentation and examples for OO? i'm reading Practical Common Lisp, and i'm not really grasping generic functions and how methods are "connected" to classes.
<Xach>
rdh: practical common lisp is a good start.
vutral has joined #lisp
<Xach>
rdh: it can help not to think of generic functions as the primary thing, and classes as a convenient way to implement some concrete behavior.
<Xach>
err, "help to think" not "help not to think"
<no-defun-allowed>
GFs are not connected to classes (except that they have a class, standard-generic-function) but they dispatch on classes (and eql values)
<rdh>
ohhhhhhhhhhhhh, methods are not really part of class objects... so i'm defining a generic way to use my object using methods
<Xach>
rdh: methods are not part of classes, classes are a way for a generic function to select what methods apply to a given set of arguments.
<Xach>
and not just classes can be used for selecting methods
<didi>
"There are no object methods." -- Matrix
<Xach>
rdh: "generic way to use my object" is still not really right
<Xach>
rdh: a generic function is like a thingy to which you attach methods. when you call a generic function, some (or none!) of the methods are selected to run if they match the arguments in some way.
Bike has joined #lisp
<Xach>
so classes become part of the selection process through the method lambda list.
wxie has joined #lisp
<Xach>
if you define a method and it is selected, your object will be one of the arguments processed in some way by the code in the method. there can be many objects involved too - it's not helpful to think of an object as the "owner" of a method, it's just a participant in the selection of a method.
<Xach>
and acted on by the code of the method.
<Xach>
or it might be used merely for the selection process and not actually acted upon
<Xach>
rdh: super clear now right?
<rdh>
Xach, no lol
<Xach>
hee hee
<Xach>
well, there are some good resources out there. try to avoid something that puts objects/classes first. it inhibits real understanding.
<rdh>
i wish i learned lisp before other programming languages.
<rdh>
Xach, wow thank you for that guide, that makes it much more clear.
<moldybits>
i don't know if this is better, but at least it's more natural in clos to distinguish actions by how you name the function as opposed to letting the objects provide the context. (concatenate "a" "b") => "ab" (+ "19" "23") => "42"
<didi>
moldybits: This is a good way to emphasize the generic function.
<Xach>
rdh: glad to hear it.
gjvc has joined #lisp
saravia has quit [Remote host closed the connection]
moei has quit [Quit: Leaving...]
femi has quit [Ping timeout: 248 seconds]
shifty has joined #lisp
femi has joined #lisp
femi has quit [Ping timeout: 258 seconds]
femi has joined #lisp
wxie has quit [Quit: wxie]
femi has quit [Ping timeout: 272 seconds]
femi has joined #lisp
khisanth_ has quit [Ping timeout: 258 seconds]
milanj has quit [Quit: This computer has gone to sleep]