ebrasca has quit [Remote host closed the connection]
ahungry has joined #lisp
Bourne has joined #lisp
gko has quit [Remote host closed the connection]
gko has joined #lisp
bitmapper has quit [Ping timeout: 250 seconds]
iAmDecim has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
Josh_2 has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
iAmDecim has joined #lisp
Jeanne-Kamikaze has joined #lisp
penguwin has quit [Quit: NO CARRIER]
penguwin has joined #lisp
iAmDecim has quit [Ping timeout: 264 seconds]
penguwin has quit [Quit: NO CARRIER]
ahungry has quit [Remote host closed the connection]
penguwin has joined #lisp
ahungry has joined #lisp
gko_ has joined #lisp
gko has quit [Ping timeout: 265 seconds]
gko has joined #lisp
gko_ has quit [Ping timeout: 256 seconds]
mono has joined #lisp
EvW1 has quit [Ping timeout: 252 seconds]
<White_Flame>
is there a simple pattern or utility for testing if REMOVE successfully removed an item, without re-walking the sequence?
monokrom has quit [Ping timeout: 256 seconds]
<White_Flame>
I guess sine I'm using lists, LENGTH would still have to walk it; could work for arrays
<White_Flame>
(actually, length would end up with 3 walks, old length, remove, new length)
<White_Flame>
the other option that comes to mind is setting a flag from inside the :test function
<White_Flame>
any others, besides writing your own REMOVE?
renzhi has quit [Ping timeout: 260 seconds]
efm has joined #lisp
<Bike>
you could use member, and avoid any redundant processing that way
<Bike>
kind of roudnabout though
<Bike>
also, only works for lists
<Bike>
oh, no, better
<Bike>
"If any elements need to be removed, the result will be a copy. The result of remove may share with sequence; the result may be identical to the input sequence if no elements need to be removed. "
<Bike>
i suppose that doesn't guarantee that it's identical, though
vhost- has quit [Quit: WeeChat 2.6]
<White_Flame>
right
iAmDecim has joined #lisp
<White_Flame>
for my PUSHNEW?, I simply do (eq ,place (pushnew ,val ,place...)) and it's fine
<Bike>
that will evaluate place's subforms twice... i guess it probably doesn't matter
<White_Flame>
yep. Is there a pattern for evaluating place's subforms only once?
<Bike>
use get-setf-expansion. that basically means reimplementing pushnew, but that's pretty easy since it's just adjoin
<White_Flame>
I mean, most updating forms have ,place twice
<Bike>
the standard ones only evaluate subforms once
<White_Flame>
right, I mean when writing read-mody-write macros on places
<White_Flame>
in any case, I'll write my REMOVE? with manual iteration
GuerrillaMonkey has joined #lisp
<Bike>
define-modify-macro operators only evaluate them once too. all you have to do is use the get setf expansion and then you can put the reader form wherever
gko_ has joined #lisp
Jeanne-Kamikaze has quit [Ping timeout: 258 seconds]
Jeanne-Kamikaze has joined #lisp
gko has quit [Ping timeout: 256 seconds]
GuerrillaMonkey has quit [Ping timeout: 264 seconds]
gko_ has quit [Ping timeout: 256 seconds]
efm has quit [Remote host closed the connection]
efm has joined #lisp
gko has joined #lisp
vhost- has joined #lisp
vhost- has quit [Changing host]
vhost- has joined #lisp
libertyprime has quit [Ping timeout: 250 seconds]
buffergn0me has joined #lisp
shukryzablah has joined #lisp
pilne has quit [Quit: We be chillin' - IceChat style]
wxie has joined #lisp
mathrick has quit [Remote host closed the connection]
mathrick has joined #lisp
mathrick has quit [Remote host closed the connection]
libertyprime has joined #lisp
mathrick has joined #lisp
ivan4th has joined #lisp
mathrick_ has joined #lisp
mathrick has quit [Ping timeout: 264 seconds]
<beach>
Good morning everyone!
jeosol has joined #lisp
ArthurStrong has left #lisp [#lisp]
wxie has quit [Ping timeout: 256 seconds]
<shukryzablah>
good morning
vlatkoB has joined #lisp
buffergn0me has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
Good morning shukryzablah
iridioid has quit [Ping timeout: 256 seconds]
voidlily has quit [Remote host closed the connection]
bjorkintosh has joined #lisp
orivej has joined #lisp
libertyprime has quit [Read error: Connection reset by peer]
ahungry has quit [Ping timeout: 250 seconds]
libertyprime has joined #lisp
ahungry has joined #lisp
sauvin has joined #lisp
wxie has joined #lisp
narimiran has joined #lisp
iridioid has joined #lisp
iridioid has quit [Ping timeout: 265 seconds]
wxie has quit [Ping timeout: 252 seconds]
akoana has left #lisp ["Leaving"]
Kundry_Wag has quit [Ping timeout: 256 seconds]
Oladon has quit [Quit: Leaving.]
shifty has joined #lisp
voidlily has joined #lisp
Bike has quit [Quit: leaving]
iAmDecim has quit [Ping timeout: 264 seconds]
ayuce has quit [Remote host closed the connection]
ayuce has joined #lisp
ahungry has quit [Remote host closed the connection]
Jeanne-Kamikaze has quit [Quit: Leaving]
ayuce has quit [Remote host closed the connection]
narimiran has quit [Quit: leaving]
iridioid has joined #lisp
wxie has joined #lisp
Kundry_Wag has joined #lisp
iridioid has quit [Ping timeout: 264 seconds]
ayuce has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
gravicappa has joined #lisp
ivan4th has quit [Ping timeout: 240 seconds]
mikecheck has joined #lisp
_paul0 has joined #lisp
shangul has joined #lisp
shka_ has joined #lisp
ayuce has quit [Remote host closed the connection]
paul0 has quit [Ping timeout: 265 seconds]
srji has joined #lisp
iAmDecim has joined #lisp
cosimone has joined #lisp
EvW has joined #lisp
wxie has quit [Ping timeout: 252 seconds]
lambda-p has joined #lisp
lambda-p has quit [Client Quit]
narimiran has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
lambda-p has joined #lisp
shangul has quit [Ping timeout: 256 seconds]
lambda-p has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
narimiran has quit [Ping timeout: 260 seconds]
v_m_v has joined #lisp
hylisper has joined #lisp
heisig has joined #lisp
shangul has joined #lisp
_whitelogger has joined #lisp
<phoe>
pjb: thanks, I see.
<phoe>
Also good morning
<no-defun-allowed>
Good morning phoe
<beach>
Hello phoe. Thanks for the report on SICL conditions. I am not going to act upon it now, because those conditions are not final. They may change in the future.
<phoe>
beach: yes, I've noticed! The condition system in SICL looks like a big WIP.
<beach>
You are right.
<beach>
I am concentrating on solving problems that I consider fundamental.
<beach>
Bootstrapping is one such problem.
<phoe>
Yep, understandable.
<beach>
And, as of this morning, thanks to Bike, I am thinking more about thread safety too.
ATuin has joined #lisp
iridioid has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
iridioid has quit [Ping timeout: 260 seconds]
dddddd has quit [Ping timeout: 250 seconds]
hylisper has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
hylisper has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
ivan4th has joined #lisp
ivan4th` has joined #lisp
hylisper has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
ivan4th has quit [Ping timeout: 265 seconds]
iAmDecim has joined #lisp
ivan4th` has quit [Ping timeout: 256 seconds]
narimiran has joined #lisp
Necktwi has quit [Ping timeout: 258 seconds]
iAmDecim has quit [Ping timeout: 240 seconds]
narimiran has quit [Client Quit]
ivan4th` has joined #lisp
ivan4th` has quit [Ping timeout: 264 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
libertyprime has quit [Remote host closed the connection]
narimiran has joined #lisp
<beach>
phoe: Since you now know so much about the condition system, perhaps you should be the one implementing the SICL condition system?
cosimone has quit [Remote host closed the connection]
dale has quit [Quit: My computer has gone to sleep]
cosimone has joined #lisp
<phoe>
beach: I was thinking about that, yes
<beach>
Great!
<phoe>
The code I am working on shall be placed into public domain; it's also implemented using portable CL.
<jackdaniel>
I imagine beach wouldn't want it to be defined in terms of defstruct (just saying)
<phoe>
Yes, that's the only thing that'll need adjustment - restarts using defstruct
<phoe>
conditions are already classes.
<beach>
It won't matter, since SICL DEFSTRUCT will be pretty much an alias for DEFCLASS.
<phoe>
Hah!
narimiran has quit [Ping timeout: 258 seconds]
Necktwi has joined #lisp
cosimone has quit [Remote host closed the connection]
<beach>
phoe: There might be some adaptation to make for SICL. I was thinking of having dedicated entries in the dynamic environment for things like handlers, rather than using a special variable.
<beach>
phoe: But my knowledge of the condition system tells me that most of it is totally portable either way, and that such adaptations can be isolated with a proper protocol.
v_m_v has quit [Remote host closed the connection]
<phoe>
oh wait, it's *not* that simple - we need rebinding
<phoe>
and I don't think we should mutate the current environment, rather, we should return new ones.
darkstar314 has joined #lisp
<beach>
I still haven't looked at the details of you code, but I am convinced that no major problems will be detected.
<phoe>
I don't think so either
<phoe>
if I can rebind a dynamic environment via rebinding a dynamic variable, then only minor adjustments are needed
<phoe>
instead of binding *handler-clusters* with (cons stuff *handler-clusters*), I can bind *env* with (env-add-handlers *env* stuff)
<beach>
And I think a totally fresh implementation of the condition system is a very good thing, especially by someone like you who have understood the importance of protocols, modularity, etc.
<phoe>
beach: it's not totally fresh, I'm standing on the shoulders of kmp whose code I'm working on
<phoe>
but, given the amount of work that I'm putting there... it's clearly a non-trivial modification that I am creating right now
<jackdaniel>
also, I think that you are very haste with dubbing things dead, unreadable or whatever
<phoe>
I cannot comment on ECL's one since it's written in C
<phoe>
jackdaniel: I think you are right, yes
<phoe>
I need to better my holding-my-horses ability
<jackdaniel>
it is first time I hear that ECL's condition system is written in C
<jackdaniel>
it is usable from C, but that is not the same thing
<jackdaniel>
see src/clos/conditions.lsp
<phoe>
one second...
<jackdaniel>
it is not about holding horses but rather about thinking before speaking
<phoe>
welp, I looked in the wrong place - *restart-clusters* is defined in C
<phoe>
the macros are in CL, correct
iAmDecim has joined #lisp
<jackdaniel>
wrong again
<jackdaniel>
how is it defined in C?
xlei has quit [Ping timeout: 256 seconds]
<jackdaniel>
this time by "it" I mean *restart-clusters*
<jackdaniel>
it is literally third form in conditions.lsp file
<phoe>
welp
* jackdaniel
disengages
<phoe>
#define ECL_RESTART_CLUSTERS ((cl_object)(cl_symbols+5)) didn't mean what I think it did.
* phoe
hides in shame
<phoe>
now that's a good example of not thinking before speaking that you were talking about
Inline has joined #lisp
xlei has joined #lisp
<no-defun-allowed>
So far, it's pretty good. HANDLER-CASE with a :NO-ERROR clause expands to something that contains a HANDLER-CASE* invocation that is never defined; should it just be HANDLER-CASE without the star suffix?
gko_ has joined #lisp
Kundry_Wag has joined #lisp
<phoe>
no-defun-allowed: that's a bug.
refpga has joined #lisp
<phoe>
fixed
<phoe>
yes, it should be without a star
<no-defun-allowed>
Gotcha.
gko has quit [Ping timeout: 256 seconds]
gko has joined #lisp
gko_ has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Would it be possible and preferable to move the condition type definitions to another file? Usually I put those in another file.
<phoe>
no-defun-allowed: sure, I can do that
<beach>
This is excellent! Another pair of eyes. The quality of the code can only be improved. :)
<no-defun-allowed>
Thanks. I think conditions.lisp is very good otherwise; I'm not so confident with restarts but I'll start reading restarts.lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
<phoe>
there's still bugs in it but I'm squashing them right now
<no-defun-allowed>
Splitting out the parsing code from the macro definition in the macros that have some syntax like DEFINE-CONDITION and HANDLER-CASE is very nice, too.
iridioid has joined #lisp
EvW has joined #lisp
iAmDecim has quit [Ping timeout: 258 seconds]
iridioid has quit [Ping timeout: 260 seconds]
<phoe>
that's what I wanted to say I dislike in big long complex macros before I got a bucket of cold water to the head
<phoe>
anyway - I split condition definitions outside conditions.lisp and fixed some bugs, things now compile cleanly for me
<no-defun-allowed>
Cool.
<no-defun-allowed>
restarts.lisp looks fine, but I can't comment on if it's correct.
Lycurgus has quit [Remote host closed the connection]
iAmDecim has quit [Ping timeout: 240 seconds]
u8t6 has joined #lisp
hylisper has quit [Remote host closed the connection]
iridioid has joined #lisp
iAmDecim has joined #lisp
iridioid has quit [Ping timeout: 256 seconds]
Codaraxis_ has joined #lisp
hylisper has joined #lisp
Codaraxis has quit [Ping timeout: 256 seconds]
theosvoitha has joined #lisp
joshcom has joined #lisp
u8t6 has quit [Remote host closed the connection]
ATuin has quit [Ping timeout: 256 seconds]
gko has joined #lisp
ivan4th` has joined #lisp
iAmDecim has quit [Ping timeout: 264 seconds]
shangul has quit [Quit: Leaving]
<jcowan>
How about calling it Fettle?
<phoe>
hmm
<jcowan>
(the condition system for Sicl)
<phoe>
why fettle?
<jcowan>
an old-fashioned synonym for condition, like "in fine fettle" = "in good condition'.
<jcowan>
but an unusual word
<beach>
Oh, nice! Never heard that.
<phoe>
hah
<shka_>
oh, we are discussing names now? awesome i am in need of cool names
<beach>
I love it!
<shka_>
i have data-frame library that i named cl-data-frames
<beach>
shka_: A bit boring perhaps. :)
<shka_>
not only that but there already is cl-data-frame library (singular) in the quicklisp
<shka_>
so imagine the confusion
<phoe>
i have a portable condition system that I named portable-condition-system
<jcowan>
Isn't a dataframe basically a SQL table?
iridioid has joined #lisp
<shka_>
well, pretty much just a table (in this instance a sparse table because sparse data sets are results in giganils of memory) and some more elaborate operations
<phoe>
> giganil
<phoe>
now that is a fun term
<MichaelRaskin>
jcowan: looking in the dictionary, it looks like fettle is only used when it's fine (and the condition system should probably cover the cases where something is wrong…)
<phoe>
(not "in fine fettle")
<jcowan>
That's true: there are few perfect synonyms in natural language (though gorse, furze, and whin come close).
<shka_>
phoe: accurate description o situation where column is 99.99% empty and the table as a whole is 16gb
<jcowan>
The idea is to be (a) memorable as a name, (b) unlikely to conflict with anything (c) semantically related to the subject
<shka_>
jcowan: this sounds like a solid guidelines!
<jcowan>
There are two different HTML parsers called TagSoup, but fortunately their home pages are cross-linked
<selwyn>
i am reminded of the song 'just dropped in / to see what condition my condition was in'
<selwyn>
you could look to the lyrics for inspiration
Josh_2 has joined #lisp
iridioid has quit [Ping timeout: 258 seconds]
<shka_>
'Avidity and lust controlled by hate.'
iridioid has joined #lisp
<jcowan>
so if you want the Java parser and find the Haskell parser, or vice versa, it's just another click
z147 has joined #lisp
<shka_>
phoe: i would call a condition system Gehenna :P
<shka_>
though perhaps better for debugger
<phoe>
shka_: you have a dark mind
<phoe>
I like it
<shka_>
no, i think that i have a very bright mind :P
<shka_>
but there are different opinions on the subject
<phoe>
I said dark, not dim
<MichaelRaskin>
Bright and full of sulfur?
<phoe>
definitely
iridioid has quit [Ping timeout: 256 seconds]
darkstar3141 has joined #lisp
darkstar314 has quit [Ping timeout: 260 seconds]
* jcowan
notes the proof that Heaven is hotter than Hell
iAmDecim has joined #lisp
Kundry_Wag has joined #lisp
EvW has quit [Ping timeout: 246 seconds]
frgo has quit []
frgo has joined #lisp
keep_learning has quit [Quit: This computer has gone to sleep]
darkstar3141 has left #lisp [#lisp]
cosimone has joined #lisp
EvW has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
z147 has quit [Quit: z147]
Bike has joined #lisp
ivan4th` has quit [Ping timeout: 256 seconds]
refpga` has joined #lisp
refpga has quit [Ping timeout: 256 seconds]
joshcom has quit [Ping timeout: 256 seconds]
<Shinmera>
phoe: My name suggestion is: Unconditional
* Shinmera
goes back to working on the update for his lisp game
<phoe>
Shinmera: an unconditional condition system
<phoe>
:thonk:
<Bike>
well, if it's not metacircular, your condition system doesn't presume the existence of conditions, right?
<Bike>
un con di tion al
<Bike>
by the way, ecl's condition code is definitely derived from kmp. i mentioned yesterday (?) that clasp (which got it from ecl) still had that unique-id thing
glamas has quit [Ping timeout: 256 seconds]
glamas has joined #lisp
shangul has joined #lisp
<phoe>
Bike: yes, I was an idiot, it's Lisp-defined and derived from kmp code
<phoe>
also, "unconditional" - that's... tempting
devrtz has quit [Ping timeout: 256 seconds]
<Bike>
now, clisp i'm kind of curious about, because I believe the VM definition has some handling for handler-case specifically
<Bike>
that sounds pretty different
ccl-logbot has quit [Read error: Connection reset by peer]
<MichaelRaskin>
phoe: is the core of what you are doing objectifyng the condition system?
<Bike>
phoe: want some incredibly nitpicky nitpicks on your repo?
<phoe>
Bike: please
<phoe>
MichaelRaskin: not really objectifying
<phoe>
I'm implementing a portable condition system
<jcowan>
Vacuity might be a good name for a table implementation specializing in mostly-empty columns.
iAmDecim has joined #lisp
ccl-logbot has joined #lisp
<jcowan>
I forgot to mention condition (d): short.
<jcowan>
Unconditional is problematic just because it is so common.
<phoe>
Bike: all nitpicks are good, this is code that I want to be as clean as possible since it'll be educational material
<phoe>
just pushed newest fixes to it, too.
<Bike>
phoe: define-condition :report lambdas are in the wrong lexical environment (also repeatedly evaluated, which kind of sucks but is probably allowed). coerce-to-condition should accept a function as datum since functions can be format controls.
<Bike>
that's all i see so far
<phoe>
Bike: nice catches
<phoe>
in COERCE-TO-CONDITION, you mean that if datum is a function, then I should call (make-condition default-type :format-control datum :format-arguments arguments) ?
<phoe>
local lexical functions are properly captured
<Bike>
I mean like (let ((x ...)) (define-condition ... (:report (lambda (stream) ...x...)))))
<Bike>
er, condition stream, whatevs
<jcowan>
This led me to wonder about Vacietis, the Common Lisp C compiler; it's the Lithuanian word for 'German', but the two famous people who bore it are both Latvian.
<Bike>
seems fine to me. What happens when printing a condition signals an error?
<phoe>
I don't handle this one yet. Let me fix it.
<phoe>
fixed, thanks.
TwoNotes has joined #lisp
iAmDecim has quit [Ping timeout: 258 seconds]
theosvoitha has quit [Quit: Connection closed for inactivity]
cosimone has quit [Quit: Terminated!]
xlei has quit [Ping timeout: 256 seconds]
iAmDecim has joined #lisp
jayspeer has joined #lisp
ATuin has joined #lisp
cosimone has joined #lisp
ayuce has joined #lisp
iAmDecim has quit [Ping timeout: 250 seconds]
xlei has joined #lisp
iridioid has joined #lisp
iAmDecim has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
iridioid has quit [Ping timeout: 256 seconds]
iAmDecim has quit [Ping timeout: 260 seconds]
Lycurgus has joined #lisp
narimiran has joined #lisp
iAmDecim has joined #lisp
iAmDecim has quit [Ping timeout: 265 seconds]
narimiran has quit [Quit: leaving]
<TwoNotes>
Packages COMMON-LISP and LMDB both contain a method GET. How do I :use :LMDB without getting a name conflict? Something about :shadow I think.
<beach>
Don't :USE the LMDB package.
<scymtym>
if you must, you can use (:shadowing-import-from #:lmdb #:get) in your package. but as beach says, better don't
<Xach>
TwoNotes: it depends on which symbol you want to refer to when you write GET without a prefix.
gko has quit [Ping timeout: 256 seconds]
<Xach>
if you use (:shadow #:get), it refers to neither. otherwise you can chose with shadowing-import-from.
<TwoNotes>
I only reference it as (lmdb:get ...)
<Xach>
another option is not to use the package at all
<Xach>
as beach says
<TwoNotes>
So just the :depends-on in my ASD file is enough?
<Xach>
that will ensure it is loaded, yes
<TwoNotes>
ah ok. Thnak you
<beach>
TwoNotes: The package name is short enough that you can prefix all the symbols from the LMDB package. That way, your code automatically becomes more clear as well.
<phoe>
yes, four characters is short enough
<Xach>
i'm still intrigued by joe marshall's application structure, where no symbol is ever referred to by prefix.
<Xach>
i have never tried to seriously do that myself, though.
<TwoNotes>
All my LMDB references are in a single source file, so it is not a problem using the explicit lmdb: all the time.
<shka_>
because for the maximum effect, mix cultures
<phoe>
we don't have restarts, we have resurrection methods
<shka_>
also, fatal error may display "In this times you need more then an advice. You need Jesus."
<shka_>
ok, enough of fooling around, back to coding
<phoe>
yes
<eta>
is there a way to specify a maximum line length with READ-LINE?
Oladon has joined #lisp
iAmDecim has joined #lisp
<phoe>
eta: nope
<phoe>
it reads until a newline
<eta>
phoe, so if I want this functionality, I should roll my own READ-LINE with READ-BYTE or something?
<phoe>
READ-CHAR
<eta>
yeah, that :)
<phoe>
you can implement a version which reads until #\Newline or until it has read 80 characters or something
gko has quit [Ping timeout: 256 seconds]
<phoe>
(with-output-to-string (loop with char = nil for i from 1 until (= i char-limit) do (setf char (read-char)) if (eql #\Newline char) do (loop-finish) else (write-char char)))
<phoe>
something like that, very roughly implementing
<Shinmera>
Could also do more complicated logic with read-sequence to avoid the char-by-char read.
<eta>
Shinmera, yeah, that's what I was thinking of
<phoe>
or what Shinmera says
<eta>
the problem is you'd end up reading too much
<Shinmera>
read seq, seek to eol, process up until that index, shift rest to front, read-sequence starting at that point, repeat.
<Shinmera>
Doubt it would end up faster though.
gko has joined #lisp
<eta>
Shinmera, well read-sequence can probably use AVX or some other funky CPU instructions
iAmDecim has quit [Ping timeout: 250 seconds]
<Shinmera>
at 80 characters you're not gonna save a lot.
<phoe>
also the question is if you're reading from string or if you're reading from a normal stream
<eta>
hmmm
<eta>
it's a usocket
<phoe>
yes, that's worse
<Shinmera>
but as always, measure.
<eta>
so I don't really want to call READ-CHAR a million times on it
<phoe>
if you read too much then you need to unread that stuff somehow
<phoe>
and that means buffering
<phoe>
which you're likely going to do anyway if you want to do your own socketing
* eta
googles for buffered streams
<eta>
well I think you have to do your own socketing, no?
<phoe>
;; come to the zeromq side, we have cookies
<phoe>
;; and messages instead of streams!
<eta>
phoe, it's an SMTP server
<eta>
I can't make all SMTP clients in the world use ZMQ, sadly :P
<phoe>
ouch! my condolences
<eta>
phoe, hey, this is supposed to be a fun side project >_<
<Shinmera>
internet protocols are never a fun side project.
* Shinmera
just published an rss/atom lib today
<phoe>
yeah, I don't mean to discourage you or anything
<eta>
Shinmera, ah, but RSS is a uniquely bad disaster
<Shinmera>
Pretty standard fare for internet, in my opinion.
<phoe>
it's just that mailservers are damn complicated because SMTP itself is damn complicated
<Shinmera>
You ain't seen HTTP specs yet
<eta>
phoe, nah, SMTP seems pretty easy
<eta>
the hard part seems like MIME
<Shinmera>
eta: have you looked at cl-smtp, the client implementation?
<eta>
I just realised that's a really inefficient way of doing it
efm has quit [Read error: Connection reset by peer]
<TwoNotes>
phoe, that Idiot's Guide looks useful. ty
efm has joined #lisp
iAmDecim has joined #lisp
<jackdaniel>
speaking of classes and their names, is it conforming to expect, that metaclass is available *by name* (find-class) immedietely after the primary method for finalize-inheritance is called? (i.e in the after method)
efm_ has joined #lisp
shangul has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
<jackdaniel>
if finalization is performed in initialize-instanc, and name is associated after make-instance finishes (i.e in ensure-class), then that would fail
gko has joined #lisp
efm has quit [Ping timeout: 260 seconds]
retropikzel has joined #lisp
shangul has joined #lisp
<beach>
I find that I am too tired to even understand what you mean. If it can wait until tomorrow, I'll be in much better shape.
<jackdaniel>
alright, thank you
gko_ has quit [Ping timeout: 265 seconds]
<jackdaniel>
if I don't crack it myself today I'll bother you :)
<beach>
Sounds good.
<beach>
I am off to fix dinner for my (admittedly small) family, and then spend time with her. I'll be back tomorrow morning (UTC+2).
efm_ has quit [Client Quit]
<jackdaniel>
see you o/
gko_ has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
mangul has joined #lisp
efm has joined #lisp
Kundry_Wag has joined #lisp
mangul has quit [Remote host closed the connection]
gko has quit [Ping timeout: 250 seconds]
shangul has quit [Ping timeout: 250 seconds]
shangul has joined #lisp
mikecheck has left #lisp ["part"]
iridioid has joined #lisp
shangul has quit [Ping timeout: 240 seconds]
Jeanne-Kamikaze has joined #lisp
shangul has joined #lisp
mangul has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
hylisper has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
<phoe>
jackdaniel: I think the class itself should be available by name only after ENSURE-CLASS is about to finish its operation
<phoe>
but let me dig into the MOP...
<jackdaniel>
that's my impression too
<phoe>
"The proper name of the newly created class metaobject is set to name."
<phoe>
what does it mean that "the proper name is set"
<Xach>
phoe: i never knew about *print-gensym*, thanks!
<phoe>
does it mean SETF FIND-CLASS is called with the name and the instance to associate the symbol and the instance?
<phoe>
Xach: ha! seriously?
<Xach>
seriously
<Xach>
just when you think you've seen most symbols...
<phoe>
well, glad to be of service
<jackdaniel>
phoe: class-name
<phoe>
jackdaniel: ooh, that.
<phoe>
Then this passage doesn't meant what I think it meant.
<jackdaniel>
afair it is defiend in defclass
<phoe>
but then again, it's not required to call DEFCLASS to have SETF FIND-CLASS called
<phoe>
user can call ENSURE-CLASS-USING-CLASS themselves
<jackdaniel>
class name is "proper" when (eq #1=(class-name class) (class-name (find-class #1# nil))) roughly speaking
q3d has joined #lisp
<phoe>
I see! so this implies that FIND-CLASS must work at that moment
<jackdaniel>
no, see the second argument
<phoe>
hm
<phoe>
one second though
<jackdaniel>
if the class is associated with its name after creation, then it is not conforming to expect that it is accessible by its name immedietely after its metaclass is finalized
<jackdaniel>
I suppose I have my conclusion. I know why it works on SBCL, but that's beside the point.
<phoe>
"The proper name of the newly created class metaobject is set to name. The newly created class metaobject is returned."
<phoe>
if the proper name is set, then it means that both CLASS-NAME and FIND-CLASS of that name must work *after* proper name is set
<phoe>
but not earlier than that
<jackdaniel>
sure
<phoe>
and there are no steps defined in the MOP between setting the name and returning the class metaobject
<jackdaniel>
I think that my question was misunderstood, but I'm also tired after long time to try to rephrase
<phoe>
OK - you got your answer, I'll not push that further
hiroaki has joined #lisp
* phoe
works on translating cl:conditions to pcs:conditions
rozenglass has joined #lisp
cage_ has joined #lisp
cage_ has quit [Client Quit]
cage_ has joined #lisp
cage_ has quit [Client Quit]
buffergn0me has joined #lisp
<jcowan>
phoe, shka: Doomsday would be better than Day of Judgment
g0d_shatter has joined #lisp
gareppa has joined #lisp
dddddd has joined #lisp
gareppa has quit [Remote host closed the connection]
rozenglass has quit [Ping timeout: 240 seconds]
joshcom has joined #lisp
q3d has quit [Ping timeout: 240 seconds]
joshcom has quit [Remote host closed the connection]
joshcom has joined #lisp
mangul has quit [Quit: Leaving]
mangul has joined #lisp
tutti has quit [Ping timeout: 256 seconds]
<flip214>
ESRAP is quite slower than CL-PPCRE - but much better to read! Using sprof reveals that 46% of time is spent in "LABELS ESRAP::RULE/TRANSFORM :IN ESRAP::COMPILE-RULE".
<flip214>
Is there some separate step to get the grammer compiled for good?
<flip214>
I'd have expected the rules to be compiled to simple functions that walk the input string... seems that there's much more going on
gko_ has quit [Ping timeout: 256 seconds]
Blukunfando has quit [Ping timeout: 256 seconds]
<scymtym>
flip214: one of the goals nikodemus had for esrap was to not COMPILE rules but use the "tree of closures" compilation technique. that's the reason a closure made in COMPILE-RULE is executed at runtime. i will make that part a bit more efficient, but the biggest time sinks are result structures and the cache anyway
joshcom has quit [Remote host closed the connection]
joshcom has joined #lisp
didi has joined #lisp
<didi>
When should one use catch/throw instead of conditions?
<flip214>
scymtym: well, but parsing a file with 87000 lines takes 2.6 sec - and 46% of that time is in COMPILE-RULE?
<flip214>
scymtym: ah, I understand what you say.
<phoe>
flip214: IIUC it's not in COMPILE-RULE itself
<phoe>
it is inside some local function that was returned from COMPILE-RULE
<phoe>
didi: performance
<jackdaniel>
didi: when you want to implement a dynamic emergency exit
<jackdaniel>
(i.e you have recursive alpha-beta algorithm and you've found an answer with maximum score)
<didi>
phoe: Thank you.
<flip214>
well, is there some way to make it faster? I've got files with several million lines to parse as well... and CL-PPCRE "only" compiles to closures as well and is still much faster?!
<didi>
jackdaniel: Thank you.
<eta>
are there any buffered stream things?
<phoe>
technically speaking, a dynamic emergency exit like the one jackdaniel mentioned is possible to implement in conditions, (handler-case (some-form) (get-me-out-of-here ())) and then (signal 'get-me-out-of-here) anywhere in the dynamic extent of (some-form)
<phoe>
;; and it even won't crash, unlike a throw with no matching catch tag
tutti has joined #lisp
<phoe>
however, walking the handler stack is costly
<didi>
oic
<phoe>
that gist by nikodemus mentions the performance hit if you perform a *lot* of backtracking via condition handling
<phoe>
for a single transfer of control, the difference will likely be negligible
mangul has quit [Ping timeout: 256 seconds]
<phoe>
for hundreds, thousands, millions - it'll stack and heavily slow your stuff down
jason_m has joined #lisp
<jackdaniel>
how about billions?
<jackdaniel>
will it work fast?
jayspeer has quit [Ping timeout: 265 seconds]
<phoe>
jackdaniel: if your implementation is 32-bit, then it might speed back up just after you pass four billion - 4294967296 to be exact
<phoe>
but, as always, measure
g0d_shatter has quit [Quit: Leaving]
wheelsucker has joined #lisp
joshcom has quit [Remote host closed the connection]
joshcom has joined #lisp
shukryzablah has left #lisp ["ERC (IRC client for Emacs 27.0.90)"]
z147 has joined #lisp
<flip214>
when TIME says (on sbcl) "269 lambdas converted", does that mean that these lambda were not compiled before?
test` has quit [Remote host closed the connection]
keep_learning has joined #lisp
C-Keen has quit [Quit: WeeChat 2.6]
Jesin has quit [Quit: Leaving]
davd has joined #lisp
Jesin has joined #lisp
izh_ has quit [Quit: Leaving]
wheelsucker has quit [Ping timeout: 250 seconds]
arduo has joined #lisp
davd has quit [Remote host closed the connection]
davd has joined #lisp
penguwin has quit [Quit: NO CARRIER]
penguwin has joined #lisp
davd has quit [Remote host closed the connection]
joshcom has quit [Ping timeout: 264 seconds]
TwoNotes has quit [Quit: Leaving]
dmiles has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 265 seconds]
fadieller has joined #lisp
<fadieller>
how are m expressions different? they just use [] instead of ()?
<scymtym>
flip214: replying to "and cl-ppcre …": as i said, the "tree of closures" technique is /not/ the worst bottleneck, so "cl-ppcre is fast therefore esrap should be fast" is invalid
<scymtym>
esrap is a slow parser. partly due to its architecture and partly due to its implementation. i have been working on eliminating some of the reason on the implementation side, but the speedups have been moderate
fadieller has quit [Quit: fadieller]
efm has quit [Quit: Konversation terminated!]
<scymtym>
flip214: regarding "lambdas converted", since esrap does not call COMPILE, it has to be something else such as generic functions being called for the first time or after methods have changed. in case of compiler invocations within generic function dispatch, just rerunning the benchmark should make the compiler invocations disappear
<scymtym>
flip214: regarding the optimizations you tried: the cache can be disabled per-rule with the (:cache nil) option. esrap also disables the cache automatically if it can determine that it is safe to do so and the rule expression in question is simple enough. compiling things with (speed 3) may help, but that is a decision i would rather leave to the library user
jayspeer` has joined #lisp
ym has joined #lisp
jayspeer has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: Quit.]
jayspeer has joined #lisp
cosimone has joined #lisp
jayspeer` has quit [Ping timeout: 256 seconds]
mr_yogurt has joined #lisp
orivej has quit [Ping timeout: 250 seconds]
Kundry_Wag has joined #lisp
pilne has joined #lisp
dmiles has joined #lisp
Lord_of_Life_ has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
notzmv has quit [Ping timeout: 256 seconds]
retropikzel has quit [Quit: Leaving]
karlosz has quit [Ping timeout: 258 seconds]
notzmv has joined #lisp
notzmv is now known as Guest52582
karlosz has joined #lisp
mikecheck has joined #lisp
jayspeer` has joined #lisp
ardoc has joined #lisp
frgo has quit [Remote host closed the connection]
gravicappa has quit [Ping timeout: 240 seconds]
frgo has joined #lisp
jayspeer has quit [Ping timeout: 250 seconds]
arduo has quit [Ping timeout: 256 seconds]
ardoc` has joined #lisp
pve has quit [Quit: leaving]
ardoc has quit [Ping timeout: 256 seconds]
jayspeer` has quit [Ping timeout: 250 seconds]
whiteline has quit [Remote host closed the connection]
z147 has quit [Quit: z147]
whiteline has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
ardoc` has quit [Ping timeout: 264 seconds]
karlosz has quit [Client Quit]
karlosz has joined #lisp
akoana has joined #lisp
cosimone has quit [Quit: Quit.]
rand_t has joined #lisp
cosimone has joined #lisp
KindTwo has joined #lisp
KindTwo has quit [Max SendQ exceeded]
iridioid has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
refpga` has quit [Remote host closed the connection]
KindTwo has joined #lisp
cosimone has quit [Quit: Quit.]
KindTwo has quit [Max SendQ exceeded]
shifty has joined #lisp
Oladon has joined #lisp
Guest52582 is now known as notzmv
whiteline has quit [Read error: Connection reset by peer]
whiteline has joined #lisp
whiteline has quit [Remote host closed the connection]