<afidegnum>
coming from other langauges, i m struggling to adjust here,
<asdf_asdf_asdf>
On the bottom.
<no-defun-allowed>
asdf_asdf_asdf: Do you expect everyone here to understand Polish and Java?
<afidegnum>
:D
<asdf_asdf_asdf>
OK.Let it be.
<no-defun-allowed>
Vectors are probably the most common sequence type in other languages, but they usually support linked lists too.
<afidegnum>
yes. the syntax is kind of confusing me, but i m forcing to settle in
<afidegnum>
ok, let's start with array first,
<afidegnum>
(setf x (make-array '(3 3) here, means we are seting a 3 list containing 3 elements, right ?
<no-defun-allowed>
The usual signature for a function that makes a sequence called <sequence> is (make-<sequence> <length> :initial-element <element>).
<afidegnum>
good
<no-defun-allowed>
(make-array '(3 3)) makes a two-dimensional, 3x3 array.
<afidegnum>
ok,
<no-defun-allowed>
So to create an array with just 3 elements, you want (make-array 3)
<no-defun-allowed>
asdf_asdf_asdf: Another difference between Java linked lists and Lisp linked lists is that the former has a container object over the conses, whereas Lisp has no container over them and you just manipulate conses.
<no-defun-allowed>
Typically, changing a Lisp list (and I say typically, there are legitimate reasons to mutate) produces a new list too, rather than changing the old list.
<asdf_asdf_asdf>
Thanks for figured out/described.
refpga has quit [Ping timeout: 240 seconds]
refpga has joined #lisp
<afidegnum>
(setq a "a") is this ok for a vector ?
<no-defun-allowed>
You would be replacing the value bound to A, which would not affect the vector.
<afidegnum>
?
<no-defun-allowed>
setf/setq doesn't affect the binding (unless you provide a place to setf -- actually, let's just stick to setq)...
<afidegnum>
can you assist in possibilites and examples of vectors?
<no-defun-allowed>
Try (let* ((a (make-array 3)) (b a)) (setq a "a") b)
<no-defun-allowed>
You'll see that the vector that A and B are bound to is still intact and unchanged, but only the binding for A changed.
<afidegnum>
#(0 0 0)
<White_Flame>
afidegnum: btw, lists, alists, and plists are the same basic datatype, just singly linked lists. list = (1 2 3), a-list = ((key . val) (key . val)...), p-list = (key val key val key val...)
<White_Flame>
alist and plist are just a convention for holding key/val lists in a plain list
<White_Flame>
s/lists/pairs/
<afidegnum>
ok, let's say White_Flame ok, it's clearer
<afidegnum>
what about arrays and vectors?
<White_Flame>
a vector is a 1-dimensional array
<White_Flame>
arrays can have any number of dimensions, from 1 to irresponsibly-big
<White_Flame>
arrays can have any number of dimensions, from *0* to irresponsibly-big
<afidegnum>
i'm condering like a strict dictionry containing no list, is it correcet?
<afidegnum>
*correct?
<White_Flame>
CL's "dictionary" type is the hash-table
<afidegnum>
can you expand with your previous analogy? that's much clearer
<afidegnum>
the list, alist, plist thing :)
<White_Flame>
before hashtables existed, people stuffed key/value pairs in plain lists
<afidegnum>
ok
<White_Flame>
in the formats I exampled above
frgo has quit [Ping timeout: 268 seconds]
<White_Flame>
the functions for accessing key/val pairs in alist or plist format are part of the common lisp standard
<White_Flame>
but they're just still plain lists
GoldRin has joined #lisp
<afidegnum>
ok
<afidegnum>
so how do we match a vector against a value?
<White_Flame>
lisp doesnt' have built-in match operations like prolog or erlang do
<afidegnum>
what about binding?
khisanth_ has quit [Ping timeout: 240 seconds]
<random-nick>
binding what?
<White_Flame>
LET does binding, function parameters are bindings, etc
<Inline>
you loop across the vector and across the input testing for equality in parallel
g_o has joined #lisp
<White_Flame>
lisp's dynamic bindings are fairly unique. per-thread, scope-based bindings of otherwise "global" variables
<Inline>
i.e. element by element for example
eSVGDelux has quit [Ping timeout: 245 seconds]
<afidegnum>
i think where the nuance persist is the difference between variable, symbol and vector
g_o has quit [Client Quit]
Demosthenex has quit [Ping timeout: 265 seconds]
<afidegnum>
why is my message blinking ?
<White_Flame>
that would be something local to your irc client
jonatack has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 240 seconds]
<White_Flame>
what does "vector" seem to you, because it's quite a bit different than variables or source code symbols
<White_Flame>
and are quite common data structures across many languages
<afidegnum>
vectors reminds me of Geometry :D
<White_Flame>
vectors are not math constructs in CL, altough there are complex numbers which can sort of be 2-dimensional numbers in math
<White_Flame>
(which are a separate datatype from vector)
<afidegnum>
ok
niceplaces has joined #lisp
niceplace has quit [Ping timeout: 265 seconds]
scymtym has joined #lisp
<White_Flame>
if you have a lot of fundamental questions about CL, then #clschool might be more appropriate, as here you'll get a lot of in-depth answers that assume you already know the rest of the language
<afidegnum>
thanks let me enroll :)
khisanth_ has joined #lisp
Demosthenex has joined #lisp
<afidegnum>
ah, but wait, isn't vector the same as list ?
<pjb>
White_Flame: arrays and vectors are as mathematical in CL as numbers and any other lisp data structure. Granted, CL arrays are a tad richer a data structure than usual mathematical vectors, matrices, etc (eg. adjustable, fill-pointers, etc), but as programming entities, they're perfectly defined mathematically.
<pjb>
We're talking formal system here…
g_o has joined #lisp
prite has quit [Ping timeout: 245 seconds]
<White_Flame>
there's no mathematical operations on arrays themselves in CL
prite has joined #lisp
<pjb>
White_Flame: rank, dimensions are mathematical operations applying on math arrays. They existin in CL: array-dimensions, array-rank.
<White_Flame>
those are just readers
<pjb>
White_Flame: notice that mathematically, the operations depend on groups which are separate from the "data structure".
<beach>
afidegnum: No, a vector is a sequence of consecutive cells in memory, each cell being able to hold one object.
<pjb>
So I consider that we can accept that CL doesn't pre-define those operations, because this would mean choosing some specific group. Several are possible.
<afidegnum>
no i mean List in Python
wxie has joined #lisp
<beach>
afidegnum: Whereas a list is a linked data structure, each element being a CONS, containing one cell for the element and one cell for pointing to the next CONS.
<no-defun-allowed>
A Python list is closer to a Lisp vector than a Lisp list.
<afidegnum>
ok
<no-defun-allowed>
But a Python list is implemented in a weird way I don't know the specifics of, probably closer to a Lisp list of "segments" which are Lisp vectors.
<beach>
afidegnum: But, as I recall, you can insert and delete elements from a Python list, but you can't (easily) from a Common Lisp vector.
<pjb>
White_Flame: for example, (ℤ,+) is implemented in CL with (CL:INTEGER CL:+), but not in C with (int +) which implements another group: (ℤ/2^p,+).
<no-defun-allowed>
Yeah, you can write `del lst[n]` and that removes it from the list.
<beach>
afidegnum: Usually, what they call "list" in so-called scripting languages is a sequence that supports insert and delete, and it is usually implemented as some kind of tree structure.
<g_o>
Hey how do i make an alien routine that returns a c int? sbcl
<beach>
g_o: In order of preference: 1. Don't use alien code. 2. Use CFFI. 3. [if you absolutely have to] use implementation-specific techniques.
<g_o>
beach: unfortunately, i have to use sb-alien =(
<afidegnum>
in a nutshell, a vector, if not a single unit, haave its elements in "[]" can be accessed using (aref [] position), am i correct ?
<no-defun-allowed>
For example: (cffi:defcfun "getpid" :int) defines GETPID, which returns your Lisp process's process ID.
<no-defun-allowed>
Yes, you can use AREF to index an array.
<no-defun-allowed>
g_o: Seriously? How come?
<beach>
afidegnum: What do you mean by "if not a single unit"?
frgo has joined #lisp
<no-defun-allowed>
If your vector has one element, then the only thing you should try on it is (aref <vector> 0)
nowhereman has quit [Ping timeout: 240 seconds]
<g_o>
no-defun-allowed: im trying to work on an sb-alien issue, embarrassingly enough im starting to wrap my head around the internals, but never tried simply returning an int
<afidegnum>
ok
<beach>
afidegnum: And, yes, as no-defun-allowed says, you access the elements of a vector using AREF or some related operation. Again, a vector is a sequence of consecutive cells in memory, and they are numbered from 0 up to length-1.
prite has quit [Ping timeout: 240 seconds]
<beach>
g_o: For SBCL-specific questions, people in #sbcl might know more.
<afidegnum>
ok
<beach>
afidegnum: What do you mean by "if not a single unit"?
<afidegnum>
i mean one element
<no-defun-allowed>
g_o: I see. I don't think I can help then, but I wish you the best of luck.
<g_o>
beach: it's true but it appears that sbcl just used cmucl's module; which supposedly hang around here (if they're still alive)
<beach>
afidegnum: Then you also use AREF.
prite has joined #lisp
<no-defun-allowed>
Then you still use AREF, but the only valid index you can provide is 0.
<g_o>
no-defun-allowed: thanks
<no-defun-allowed>
g_o: This works, and is equivalent to my CFFI example: (sb-alien:define-alien-routine "getpid" sb-alien:int)
<White_Flame>
(aref #(:a :b :c :d) 2) => :C
frgo has quit [Ping timeout: 240 seconds]
<beach>
afidegnum: I am asking what you mean by "if not a single unit", because that phrase suggests to me that you are still having problems understanding. Why did you think a vector with a single element was some kind of special case?
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
<afidegnum>
3
gabiruh has joined #lisp
<White_Flame>
which is exactly like v=[3,4,5], v[0] in python
<g_o>
no-defun-allowed: ah, i did the noob too much paranthesis mistake. Thanks!
<afidegnum>
yes, that's what i was refering to
<beach>
afidegnum: So why did you think a vector with one element was an exceptional case?
nanoz has quit [Ping timeout: 268 seconds]
<afidegnum>
i misinterpreted it's 0(1) aspect
<beach>
Hmm.
<afidegnum>
)(n)
<afidegnum>
O(n)
<White_Flame>
big-O notions are pretty degenerate at a collection size of 1 though
<beach>
afidegnum: O(1) and O(n) is notation used in complexity theory. The first one means that accessing an element takes constant time not matter how many elements there are, and the second means that accessing an element takes time proportional to the number of elements.
<beach>
afidegnum: Interestingly, then, is that accessing an element of a Common Lisp vector is O(1), but in a Python list, it is probably O(log n) or something like that, since in Python a list is not a consecutive sequence of elements.
<beach>
afidegnum: I strongly recommend you read up on things like this, or you run the risk of writing very inefficient code indeed, no matter what programming language you work in.
<beach>
So that situation is very typical. An inexperienced programmer uses some built-in collection type of some language, thinking that, because it is built-in, it is also fast. Then they get terrible performance.
<no-defun-allowed>
I don't think a Python programmer can tell the difference between "O(log n) but slow" and "O(n) but slow" though.
<beach>
I think that's exactly my point.
<no-defun-allowed>
That wasn't what I was going for, just that the reference Python implementation is interpreted and pretty slowly interpreted at that.
<beach>
Ah, I see. Sure.
g_o has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
But I really do remember Python lists being more complicated; if you did `[2] * 5000` it would be larger in memory than `[2 for _ in range(5000)]`.
<afidegnum>
ok
<afidegnum>
i need to understand that as well...
cosimone has joined #lisp
<no-defun-allowed>
Now it's terribly late, I'll be back tommorow.
<afidegnum>
there is more to read :)
<beach>
'night no-defun-allowed.
<beach>
afidegnum: Any introductory book on algorithms and data structures will explain the complexity of the operations of most common data structures.
xkapastel has quit [Quit: Connection closed for inactivity]
prite has quit [Ping timeout: 240 seconds]
prite has joined #lisp
jonatack has joined #lisp
frgo has joined #lisp
GoldRin has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
refpga has quit [Remote host closed the connection]
salinasce has joined #lisp
<White_Flame>
no-defun-allowed: the memory footprint probably expands becuase of intermediate garbage created
frgo_ has joined #lisp
wxie has quit [Remote host closed the connection]
frgo has quit [Ping timeout: 276 seconds]
lxbarbosa has joined #lisp
salinasce has quit [Ping timeout: 245 seconds]
salinasce has joined #lisp
stepnem has quit [Ping timeout: 276 seconds]
stepnem has joined #lisp
gareppa has quit [Quit: Leaving]
retropikzel has joined #lisp
frgo_ has quit [Ping timeout: 240 seconds]
nanoz has joined #lisp
stepnem_ has joined #lisp
stepnem has quit [Ping timeout: 245 seconds]
caltelt has joined #lisp
igemnace has joined #lisp
isBEKaml has joined #lisp
asdf_asdf_asdf has quit [Quit: asdf_asdf_asdf]
salinasce has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
frgo has joined #lisp
cosimone has quit [Quit: Terminated!]
salinasce has joined #lisp
cosimone_ has joined #lisp
cosimone_ has quit [Client Quit]
cosimone has joined #lisp
paul0 has quit [Read error: Connection reset by peer]
gareppa has joined #lisp
gxt has quit [Ping timeout: 260 seconds]
prite has quit [Ping timeout: 245 seconds]
prite has joined #lisp
paul0 has joined #lisp
elinow has joined #lisp
shangul has joined #lisp
elinow has quit [Client Quit]
elinow has joined #lisp
paul0 has quit [Ping timeout: 265 seconds]
igemnace has quit [Ping timeout: 240 seconds]
gareppa has quit [Quit: Leaving]
hhdave has joined #lisp
igemnace has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
jfe has quit [Ping timeout: 246 seconds]
gareppa has joined #lisp
stepnem has joined #lisp
stepnem_ has quit [Ping timeout: 268 seconds]
goFasterSteve has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
EvW has joined #lisp
Harag has quit [Quit: Harag]
Harag has joined #lisp
refpga has joined #lisp
mangul has joined #lisp
Harag has quit [Quit: Harag]
shangul has quit [Ping timeout: 245 seconds]
asdf_asdf_asdf has joined #lisp
isBEKaml has quit [Quit: leaving]
habeangur has joined #lisp
paul0 has joined #lisp
ralt has joined #lisp
mangul has quit [Ping timeout: 276 seconds]
cosimone has joined #lisp
davsebamse has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
cosimone has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
APic has quit [Ping timeout: 240 seconds]
APic has joined #lisp
analogue has joined #lisp
cosimone has joined #lisp
EvW has quit [Ping timeout: 276 seconds]
ljavorsk_ has joined #lisp
salinasce has quit [Remote host closed the connection]
refpga has quit [Read error: Connection reset by peer]
gareppa has quit [Quit: Leaving]
refpga has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
cosimone has quit [Quit: Quit.]
cosimone has joined #lisp
cosimone has quit [Client Quit]
FreeBirdLjj has joined #lisp
xkapastel has joined #lisp
_paul0 has joined #lisp
paul0 has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
habeangur is now known as shangul
EvW1 has joined #lisp
retropikzel has quit [Remote host closed the connection]
Jeanne-Kamikaze has joined #lisp
hiroaki has joined #lisp
Nomenclatura has joined #lisp
salinasc has joined #lisp
Cymew has joined #lisp
georgie_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
refpga has quit [Quit: ERC (IRC client for Emacs 26.3)]
cosimone has joined #lisp
APic has quit [Ping timeout: 245 seconds]
APic has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
hiroaki has quit [Remote host closed the connection]
hiroaki has joined #lisp
hiroaki has quit [Remote host closed the connection]
asdf_asdf_asdf has quit [Remote host closed the connection]
goFasterSteve has quit [Ping timeout: 240 seconds]
gareppa has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
ebrasca has quit [Remote host closed the connection]
nostoi has joined #lisp
CEnnis91 has joined #lisp
makomo has quit [Quit: WeeChat 2.4]
jonatack has quit [Ping timeout: 264 seconds]
APic has quit [Ping timeout: 276 seconds]
Cymew has quit [Ping timeout: 240 seconds]
salinasc has quit [Remote host closed the connection]
APic has joined #lisp
nanoz has quit [Ping timeout: 265 seconds]
eSVGDelux has joined #lisp
jonatack has joined #lisp
scymtym has quit [Ping timeout: 245 seconds]
nostoi has quit [Quit: Verlassend.]
analogue has quit [Quit: Leaving]
gareppa has quit [Quit: Leaving]
gxt has joined #lisp
prite has quit [Ping timeout: 240 seconds]
Blukunfando has quit [Ping timeout: 265 seconds]
gjvc has joined #lisp
cosimone has quit [Quit: Quit.]
<gjvc>
what's a good resource for learning about writing a language parsers in lisp?
frgo has quit [Read error: Connection reset by peer]
asdf_asdf_asdf has joined #lisp
Blukunfando has joined #lisp
frgo has joined #lisp
rpg has joined #lisp
cosimone has joined #lisp
shangul has quit [Ping timeout: 265 seconds]
<jackdaniel>
check out esrap library
<gjvc>
thank you
goFasterSteve has joined #lisp
<gjvc>
hello
<gjvc>
oops, sorry
<beach>
gjvc: What kind of language do you need to parse?
goFasterSteve has quit [Ping timeout: 265 seconds]
ljavorsk_ has quit [Remote host closed the connection]
ljavorsk_ has joined #lisp
rpg has quit [Read error: Connection reset by peer]
jeosol has joined #lisp
nanoz has joined #lisp
goFasterSteve has joined #lisp
<asdf_asdf_asdf>
Hi. Why function alien is undefined? I defined this function.
Jeanne-Kamikaze has quit [Ping timeout: 268 seconds]
<asdf_asdf_asdf>
Sorry. I forgot set "(sb-alien::load-shared-object "C:/Windows/System32/Gdi32.dll")".
Nomenclatura has quit [Quit: q]
prite has joined #lisp
lxbarbosa has quit [Ping timeout: 276 seconds]
orivej has joined #lisp
yoeljacobsen has joined #lisp
akoana has joined #lisp
lxbarbosa has joined #lisp
prite has quit [Ping timeout: 240 seconds]
lxbarbosa has quit [Read error: No route to host]
FreeBirdLjj has joined #lisp
jfe has joined #lisp
milanj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
Folkol has joined #lisp
prite has joined #lisp
ljavorsk_ has quit [Ping timeout: 240 seconds]
gareppa has joined #lisp
yoeljacobsen has quit [Ping timeout: 265 seconds]
Aruseus has joined #lisp
elinow has quit [Read error: Connection reset by peer]
mbrock has quit [Ping timeout: 276 seconds]
scymtym has joined #lisp
cosimone has joined #lisp
sauvin has quit [Ping timeout: 240 seconds]
sauvin has joined #lisp
bjorkintosh has quit [Quit: Leaving]
slightlycyborg has joined #lisp
lxbarbosa has joined #lisp
ggole has quit [Quit: Leaving]
krid has joined #lisp
gareppa has quit [Quit: Leaving]
lxbarbosa has quit [Ping timeout: 246 seconds]
gravicappa has quit [Ping timeout: 276 seconds]
nanoz has quit [Ping timeout: 240 seconds]
raghavgururajan has joined #lisp
bjorkintosh has joined #lisp
gareppa has joined #lisp
gareppa has quit [Client Quit]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
hhdave has quit [Quit: hhdave]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
ljavorsk_ has joined #lisp
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hhdave has joined #lisp
hhdave has quit [Client Quit]
hiroaki has joined #lisp
hiroaki has quit [Ping timeout: 252 seconds]
Aruseus has quit [Remote host closed the connection]
<alandipert>
i noticed that ((lambda () 'x)) works but (((lambda () (lambda () 'x)))) does not ("illegal function call"). why is that?
<alandipert>
oh nevermind i think i get it, (funcall ((lambda () (lambda () 'x)))) does the trick. the return value of a function, even if a function, is not a 'function designator' perhaps?
<_death>
a function is a function designator.. but it's not a lambda expression
<asdf_asdf_asdf>
(funcall (lambda () 'x))
<_death>
the special case needs a lambda expression in the operator position
<asdf_asdf_asdf>
(#|treat as instruction to call|#(funcall (lambda () 'x)))
<_death>
well, not only that.. only one level is considered
buffergn0me has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
<grewal>
Good morning, do you know of any cl implementations of python3? I've found clpython, but it says it only supports python2.
<aeth>
There probably isn't that much of a demand for that, although it would be entertaining to parse Python into an intermediate s-expression form that then could be used from CL in a more familiar way.
<aeth>
e.g. "x + y" => (+ x y) => actual python implementation
<aeth>
The problem with making a better Python implementation is that the main Python implementation is one of the slowest languages, so quite a few serious users use native libraries like Numpy, so you wouldn't be able to run a lot of Python code without also exposing the entire Python C API, which would probably force you into the inefficiencies that make Python's main implementation slow in the first place.
<aeth>
at least afaik
<aeth>
So python3-on-sbcl won't give you access to popular libraries that require running native C/C++/etc. code.
<grewal>
I see...
<aeth>
But, I think the more relevant factor is that it's not easy.
raghavgururajan has quit [Remote host closed the connection]
<grewal>
Right, but perhaps forking clpython might be sufficient for me. I've landed a python job, and I miss having a lispy development environment
<aeth>
yeah, you could fork clpython (if it was even a complete Python 2 in the first place) and you could maybe even do what the Python core devs refused to do: have Python 2 and Python 3 running together in one runtime rather than in separate interpreters
<aeth>
Although maybe that's too difficult. I wonder if PyPy does this or if there was a reason why they don't?
caltelt has quit [Remote host closed the connection]
slightlycyborg has quit [Ping timeout: 265 seconds]
ljavorsk_ has quit [Ping timeout: 265 seconds]
bjorkintosh has quit [Quit: Leaving]
raghavgururajan has joined #lisp
vap1 has quit [Quit: Leaving]
techquila has joined #lisp
mindthelion has quit [Ping timeout: 265 seconds]
bitmapper has joined #lisp
asdf_asdf_asdf has quit [Remote host closed the connection]
<remexre>
grewal: Another, much worse, thing you could do is running ABCL on GraalVM, which can run a bunch of languages
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
<no-defun-allowed>
White_Flame: No, the size of the list created changes. I guess the more plausible explanation is that it resizes differently?
<aeth>
remexre: It would be better to make a multilanguage runtime running on top of the CL runtime imo. Better than either clpython or CL-on-someone-else's-runtime
<remexre>
aeth: probably true if all one needs is one language on the runtime; the project I'm trying is part Scala, part CL, part <custom language>
<remexre>
where the custom language is performance-sensitive enough to want optimizations on par with GraalVM's
<aeth>
This was on the front page of HN earlier today... on the second page now, though, and only two comments. "Coleslaw: Static Site Generator in Common Lisp" https://news.ycombinator.com/item?id=21100128
asdf_asdf_asdf has joined #lisp
sjl has joined #lisp
jfe has joined #lisp
afidegnum has quit [Ping timeout: 268 seconds]
afidegnum has joined #lisp
raghavgururajan has quit [Read error: Connection reset by peer]