<verisimilitude>
Well, not only does it now work properly when compiled with SBCL, but it's leagues faster, fast enough for practical purposes. Due to that, I was able to test it on more files and uncovered an additional error I'd overlooked.
<verisimilitude>
It should be fine now, Xach, still at that URL.
<verisimilitude>
If you want to see it as a string, you could call it like this instead:
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
efm has quit [Ping timeout: 264 seconds]
Bourne has quit [Ping timeout: 256 seconds]
msk_ has joined #lisp
msk has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Remote host closed the connection]
patlv has quit [Quit: patlv]
efm has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
efm has quit [Excess Flood]
efm has joined #lisp
Oladon has joined #lisp
EvW has quit [Ping timeout: 256 seconds]
msk_ has quit [Remote host closed the connection]
msk_ has joined #lisp
SGASAU` has quit [Remote host closed the connection]
bitmapper has quit [Ping timeout: 256 seconds]
SGASAU` has joined #lisp
ayuce has joined #lisp
ayuce has quit [Remote host closed the connection]
frgo_ has quit [Ping timeout: 240 seconds]
asarch has joined #lisp
ayuce has joined #lisp
jonatack has quit [Ping timeout: 256 seconds]
jonatack has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
lemoinem has quit [Killed (barjavel.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
aindilis has quit [Ping timeout: 250 seconds]
iAmDecim has joined #lisp
gko has joined #lisp
<ArthurStrong>
Hi all. How 'describe' works? How it pulls a first string in function?
<Xach>
ArthurStrong: that string is called a docstring and it is generally available via the DOCUMENTATION function.
<Xach>
ArthurStrong: what DESCRIBE does is not very strictly specified.
<Xach>
it might show the docstring or it might not
<ArthurStrong>
I meant, if I'm writing toy LISP interpreter. How could I implement it?
<no-defun-allowed>
Attach a documentation string to each function object.
<ArthurStrong>
no-defun-allowed: ah, attach an additional string to a symbol?
<Xach>
ArthurStrong: what language are you writing your toy lisp in?
<ArthurStrong>
no-defun-allowed: and fill it while parsing?
<ArthurStrong>
Xach: pure C
<no-defun-allowed>
I would rather attach it to the function object.
<no-defun-allowed>
ArthurStrong: No, evaluate (lambda (args ...) "documentation string" body ...) to be a function with arguments ARGS, documentation "documentation string" and body BODY.
<Xach>
ArthurStrong: what reference works (aside from #lisp) are you using in your project?
iAmDecim has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
Rule 1 of Lisp interpreting: never preprocess anything in the reader. Everything is evaluated at eval-time (well, except for #.foo, which causes an eval-time in read-time).
aindilis has joined #lisp
<ArthurStrong>
Is docstring evaluates at each execution or is skipped?
* Xach
oh boy
<no-defun-allowed>
A string, by definition, is self-evaluating.
<ArthurStrong>
Somehow, describe can fetch whatever string evaluates first :)
<no-defun-allowed>
There is no point to evaluating a documentation string.
<no-defun-allowed>
No, the documentation string is separate to the function body. It isn't evaluated.
SGASAU` has quit [Remote host closed the connection]
<no-defun-allowed>
The syntax definition tells us that the documentation is separate to the body of the function.
<ArthurStrong>
OK
<ArthurStrong>
thanks
SGASAU` has joined #lisp
<no-defun-allowed>
"lambda lambda-list [[declaration* | documentation]] form*" means it starts with LAMBDA, then there are some (possibly zero) number of declarations and documentation strings (the first of which is the documentation), then there are forms that constitute the body.
<no-defun-allowed>
(Actually, no, if there are multiple documentation strings, "the consequences are unspecified". Picking the first would probably be the least surprising.)
shinohai has quit [Quit: If you are reading this then I have left the channel.]
shinohai has joined #lisp
anlsh-nopass has joined #lisp
HiRE has quit [Quit: Later]
HiRE has joined #lisp
Guest35635 has joined #lisp
sveit has quit [Ping timeout: 260 seconds]
Oladon has quit [Quit: Leaving.]
sveit has joined #lisp
efm has quit [Ping timeout: 264 seconds]
kingcons has joined #lisp
torbo has joined #lisp
anlsh-nopass has left #lisp [#lisp]
anlsh-nopass has joined #lisp
iAmDecim has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
anlsh-nopass has quit [Ping timeout: 240 seconds]
torbo has quit [Remote host closed the connection]
torbo has joined #lisp
theosvoitha has joined #lisp
Josh_2 has quit [Ping timeout: 256 seconds]
wxie has quit [Ping timeout: 265 seconds]
nightfly has quit [Ping timeout: 265 seconds]
frgo has joined #lisp
Xach has quit [Ping timeout: 265 seconds]
Xach has joined #lisp
nightfly has joined #lisp
madage has quit [Ping timeout: 240 seconds]
ahungry has joined #lisp
iAmDecim has joined #lisp
turona has quit [Ping timeout: 272 seconds]
pierpa has quit [Remote host closed the connection]
shifty has joined #lisp
turona has joined #lisp
madage has joined #lisp
pilne has quit [Quit: Few women admit their age. Few men act theirs.]
<beach>
Good morning everyone!
akoana has quit [Quit: leaving]
EarwainBanadar has quit [Remote host closed the connection]
EarwainBanadar has joined #lisp
<Samo_svoj>
anyone knows microservices framework for lisp?
lxbarbosa has quit [Ping timeout: 246 seconds]
<loke>
Samo_svoj: What would you expect such a framework to provide? I've built such things in the past, and the "framework" was really no mure than a few tens of lines of scaffolding around Hunchentoot.
<Samo_svoj>
ES/CQRS?
<no-defun-allowed>
What do those acronyms mean?
<Aurora_v_kosmose>
Those are design patterns afaik.
<no-defun-allowed>
Also, morning beach
<Samo_svoj>
loke: + good parallel features + graphql capacity + speed comparable to Rust :)
<Aurora_v_kosmose>
That's not generally a feature of microservices as a general thing.
<no-defun-allowed>
But what are they? (And we don't do design patterns in Lisp.)
<no-defun-allowed>
Okay.
<Samo_svoj>
no-defun-allowed: ES = it means that everything you do you have to write in database (db is append-only). After some time you do snapshot and if you restart microservice you do reply.
<no-defun-allowed>
Right, so everything is encoded as a change to something instead of replacement?
<Samo_svoj>
no-defun-allowed: CQRS - it means everything you do from client side has to be propagated through database, recorded, and then activity has to be done back. there is no update table only in web browser, for example.
<Aurora_v_kosmose>
So... blocking transactions.
<drmeister>
How do lispers feel about print-object methods that print objects over multiple lines?
<Samo_svoj>
Aurora_v_kosmose: maybe it is not but this is one highly bespoke microservice framework
<drmeister>
Good? Bad? Indifferent?
<no-defun-allowed>
Usually good.
Bike has quit [Quit: Lost terminal]
<Aurora_v_kosmose>
Pretty-printing is good for readability.
<no-defun-allowed>
I can't remember how my define-tuple macro (which does everything) invokes the pretty printer stuff exactly, but it does go on multiple lines.
<drmeister>
Should I be using the pretty printer better?
<loke>
drmeister: I usuallt find it to be a hassle if it's note done well.
<drmeister>
Any advice on doing it well?
<loke>
drmeister: Specifically, I often do stuff like: (format t "foo:~a, bar:~a~%" x y)
<drmeister>
I want to view these in terminals and slime buffers and sldb - you know the drill.
<Samo_svoj>
as far as I can see Hunchentoot is http/1.1 not 2.0 or 3.0 compliant?
<no-defun-allowed>
That file is ancient as far as I am concerned.
<no-defun-allowed>
Yeah, HTTPs 2 and 3 are much harder to implement than 1.1.
<Aurora_v_kosmose>
If it's a hard requirement, FFI-wrapping some lib that provides it may be a usable interim solution.
<asarch>
Bingo! SELECT * FROM student ORDER BY id DESC LIMIT (20-10+1) OFFSET 10; is (ql:quickload :sxql) (select :* (from (:student)) (order-by :id (:desc :id)) (limit (- 20 (+ 10 1))) (offset 10))
<loke>
drmeister: I use that form in log outpit (log4cl)
<loke>
It coul dbe controversial yes :-)
<no-defun-allowed>
In my opinion, HTTP/2 is reasonable, and multiplexing and data pre-fetching are fair play, but additionally having to deal with congestion control with Google's QUIC transport protocol is just peak webshit.
<Samo_svoj>
no-defun-allowed: in mobile world it is not.
<Aurora_v_kosmose>
Eh, 5G will help with that nonsense.
<Aurora_v_kosmose>
But having to implement a secondary protocol on top of http does sound like a much larger workload.
<loke>
Samo_svoj: I usually put haproxy or ngnix in front of Hunchentoot and to TLS termination there. That's where the HTTP/2 is handled.
<loke>
It then calls hunchentoot using HTTP/1.1 on the backend.
<Samo_svoj>
loke: is there a library for session types?
<loke>
What do you mean by session types?
<no-defun-allowed>
To implement a HTTP/3 server, I understand one also has to implement the QUIC protocol; but otherwise there don't seem to be any more changes or advantages from HTTP/2 other than "haha version number is bigger".
<Aurora_v_kosmose>
Samo_svoj: You'd represent session types as CLOS classes & optimize methods based what you expect.
<beach>
Aurora_v_kosmose: The term "CLOS class" is meaningless, since all classes in Common Lisp are CLOS classes.
<Aurora_v_kosmose>
beach: Touche. It's redundant.
<beach>
Usually, when people use that term, they mean "standard classes" as in what you get by default when you use DEFCLASS to define one.
<loke>
Samo_svoj: SBCL has performance on the same order of magnitude as C, yes. It can in places be even faster.
<Aurora_v_kosmose>
beach: I was assuming unfamilarity with CL's object system and providing a keyword to lookup.
<loke>
Samo_svoj: I created a template parser that generates native code (it outputs Lisp forms and passes them through COMPILE). I'd argue that that template system is one of the fastest ever created.
<loke>
REST API methods are defined using DEFINE-API-METHOD
<no-defun-allowed>
I would say it's possible to get (100 - small number)% of the speed of C in small number% of the time with Common Lisp; and there are optimisations that can be done that are just plain impossible with static languages.
gko has quit [Ping timeout: 260 seconds]
asarch has quit [Quit: Leaving]
Oladon has quit [Quit: Leaving.]
vlatkoB has joined #lisp
<beach>
Do we have any construct that would alter the result of get-setf-expansion in a non-null lexical environment?
dddddd has quit [Ping timeout: 256 seconds]
<beach>
I am asking because get-setf-expansion takes an optional environment argument, and I am wondering whether it is used only to distinguish between the compilation environment and the run-time environment, or whether there can be any information in a lexical environment that can alter the expansion.
iAmDecim has quit [Ping timeout: 256 seconds]
sauvin has joined #lisp
drot has quit [Ping timeout: 260 seconds]
drot has joined #lisp
SDP has joined #lisp
SDP has left #lisp [#lisp]
gravicappa has joined #lisp
ahungry has quit [Remote host closed the connection]
narimiran has joined #lisp
<phoe>
beach: the only thing that comes to my mind is the possibility of local macros
<phoe>
but does GET-SETF-EXPANSION expand macros at all?
shka_ has joined #lisp
<phoe>
it does seem that it expands macros
<phoe>
therefore it'll need &env for MACROLET-defined ones
<phoe>
a macro can be used as a place, which means that passing a macro form to GET-SETF-EXPANSION is valid
<phoe>
which means that a local macro is valid too, and for that, we need &env
<beach>
Excellent! Thanks!
<phoe>
no problem
<beach>
So if there is both a global setf expander and a macro for a form, the global setf expander is used if I understand things right.
<beach>
I should try an experiment for that.
<phoe>
it seems so
<phoe>
"Such macro expansion is attempted only after exhausting all other possibilities other than expanding into a call to a function named (setf reader)."
<beach>
Yes, that's the one I am trying to understand.
<phoe>
so other options are preferable
<phoe>
if you have a macro FOO, then a setf expander for (SETF FOO) will take precedence over macroexpanding FOO
JohnMS_WORK has joined #lisp
<beach>
I think I understand.
<phoe>
like, you can define SETF FOO do perform some actual setting - you can't do that if your FOO expands into e.g. (let ((x 42)) ...)
<phoe>
that's because SETF LET is undefined
<phoe>
and you can work around this by defining a SETF FOO expansion yourself that will make actual sense
<phoe>
macroexpanding a form is SETF's next-to-last resort
<beach>
Yes, I think I get it.
<phoe>
the last resort is funcalling #'(SETF FOO)
<beach>
Thanks again.
<phoe>
no problem
<beach>
So I need to figure out the best way of checking whether some place would result in a setf expasion of funcalling #'(setf <place>).
Cymew has joined #lisp
<phoe>
I think the place algorithm will give you that
<phoe>
when you exhaust all other options available to you, all that remains is #'(setf foo)
<beach>
But how do I go about exhausting all other options, is my question.
<phoe>
like, you can go through all the options of clhs 5.1.2
<phoe>
is it a varable? is it a function call? is it a VALUES call?... etc..
_paul0 has quit [Remote host closed the connection]
paul0 has joined #lisp
karlosz has quit [Quit: karlosz]
pve has joined #lisp
random-nick has joined #lisp
Bourne has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
SvetaBilya has joined #lisp
SvetaBilya has quit [Client Quit]
Cymew has quit [Quit: Konversation terminated!]
Cymew has joined #lisp
wxie has joined #lisp
<boeg>
Anyone have experience with caveman and mito? I'm not quite sure how to connect the two properly. Is all that needs to be edited found in the db.lisp file, or is there other places where I need to do something so caveman2 is configured properly with mito?
<Cymew>
It's Fukamachiware, which usually means it's not that well documented, and I get the impression you need to have done web development in ruby to understand what the code is trying to achieve.
<Cymew>
I don't even understand what mito is used for. There seems to be some kind of db support in caveman these days, but maybe you're interested in doing something more complex.
Zakkor_ has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
Zakkor_ is now known as Zakkor
ljavorsk has joined #lisp
v_m_v_ has quit [Remote host closed the connection]
Ven`` has joined #lisp
v_m_v_ has joined #lisp
ArthurStrong has quit [Ping timeout: 265 seconds]
ArthurStrong has joined #lisp
<jmercouris>
what are monads? can someone explain them in a way I can understand?
<jmercouris>
I've been working with this question since university...
<jmercouris>
is it just a chain of funcall results???
<aeth>
jmercouris: It's basically a thing that satisfies algebraic properties
SGASAU` has quit [Quit: ERC (IRC client for Emacs 26.3)]
<TMA>
jmercouris: generally, in order to understand monads you need to understand monads first. people who understand monads lose the ability to explain them to people that dont
SGASAU has joined #lisp
<phoe>
I'll allow myself to post https://en.wikibooks.org/wiki/Haskell/Understanding_monads and route the discussion to #lispcafe since it clearly isn't about Lisp (since Lisp doesn't force you to understand monads in order to use the language in a sensible way)
msk_ has quit [Remote host closed the connection]
cosimone has joined #lisp
<jmercouris>
thanks for the links, maybe it will help to read marijn's post
<pjb>
jmercouris: In CL, method-combinations are monads.
<phoe>
or join #lispcafe
<jmercouris>
I left lispcafe sometime ago, because the discussion was not so friendly at times :-(
<phoe>
you can always escalate to the mods
<phoe>
like, e.g., me
choegusung has joined #lisp
<jmercouris>
just read the Marijn article
<jmercouris>
very fascinating stuff, I'm glad we don't have that nonsense in CL
<phoe>
we don't need to, since CL allows imperative programming
<jmercouris>
this obsession with "purity" makes things unusable
<jmercouris>
what I like about CL is its pragmatism
<jmercouris>
it is not just a toy language, restricted to academic ivory towers
barodaret has joined #lisp
<phoe>
neither is Haskell, but that's already off-topic
<jmercouris>
yet it is fully suitable for academic research as well due to some wonderful properties
* phoe
goes back to writing
<jmercouris>
I didn't bring up haskell, that was you :-D
<jmercouris>
I'm just preaching to the choir here :-D
<phoe>
when Shinmera gets angry he constructs a dns client in a day
<Shinmera>
I ain't even mad
<phoe>
at this rate you gotta get an animal groomer license
<phoe>
or the police might come knocking at your door with questions about all the yaks you have shaved
v_m_v_ has quit [Remote host closed the connection]
v_m_v_ has joined #lisp
v_m_v_ has quit [Remote host closed the connection]
v_m_v_ has joined #lisp
<phoe>
I gotta finish being angry myself
<phoe>
my angry is currently at 143 pages and 6 ASDF systems
<jackdaniel>
and what exactly are you angry at? perceived inconsistence between handler-case and handler-bind?
shifty has quit [Ping timeout: 256 seconds]
<phoe>
nope, not really
<phoe>
I was originally angry at the fact that there's no "good" tutorial to the Lisp condition system that shows how to construct it from scratch
scymtym has quit [Ping timeout: 260 seconds]
<phoe>
and now I'm angry at the fact that my tutorial turned into a book
entel has joined #lisp
<Xach>
a book is ok
* _death
is concerned, not yet angry, about alexandria :/
<phoe>
_death: which parts exactly?
v_m_v_ has quit [Remote host closed the connection]
<_death>
not sure I want to go into it right now.. maybe it's better to ignore and hope for the best
v_m_v_ has joined #lisp
dyelar has joined #lisp
<phoe>
the only hopes that are valid for alexandria are hopes that it'll become as ossified as ANSI CL
<phoe>
;; at least in my opinion
gxt has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
theosvoitha has quit [Quit: Connection closed for inactivity]
<pjb>
Shinmera: told you…
<Shinmera>
I didn't doubt you!
<pjb>
DNS-PORT should not be a constant…
lemoinem is now known as Guest65992
Guest65992 has quit [Killed (livingstone.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
madage has joined #lisp
v_m_v_ has quit [Remote host closed the connection]
v_m_v_ has joined #lisp
v_m_v_ has quit [Read error: No route to host]
v_m_v_ has joined #lisp
* Xach
feels a quicklisp dist shaping up
Zakkor has quit [Quit: Connection closed for inactivity]
<Shinmera>
!
v_m_v_ has quit [Ping timeout: 256 seconds]
Necktwi has quit [Ping timeout: 260 seconds]
v_m_v_ has joined #lisp
Bike has joined #lisp
v_m_v_ has quit [Ping timeout: 256 seconds]
ardoc has joined #lisp
<phoe>
yes, you feel something. I must know what you are feeling
sabrac has joined #lisp
wxie has joined #lisp
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
EvW1 has quit [Ping timeout: 272 seconds]
ljavorsk has quit [Ping timeout: 265 seconds]
ReginaRus has joined #lisp
ljavorsk has joined #lisp
ReginaRus has quit [Client Quit]
ljavorsk has quit [Ping timeout: 265 seconds]
shifty has joined #lisp
<Xach>
the auspices and omens all tell the same tale
<Xach>
"nothing major is broken and it is almost the end of the month"
<phoe>
quick, time to break something!
<Xach>
don't you dare
<phoe>
okay
<MichaelRaskin>
Hm, looks like some of the disappeared packages are now reuploaded by other people (or at least clx-truetype is…)
<Bike>
beach: I didn't see anyone mention it - in a lexical environment with flet bindings for "f", the global setf expander for "f" doesn't apply
<beach>
Bike: I see. Thanks.
<beach>
Very important.
holycow has joined #lisp
<Bike>
also, if it does end up being a macro form, you have to use macroexpand-1 rather than macroexpand, so that if the thing immediately expanded into has a setf expander, you use that instead of macroexpanding
v_m_v_ has quit [Remote host closed the connection]
<Bike>
Shinmera: by the way, you could define a default single-float-bits and double-float-bits using integer-decode-float, assuming they're supposed to return the IEEE754 formats... it'll work, though it'll be slower than what the implementation can do, and I don't think you can do it the other way precisely
rippa has joined #lisp
<Shinmera>
Hmm.
<Shinmera>
Not sure that's a good idea, since you said /assuming/ they return the IEEE formats.
<Shinmera>
So it would require testing per implementation, anyway.
ArthurStrong has quit [Quit: leaving]
<Bike>
well, i meant, assuming that's what you want returned. you shoudl be able to tell from standard functions whether a single-float will fit.
<Bike>
like, check float-radix is 2, float-digits is 24 or less for a single, and the exponent is in range.
<Bike>
and if not you can do a not supported error.
<Bike>
there's also a standard feature for ieee754 conformance
<anlsh>
Something about structs, but I barely know what structs are so ~\(._._/~
<anlsh>
or rather, how they work in cl
<jackdaniel>
anlsh: structures are instances of a class which metaclass is structure-class
<jackdaniel>
they are simplified version of standard-object instances
<jackdaniel>
(i.e accessors may be inlined)
EarwainBanadar has quit [Remote host closed the connection]
<jackdaniel>
but you can't redefine the structure conformingly (unlike a "normal" class)
<jackdaniel>
they are basically a performance hack withdifferent semantics
<jackdaniel>
than defclass
<anlsh>
conformingly?
<jackdaniel>
there is ANSI standard for Common Lisp and common lisp implementations implement it
<jackdaniel>
(like C standard and gcc, clang, msvc etc)
<jackdaniel>
so standard specifies some behavior, but some is left as undefined (i.e implementation is free to do whatever it wants)
<anlsh>
oh, so the spec specifies that you can't redefine structs
<phoe>
yep
<jackdaniel>
no
<phoe>
uh wait
<phoe>
implementations may provide means for doing that (e.g. SBCL does that), but in the general case, the consequences are undefined
<jackdaniel>
spec specifies, that consequences of redefining a struct are not specified
<jackdaniel>
so the implementation may provide some protocol for redefining structures, it may signal a condition, or grow carrots in your nose
<phoe>
the spec specifies that you can't *portably* redefine structs
<phoe>
where "portably" means that if it works on your implementation, yay, but it doesn't have to work on another implementation
<jackdaniel>
phoe: I'm trying to explain that and you repeat what I try to communicate, it is annoying to be honest (very much like interrupting)
* phoe
goes quiet
<jackdaniel>
thank you
<anlsh>
Thanks for the explanation!
<jackdaniel>
sure
asarch has quit [Quit: Leaving]
<jackdaniel>
anlsh: are you planning to learn Common Lisp?
<jackdaniel>
or joined to hang around for a while and see if you want to stick with the community?
<anlsh>
I've been looking at in on and off (mostly off) for a year or two now, I've been here before
<anlsh>
I'd still classify myself as a novice though I've been around to know what the more famous resources are (Let over lambda, PCL, On Lisp, etc.)
<jackdaniel>
ah OK, I was about to recommend them :) (to be precise, the second one)
<anlsh>
Yeah PCL was how I started out I like it a lot. I'm working through SICP rn
<anlsh>
The generic system I put up earlier is written mostly so that I could breeze through the relevant parts of ch 2
<anlsh>
hopefully anyways, I'll see if it's good enough shortly
<jackdaniel>
it is worth noting, that paip has been released on the internet recently
<jackdaniel>
minion: tell anlsh about paip
<minion>
anlsh: paip: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp
<jackdaniel>
just for the reference, it seems that you've already decided about your work schedule
mason has quit [Quit: leaving]
<anlsh>
I'll probably tackle On Lisp next, but I'll keep it in mind :)
mason has joined #lisp
<phoe>
On Lisp is a book that has a huge part about writing and analyzing all sorts of Lisp macros
EvW1 has joined #lisp
EvW has quit [Read error: Connection reset by peer]
<bitmapper>
why is it so hard to find a copy of allegro/lispworks for irix
<Xach>
bitmapper: have you asked franz/lispworks ltd?
<bitmapper>
franz doesn't have the ability to make new licences anymore
<phoe>
so you're effectively searching for abandonware
emys has quit [Ping timeout: 265 seconds]
<Xach>
bitmapper: out of curiosity, what is the project that involves allegro cl or lispworks for irix?
<bitmapper>
nothing
emys has joined #lisp
<bitmapper>
i just have an octane sitting in my room doing nothing, and i'm stuck inside and bored
<bitmapper>
cmucl is broken
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
nowhere_man has quit [Read error: Connection reset by peer]
buffergn0me has quit [Ping timeout: 256 seconds]
anlsh` has joined #lisp
anlsh has quit [Ping timeout: 256 seconds]
cantstanya has quit [Remote host closed the connection]
zooey has quit [Remote host closed the connection]
Aurora_v_kosmose has quit [Remote host closed the connection]
corpix has quit [Remote host closed the connection]
zooey has joined #lisp
Aurora_v_kosmose has joined #lisp
karlosz has joined #lisp
cantstanya has joined #lisp
emys has quit [Ping timeout: 265 seconds]
emys has joined #lisp
pve has quit [Quit: leaving]
lalilulelo has quit [Quit: Leaving]
emys has quit [Ping timeout: 265 seconds]
Intensity has joined #lisp
scymtym has joined #lisp
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 256 seconds]
shifty has quit [Ping timeout: 256 seconds]
<jeosol>
Good morning guys
<phoe>
hey
<jeosol>
hi phoe
<jeosol>
I wanted to quickly confirm something, I get my lambdalist mixed up sometimes, my code is acting up now
<jeosol>
specifically with CLOS
asarch has joined #lisp
<jeosol>
I want to declare method e.g., (defmethod run ((opt optimizer) &key ..) ()) but I want to be able to pass different values depending on object I have as that first argument. The defgeneric does not need to be spec out, does?
<Bike>
it's kind of hard to parse your sentences. The defgeneric's lambda list cannot have specializations, if that's what you mean.
<jeosol>
I meant pass additional parameters to the function for different objects
<Bike>
Or are you talking about the different keyword parameters?
<jeosol>
I am sorry, about that
<jeosol>
yeah, I am referring to different keyword parameters
<Bike>
You can give the different methods different keyword parameters without writing them in the defgeneric. The set of allowed keywords is defined by the methods that are actually used for the call.
<jeosol>
Ok. that resolves it. I was referring to the keyword part
gravicappa has quit [Ping timeout: 258 seconds]
efm has quit [Ping timeout: 256 seconds]
keep_learning has quit [Quit: This computer has gone to sleep]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
dale has quit [Quit: dale]
housel has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
anlsh` has quit [Remote host closed the connection]
dale has joined #lisp
duncan_ has quit [Ping timeout: 265 seconds]
amerlyq has quit [Quit: amerlyq]
Oladon has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
<verisimilitude>
That's interesting, Shinmera, as I've also planned a DNS client, although I've made little progress on programming it, because I've not yet read all of the IETF RFCs for DNS; mine will only operate on messages, doing no actual sending, so it will be standard Common Lisp. I've given the parsing of the actual messages decent thought and wanted to see if you've stumbled across an idea I'd for nicely doing so, but this doesn't seem to be
<verisimilitude>
the case, by my glance.
<verisimilitude>
It seems to me your DECODE-HOST will fail on malicious DNS names which are compressed with cycles; is this a correct understanding, Shinmera?
keep_learning has joined #lisp
iAmDecim has joined #lisp
random-nick has quit [Ping timeout: 250 seconds]
efm has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
monokrom has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
<Josh_2>
How do I convert "97.35" to a number?
<Bike>
read-from-string. i think there are maybe parse number libraries around...
<aeth>
the laziest way to implement something like that would be to read until the . and then read after the . and then give the part after the . a denominator based on the substring length after the . and then convert that into a double or single float
<aeth>
A more elaborate way can read the . each time digit by digit in a loop, shifting one over each time.
<aeth>
that's using digit-char-p
Lord_of_Life has joined #lisp
buffergn0me has joined #lisp
wxie has joined #lisp
anlsh has joined #lisp
pilne has joined #lisp
<asarch>
"SETQ" <- "Set qualifier" or "Set quoted object"?