dec0d3r has quit [Remote host closed the connection]
thomaslewis has joined #commonlisp
taiju has joined #commonlisp
epolanski has joined #commonlisp
waleee has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Devon has joined #commonlisp
Lord_of_Life has joined #commonlisp
taiju has quit [Ping timeout: 260 seconds]
Inline has quit [Ping timeout: 264 seconds]
Skyfire has quit [Quit: brb]
Skyfire has joined #commonlisp
Devon has quit [Read error: Connection reset by peer]
Devon has joined #commonlisp
random-nick has quit [Ping timeout: 245 seconds]
Bike has joined #commonlisp
karlosz has joined #commonlisp
taiju has joined #commonlisp
paule32 has quit [Ping timeout: 260 seconds]
mfiano_ has joined #commonlisp
mfiano_ has quit [Remote host closed the connection]
mfiano_ has joined #commonlisp
akoana has joined #commonlisp
ec_ has joined #commonlisp
mfiano_ has quit [Remote host closed the connection]
mfiano has quit [Remote host closed the connection]
mfiano has joined #commonlisp
mfiano has quit [Read error: Connection reset by peer]
mfiano has joined #commonlisp
ec_ is now known as ec
Oladon has joined #commonlisp
s-liao has joined #commonlisp
domovod has joined #commonlisp
vats has quit [Ping timeout: 264 seconds]
srhm has quit [Ping timeout: 268 seconds]
peterhil has quit [Remote host closed the connection]
domovod has quit [Ping timeout: 260 seconds]
pranavats has left #commonlisp [#commonlisp]
Bike has quit [Quit: Connection closed]
hendursaga has quit [Quit: hendursaga]
hendursaga has joined #commonlisp
waleee has quit [Ping timeout: 264 seconds]
lisp123 has joined #commonlisp
pranavats has joined #commonlisp
Bike has joined #commonlisp
s-liao has quit [Quit: Client closed]
Josh_2 has quit [Ping timeout: 268 seconds]
s-liao has joined #commonlisp
Guest93 has joined #commonlisp
Guest93 has quit [Quit: Client closed]
<beach>
Good morning everyone!
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
bcasiello has joined #commonlisp
Bike has quit [Quit: Bike]
taiju has quit [Ping timeout: 264 seconds]
semz has quit [Ping timeout: 264 seconds]
taiju has joined #commonlisp
taiju has quit [Ping timeout: 260 seconds]
taiju has joined #commonlisp
semz has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
taiju has quit [Ping timeout: 260 seconds]
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
lisp123 has quit [Ping timeout: 260 seconds]
taiju has joined #commonlisp
bcasiello has quit [Ping timeout: 264 seconds]
Skyfire has quit [Quit: brb broken config]
Skyfire has joined #commonlisp
mrcom_ has quit [Read error: Connection reset by peer]
mrcom_ has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
ec has quit [Ping timeout: 276 seconds]
ec has joined #commonlisp
x-x has joined #commonlisp
epolanski has quit [Quit: Connection closed for inactivity]
akoana has left #commonlisp [#commonlisp]
s-liao has joined #commonlisp
taiju has quit [Ping timeout: 260 seconds]
s-liao has quit [Ping timeout: 256 seconds]
taiju has joined #commonlisp
phantomics has quit [Quit: Ex-Chat]
gin has joined #commonlisp
<gin>
found this question in an interpreters book - "Most Lisp implementations that compile to C also contain an interpreter that lets them execute Lisp code on the fly as well. Why?"
<gin>
need help in understanding this. why?
Oladon has quit [Quit: Leaving.]
<hayley>
I can't think of very many Lisp implementations that compile to C these days.
<hayley>
If you have a Lisp implementation which uses its own compiler backend, and an implementation which uses a C compiler as a backend, you could do an experiment and observe how fast each compiler is.
<hayley>
...and then, compare that to an implementation which doesn't generate native code ever (such as CLISP). Something like (time (dotimes (i 100) (compile nil '(lambda () 2)))) should give you that information.
<gin>
hayley: okay. I want to understand the latter part of that question. why do implementations also contain an interpreter to execute Lisp code on the fly? is it to support interactive development?
<hayley>
Not necessarily, you could compile every form evaluated.
<hayley>
I don't really see why they needed to specify that the Lisp implementation should generate C code, but I guess what I am thinking of is more significant with a C compiler.
s-liao has joined #commonlisp
<gin>
ok. thanks for the insight.
lisp123 has joined #commonlisp
<hayley>
I think I know the answer, but it isn't very enlightening on its own. And the question is silly, because you can still execute "on the fly" with a compiler.
<hayley>
(Say, EVAL could be implemented like (defun eval (form) (funcall (compile nil `(lambda () ,form)))) if you only have a compiler.)
<beach>
Perhaps it is considered slow to generate C code, compile a file, and load the resulting binary, so that this technique would be reserved for COMPILE-FILE.
<beach>
But which Common Lisp implementations other than ECL compile to C?
lisp123 has quit [Ping timeout: 245 seconds]
<beach>
gin: When was the book published?
<hayley>
That is what I was thinking of, but it's also not certain that the C compiler is slower than a Lisp compiler (though, practically, the C compiler is slower). And then some Lisp implementations with their own backends, like SBCL, still use an interpreter for EVAL.
<hayley>
beach: 2021.
<beach>
hayley: Oh, you know which book was referred to?
<hayley>
beach: Yes, it's in the question section of Chapter 2 of Crafting Interpreters.
<gin>
anyway seems like it is not useful to think about that question too much
<beach>
Right.
<beach>
I was asking about the date, because a few decades ago, it might have been to slow to do the C file compilation for interactive evaluation. But not anymore.
<hayley>
I performed the experiment I described, and ECL (using GCC) is at least three magnitudes slower than SBCL at compilation. But repeatedly compiling (LAMBDA () 2) is perhaps too simple, if we want to model the sorts of forms entered at a REPL.
<hayley>
Or, since we are more concerned with absolute times, it appears ECL took 180ms to compile on average, which is not very long, but not as "instantaneous" as one might like it to be.
<beach>
Sure. But it would be interesting to know how the author established the basis for the question.
<hayley>
Yes, definitely.
horar has joined #commonlisp
<jackdaniel>
I think that a fairer comparison would be compiling some library with empty cache. ecl still will be slow, but not 3 magnitudes slower
<jackdaniel>
when you take small compilation target then gcc startup time shows easily
<beach>
jackdaniel: But the interesting comparison was for interactive evaluation of forms.
<jackdaniel>
sure, but then ecl doesn't invoke gcc but bytecompiler
<jackdaniel>
unless you explicitly call (compile '(lambda …))
<jackdaniel>
and that is not the typical scenario for interactive evaluation
<beach>
I think that's what the question is referring to.
<hayley>
Yes, I was calling COMPILE, because that is described as the alternative to having a bytecode evaluator or a naive interpreter for interactive evaluation.
<jackdaniel>
I see
<jackdaniel>
it is worth noting, that using tcc would shorted that time too (so it is not only whether you compile with c - it is also what compiler you use)
<hayley>
Right again.
<hayley>
You have more options than naive interpretation and running an optimising compiler, such as bytecode or a faster compiler, and then you could (with some error) statically guess which evaluator would be the fastest, or use runtime metering.
<jackdaniel>
as of implementations that compile to c (besides ecl): gcl and mkcl, but all three are direct or indirect offsprings from kcl
<jackdaniel>
both are interesting for comparison, because gcl interprets forms in the repl (i.e walks them) while mkcl statically links tcc (if I remember correctly), so each exhibits a different strategy to working with repl
<jackdaniel>
bytecodes vm, interpretation and compilation to c
<beach>
Interesting.
<beach>
The question still seems to be like the author just want to push the agenda that learning about interpreters is important.
mjoerg has joined #commonlisp
<jackdaniel>
I suppose that when you have a website that has "interpreters" in domain you believe that they are at least somewhat relevant :)
<jackdaniel>
s/domain/domain then/
pve has joined #commonlisp
<beach>
Exactly.
<hayley>
interpreters-stink.com (an illustrative domain which hopefully doesn't exist)
mjoerg has quit [Remote host closed the connection]
<jackdaniel>
if you proactively dislike something then it means that it is relevant enough for you to try to deter other people from it ;]
<hayley>
With the .sucks TLD you can also do interpretation.sucks, but that is more expensive.
igemnace has joined #commonlisp
<pve>
Good morning! I need to wait around for a few hours every week at my local library. Ususally I just read, but recently I figured I might use the time to try to sketch out some code in a notebook, and implement later when I get home. The only problem is, it doesn't come naturally to me (probably due to lack of practice).
<pve>
Does anyone here design (CL) programs on pen and paper? Do you have a "system" that works?
<jackdaniel>
I often scribble in my notebook, but it is a mixed notation with blocks, arrows and some lisp code (without parenthesis)
<hayley>
I think I did once, but it was for a fairly "mathematical" program, and I wrote it all in M-expressions.
<jackdaniel>
usually to improve my understanding of a problem I'm thinking about (not to write a complete program) -and some prose to write down some requirements and suggestions for myself
rgherdt has joined #commonlisp
hendursa1 has joined #commonlisp
<pve>
ah, thanks
hendursaga has quit [Ping timeout: 276 seconds]
<pve>
yeah, I was thinking of some kind of high-level description of the program
<jackdaniel>
that said if I had some free time in a library I'd engage in studying some math book (if you haven't read it yet then you can't go wrong with concrete mathematics)
<pve>
that's not a bad suggestion either
notzmv has quit [Ping timeout: 260 seconds]
contrapunctus has left #commonlisp [#commonlisp]
igemnace has quit [Remote host closed the connection]
contrapunctus has joined #commonlisp
<gin>
is there any article on what forms the core of Lisp? I mean what is the minimal subset of Lisp I need to implement so that rest of the Lisp can be expressed in terms of the subset?
<beach>
There is no unique such subset.
<beach>
gin: But why would you want to do that?
<gin>
I am still a beginner to lisp but I think if I successfully implement LAMBDA at the interpreter level, then I don't need to implement LET in the interpreter. LET can be implemented as a Lisp code over LAMBDA? am I right?
<pjb>
gin: you can study lambda calculus, and have fun implementing CL in lambda calculus.
<hayley>
Arguably, you only need function creation, function application, and a way to access variables, or a Turing machine, or the S and K combinators...
<gin>
beach: for learning purpose. keep the core small.
<hayley>
Yes, you can rewrite LET to LAMBDA.
<jackdaniel>
gin: if you are interested in "how to implement this and this that is also used in lisp" you may want to read the book "lisp in small pieces"
<beach>
gin: What are you writing this Lisp implementation in?
<gin>
beach: I thought of C. but if there are any good suggestions I will take it.
<jackdaniel>
gin: write it in common lisp
<jackdaniel>
otherwise it will be offtopic here ,-)
<beach>
gin: I am afraid I have no advice to give. I would not consider implementing Lisp from a subset.
<gin>
beach: how would you do it then? not worry about a subset at all and implement all special forms as the "core" of the interpreter/compiler?
azimut has quit [Ping timeout: 276 seconds]
<beach>
minion: Please tell gin about SICL.
<minion>
gin: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<beach>
gin: We use the full Common Lisp language to implement each module, and then we bootstrap on a Common Lisp implementation.
<gin>
beach: I know about SICL :) you are implementing SICL as an expert. I am going to implement a toy lisp for learning purpose.
<beach>
Sure, but you asked me how I would do it.
azimut has joined #commonlisp
<beach>
gin: I suggest you look at my videos about implementing Common Lisp.
<beach>
They should be archived somewhere.
<jackdaniel>
gin: study the book lisp in small piecies - I believe that this is what you seek
<beach>
I gave them in the context of phoe's online Lisp meeting.
<gin>
ok
<gin>
thanks jackdaniel. I think i will start with lisp in small pieces.
<beach>
gin: The tricky part is going to be the evaluator.
<beach>
gin: It requires a lot of knowledge about the semantics of Lisp.
horar has quit [Quit: Client closed]
<jackdaniel>
and there is also islisp that is factually a subset of common lisp (despite having its own iso standard)
<beach>
gin: And about how evaluators are written.
<gin>
thanks for the mention about islisp. i did not know it.
<gin>
i was thinking of writing a simple tree walker to visit each node in the tree and just evaluate on the fly. bad idea?
<beach>
gin: How are you going to represent the global environment, the lexical environment, and the dynamic environment?
<beach>
Though, since it's not Common Lisp, I guess you can make simplifications.
<beach>
gin: Like if you have (let ((x 234)) (let ((x 345)) (+ x 1))), how do you know which X the inner one refers to when you reach that place in the tree?
Inline has joined #commonlisp
<beach>
gin: I should probably stay out of this discussion. I am afraid I might spoil your enthusiasm if I give advice. I suggest you try out your original idea and come back when you feel you are stuck.
<MichaelRaskin>
Stuck and unable to revise the scope, that is, because a very minimal interpreter is quite feasible.
<gin>
beach: thank you for the advice. i will do that.
dec0d3r has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
cosimone has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
cosimone has quit [Client Quit]
cosimone has joined #commonlisp
notzmv has joined #commonlisp
varjag has joined #commonlisp
amb007 has joined #commonlisp
random-nick has joined #commonlisp
amb007 has quit [Ping timeout: 264 seconds]
lisp123 has joined #commonlisp
s-liao has quit [Quit: Client closed]
s-liao67 has joined #commonlisp
lisp123 has quit [Ping timeout: 260 seconds]
mrcom_ has quit [Quit: This computer has gone to sleep]
mrcom has quit [Quit: This computer has gone to sleep]
amb007 has joined #commonlisp
varjag has quit [Ping timeout: 260 seconds]
s-liao67 has quit [Quit: Client closed]
s-liao has joined #commonlisp
Guest715 has joined #commonlisp
Guest715 has left #commonlisp [#commonlisp]
Lycurgus has joined #commonlisp
varjag has joined #commonlisp
horar has joined #commonlisp
horar has quit [Client Quit]
tyson2 has joined #commonlisp
karlosz has quit [Ping timeout: 264 seconds]
Lycurgus has quit [Quit: Exeunt]
amb007 has quit [Ping timeout: 264 seconds]
amb007 has joined #commonlisp
pranavats has left #commonlisp [#commonlisp]
s-liao has quit [Ping timeout: 256 seconds]
taiju has quit [Read error: Connection reset by peer]
gxt_ is now known as gxt
taiju has joined #commonlisp
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
McParen has left #commonlisp [#commonlisp]
s-liao has joined #commonlisp
Bike has joined #commonlisp
Bike has quit [Quit: Connection closed]
Bike has joined #commonlisp
peterhil has joined #commonlisp
mfiano has quit [Remote host closed the connection]
mfiano has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
lisp123_win has joined #commonlisp
<lisp123_win>
If I have a macro that uses a function (prior to the macroexpansion form), I need to put the function into an eval-when
<lisp123_win>
A couple of questions; (a) do I need to put the function definition above (before) the macro?
<lisp123_win>
(b) I didn't seem to get an error when I forgot to wrap the function around eval-when --> is that expected or is there some other issue with my code that I may have missed?
<mfiano>
You do not need to put the function in an eval-when if the call to the macro is before the function.
<mfiano>
The macro itself could be after the function. It doesn't matter
<lisp123_win>
mfiano: other way round, macro is calling the function
<mfiano>
You only need an eval-when when the call, thus the expansion, is before any function defined using it.
<_death>
you don't need to use eval-when if uses of the macro are in a different file
<jackdaniel>
mfiano: doesn't he talk about (defmacro with-foo (…) (let ((something (function-must-be-available-now!))) `(…))
<mfiano>
Or put it in a different file to be sure.
<lisp123_win>
_death: Yes, understood. Assume we want to keep it in the same file
<mfiano>
lisp123_win: But something calls your macro. That's what I am talking about
<lisp123_win>
mfiano: Thanks, assume that is also in the same file
<mfiano>
jackdaniel: Oh I see. In that case lisp123_win, use eval-when or define the function in an earlier compilation unit.
<lisp123_win>
So with eval-when, do I still need the function to be written before the macro? And then my second question was I didn't seem to get a warning when I forgot to use eval-when, is that expected or just by chance
<mfiano>
Macros are expanded before functions are compiled.
<mfiano>
Then the functions, and any code expanded by macros are compiled afterwards.
<_death>
you don't need it written before the macro, but you do need it available when the macro is used.. so that means you need eval-when if it's in the same compilation unit
domovod has joined #commonlisp
<mfiano>
Place the function in a file that is LOAD'd earlier than the macro and you will never need eval-when.
<lisp123_win>
_death: Thanks. By "available when used" does that mean the function should be written before the macro is called?
<mfiano>
No
igemnace has joined #commonlisp
<mfiano>
In this case the function isn't being used when the macro is called, but when it is _expanded_
<mfiano>
Macro-expansion time happens before compile time
<_death>
mfiano: I think there's some confusion there.. a macro-function is called when a form is macroexpanded.. macroexpansion usually happens during compile-time
<lisp123_win>
_death: Yes, precisely. So my understanding is that the stream is read, and if the function was not defined before the macro that uses it (like in jackdaniel's example), the function's symbol will be interned during the read of the macro definition
s-liao has joined #commonlisp
<lisp123_win>
But if the macro call occurs before the function is defined within eval-when, I'm expecting an error, so wanted to confirm that?
<_death>
lisp123_win: that doesn't matter though
<jackdaniel>
when you have: (defmacro bar … (foo) …) (defun foo () …) and nothing else in the file, you don't need eval-when because foo will be called when the macro is expanded in a different file
<_death>
lisp123_win: when macroexpansion happens the macro-function is called.. if it tries to call functions that are not defined there is an issue.. so, it's fine to have the functions defined after the defmacro, but you still need eval-when to have them available at compile-time if uses of the macro (which should be after both) exist in the same compilation unit
<jackdaniel>
on the other hand when you have (defmacro bar) (defun foo) (bar) in the same file, then it will complain, because bar is expanded in the same file where bar is defined
<jackdaniel>
so you need to wrap (defun foo) in eval-when in order to have bar expanded
<jackdaniel>
it doesn't matter where in the file (eval-when … (defun foo …)) is placed
<jackdaniel>
and by file I mean compilation unit ,)
cage has joined #commonlisp
<lisp123_win>
"it doesn't matter where in the file (eval-when … (defun foo …))
<lisp123_win>
is placed" --> Why is that? Does eval-when occur before macroexpansion? I thought it was all compile-time
<_death>
jackdaniel: (bar) must come after defmacro bar and defun foo though
<jackdaniel>
_death: sure
<lisp123_win>
_death: Cool thanks for confirming! So my remaining question is that I didn't seem to get a warning when I didn't use eval-when (but the code didn't work)
<lisp123_win>
Is that "normal" (sorry its a very vague question, but for some reason my file works when I compile twice, so I assume its to do with eval-when not being used)
<beach>
lisp123_win: Try starting from a fresh image.
<_death>
lisp123_win: did you just compile or compile and load
<beach>
lisp123_win: If your file has been loaded already, then the function is defined in the image.
<lisp123_win>
beach & _death: I did from a fresh image. On the first compile / load, nothing happens, but when I then do it again, it "magically" works
<lisp123_win>
I realised I didn't have an eval-when, but didn't get an error / warning on the first compile. Sorry its very vague so maybe not worth answering
<lisp123_win>
(might be some other issue with my code)
<_death>
I don't see why you say "magically", since after loading the function is defined.. when you say "nothing happens" can you come up with a test case
domovod has quit [Ping timeout: 260 seconds]
domovod has joined #commonlisp
<lisp123_win>
_death: I was using a test suite (tests are created with macros). The tests don't exist until I compile / load the file the second time in an image, which I am thinking is because a certain function is not within eval-when so my macro is silently failing on the first attempt
s-liao62 has joined #commonlisp
<lisp123_win>
But on the second attempt, since that function is now defined, the compilation works as expected
s-liao has quit [Quit: Client closed]
<lisp123_win>
But I'm just guessing, I'll take it offline and investigate further
<beach>
lisp123_win: It would be easier to help you if you were more precise about the meaning of "nothing happens" and "magically works", like error messages, warnings, unexpected output, etc.
<beach>
Not that I plan to get involved this time. Others seem to be there for you.
<lisp123_win>
beach: Sorry, you are right. I'll try and solve this on my own (unless anybody knows whether forgetting to put a function in an eval-when is meant to cause an error or if no error is signalled during macroexpansion)
<_death>
lisp123_win: you can try it.. put defmacro,defun,use in a file and try to compile-file it
pranavats has joined #commonlisp
<jackdaniel>
lisp123_win: if you don't use this macro in the same file, then it will compile alright happily expecting that the function will be defined before the macro is expanded
peterhil has quit [Quit: Must not waste too much time here...]
<lisp123_win>
_death: Thanks, let me do that. I'll report back
<_death>
lisp123_win: if you have the same case elsewhere, and you don't see an error or warning, it might be suppressed or not there due to some other circumstance peculiar to that scenario
McParen has joined #commonlisp
<lisp123_win>
jackdaniel: Yeah, I learnt that now :) But at least I learnt how compiliation works better as a result of this
peterhil has joined #commonlisp
<lisp123_win>
_death: Thanks, good idea
amb007 has quit [Ping timeout: 245 seconds]
amb007 has joined #commonlisp
peterhil has quit [Client Quit]
lisp123 has joined #commonlisp
<lisp123>
Confirming there should be an error message
<lisp123>
Just tested it out
<lisp123>
So might be something to do with my SBCL settings on my main image / something else
<_death>
small tip, I have (setf ql:*quickload-verbose* t) in my init file
<lisp123>
_death: Thanks, I will do that going forward
s-liao62 has quit [Quit: Client closed]
casionaut has joined #commonlisp
casionaut has quit [Remote host closed the connection]
mrcom has joined #commonlisp
mrcom_ has joined #commonlisp
heisig has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
clos-encounters has joined #commonlisp
amb007 has joined #commonlisp
waleee has joined #commonlisp
epolanski has joined #commonlisp
mfiano has quit [Remote host closed the connection]
domovod has quit [Ping timeout: 245 seconds]
domovod has joined #commonlisp
xsperry has joined #commonlisp
igemnace has quit [Remote host closed the connection]
gaqwas has joined #commonlisp
cage has quit [Remote host closed the connection]
taiju has quit [Ping timeout: 264 seconds]
taiju has joined #commonlisp
cage has joined #commonlisp
varjag has quit [Ping timeout: 246 seconds]
Jing has joined #commonlisp
waleee has quit [Ping timeout: 268 seconds]
anddam has quit [Quit: WeeChat 3.3]
Jing_ has joined #commonlisp
Jing has quit [Quit: Client closed]
Inline_ has joined #commonlisp
Inline has quit [Ping timeout: 245 seconds]
Inline_ has quit [Remote host closed the connection]
Inline has joined #commonlisp
attila_lendvai has joined #commonlisp
khrbt has quit [Ping timeout: 264 seconds]
khrbt has joined #commonlisp
tyson2 has joined #commonlisp
mfiano has joined #commonlisp
waleee has joined #commonlisp
khrbt has quit [Ping timeout: 260 seconds]
mallkrampus has quit [Ping timeout: 264 seconds]
waleee has quit [Ping timeout: 260 seconds]
Bike has quit [Quit: Connection closed]
mallkrampus has joined #commonlisp
bcasiello has joined #commonlisp
dra has joined #commonlisp
heisig has quit [Quit: Leaving]
peterhil has joined #commonlisp
sbodin has joined #commonlisp
domovod has quit [Ping timeout: 245 seconds]
Bike has joined #commonlisp
khrbt has joined #commonlisp
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 260 seconds]
X-Scale` is now known as X-Scale
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
sbodin has quit [Quit: -a- IRC for Android 2.1.59]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lotuseater has joined #commonlisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
euandreh has quit [Ping timeout: 264 seconds]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #commonlisp
karlosz has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
igemnace has joined #commonlisp
Oladon has joined #commonlisp
akoana has joined #commonlisp
mariari has quit [Quit: WeeChat 3.3]
notzmv has quit [Read error: Connection reset by peer]
<hayley>
The results are somewhat interesting: CL-PPCRE is about as fast as PCRE2 without its JIT, and my regular expression engine has about 1.7× the throughput on PCRE2 with JIT (on this admittedly very contrived test).
mrcom_ has quit [Read error: Connection reset by peer]