<lotuseater>
White_Flame: what is called like that, for example expert systems
<phoe>
White_Flame: (and number (not complex))
<lotuseater>
phoe: very nice :D
<White_Flame>
well, for symbolic AI, there's not a lot of newer resources in general
<lotuseater>
yeah hm i see
<lotuseater>
I would really like to know how tools like Cyc work.
<White_Flame>
I got really annoyed with powerloom, because it's like cyc in that they invented their own version of lisp tied to C++/Java semantics, and export a version to CL which is overall pretty janky
<White_Flame>
Cyc is a mudball of legacy and per-customer hacks
<White_Flame>
but, it's that hackishness that gives it its capabilities
<lotuseater>
yes on the job site stands "you'll walk into 35 years of code"
<White_Flame>
basically, it's all about indexing
galex-713 has quit [Ping timeout: 272 seconds]
<lotuseater>
hm okay. but the talks of Douglas Lenat are nice. i first read about him in Goedel Escher Bach
<White_Flame>
all of your logic statements are semantically peers, but the indexer treats them differently
<White_Flame>
then once you have basic logic running, you define tools in logic to help you expand
<White_Flame>
so you leave lisp pretty quickly
<White_Flame>
until you need more performance
<lotuseater>
yeah hm but they're organized object oriented, right?
<White_Flame>
and then you start stirring the implementation pot more to get it to run your logic faster
<White_Flame>
no, not really
<White_Flame>
but that just depends on preference
<lotuseater>
"But how can this parentheses stuff be fast at all?" :D
<White_Flame>
it's more data-oriented than object-oriented
<lotuseater>
White_Flame: okay i thought so from reading
theBlackDragon has joined #lisp
<White_Flame>
a good place to start would be PAIP, and building prolog & stuff that it does
<White_Flame>
prolog-in-lisp
<lotuseater>
yes i worked through some chapters
<White_Flame>
and then once you know that stuff, you can consider caching, forward chaining, and open world implications
galex-713 has joined #lisp
<White_Flame>
and then you basically have the same tech as cyc
<White_Flame>
then, you have to figure out how to use that substrate well, which is the second 90% of the problem
<lotuseater>
this CLIPS (and not CLISP) expert system is also widely used
<White_Flame>
yep, I've used it
<White_Flame>
that's purely forward chaining rete, which has some real logical limitations
<lotuseater>
oh cool, i also know one who has a job with it
<White_Flame>
eg, multiple firings if some inference result happens to be true from multiple paths
<White_Flame>
huh, where at?
<lotuseater>
can you explain?
<lotuseater>
in Essen here in Germany, I'm living near by
<White_Flame>
when (a ?foo) then do-something
<lotuseater>
but nobody approx the hole country does lisp stuff or functional programming
<lotuseater>
ah okay
<White_Flame>
(a 3) can become true multiple times, and your do-something will fire multiple times
Oladon has quit [Read error: Connection reset by peer]
<White_Flame>
also, if you have the same shape both logically and non-logically asserted, the non-logical retraction will destroy the fact even though it still has logical support
<White_Flame>
it's not a very general logic system, but it's a good programming system
<lotuseater>
yes something like that someone said about cyc
Oladon has joined #lisp
<White_Flame>
no, cyc should handle things like that just fine
<lotuseater>
hmm
<White_Flame>
cyc is also one of the only systems I've seen that can transparently spill large fact bases to disk, which is a nice-to-have
<lotuseater>
so you tried it in practice?
Oladon has quit [Read error: Connection reset by peer]
<White_Flame>
I haven't learned enough about how to use cyc to use it effectively. yet.
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
How much stuff can Clyc do?
Oladon has joined #lisp
<lotuseater>
I think over and over again I'm anyway not intelligent enough to understand that all, let alone doing anything myself.
<lotuseater>
no-defun-allowed: from what i've seen it can do much topics, also something like inference the path what you have for a dicease from symptoms
<no-defun-allowed>
Clyc is White_Flame's implementation(?) of Cyc.
<lotuseater>
oh sorry :D
White_Flame has quit [Ping timeout: 240 seconds]
White_Flame has joined #lisp
<White_Flame>
they released OpenCyc in the past, as well as a component of LarKC
<White_Flame>
they released OpenCyc in the past, as well as a component of LarKC
<White_Flame>
so it's free to fiddle with
<White_Flame>
it just doesn't come with their large knowledgebases
<White_Flame>
(sorry, got disconnected)
tessier has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
kaftejiman has quit [Remote host closed the connection]
<lotuseater>
no problem, thx
nkatte has joined #lisp
ebrasca has quit [Remote host closed the connection]
torbo has joined #lisp
shifty has joined #lisp
yonkunas has quit [Ping timeout: 244 seconds]
splittist has quit [Ping timeout: 244 seconds]
yonkunas has joined #lisp
splittist has joined #lisp
ebrasca has joined #lisp
pent has quit [Ping timeout: 244 seconds]
physpi has quit [Ping timeout: 244 seconds]
l1x has quit [Ping timeout: 244 seconds]
stylewarning has quit [Ping timeout: 244 seconds]
<jeosol>
White_Flame: while on cyc, are you aware of powerlooms (?) I think it's called out of the group in USC
pent has joined #lisp
l1x has joined #lisp
stylewarning has joined #lisp
<White_Flame>
I was fiddling with it last week or so
<White_Flame>
the documentation is pretty lacking
<jeosol>
Everytime I had discussion regarding Cyc, even a few weeks ago, someone said Doug Lenat's approach wasn't correct.
physpi has joined #lisp
<White_Flame>
I was trying to figure out how to trigger lisp from goes-true-daemon facts
<jeosol>
I actually installed it and tried to evaluate it to test a small reasoning I wanted to build.
noobineer has quit [Read error: Connection reset by peer]
<White_Flame>
I'm evaluating stuff for big reasoning projects
<jeosol>
aah ok. I am not expert, as you aware, I am in the other logicmoo channel and got info from aindilis and dmiles - he told me about looms
noobineer has joined #lisp
<jeosol>
s/not/no
<White_Flame>
it has multiple layers, and it's difficult to know what you can call from where
<White_Flame>
for its basic reasoning purposes it should be fine
<jeosol>
my interest was understanding how uncertainty in inputs gets propagated into outputs. I did look into mycin
wxie has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
theBlackDragon has quit [Quit: Boom.]
iskander- has quit [Ping timeout: 272 seconds]
bcasiello has joined #lisp
iskander has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
bjorkint0sh has joined #lisp
EvW has joined #lisp
bjorkintosh has quit [Read error: Connection reset by peer]
<Kabriel>
When I go to quicklisp.org and search for libraries, it goes to website "bye common lispers". What happened? Is there an alternative?
EvW has quit [Ping timeout: 244 seconds]
<Xach>
o lord
<Xach>
i still have to update that
<Xach>
Kabriel: i link a site called quickdocs.org that is no longer active
<Xach>
argh
rumbler31 has quit [Read error: Connection reset by peer]
Lord_of_Life_ has joined #lisp
rumbler31 has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
pfdietz has quit [Remote host closed the connection]
Lord_of_Life_ is now known as Lord_of_Life
dbotton has joined #lisp
krid has joined #lisp
<dbotton>
Is there a way using lparallel to submit a task where the result will be discarded (ie just like a simple make-thread.but will use one of the lparallel worker threads)
surabax has quit [Quit: Leaving]
<mfiano>
Don't get the result off of the channel
thefunc5 has joined #lisp
<dbotton>
Won’t that collect garbage?
toorevitimirp has joined #lisp
<thefunc5>
So where do i go for Common Lisp language documentation if Quickdocs is now gone?
<moon-child>
hyperspec?
<thefunc5>
having dabbled in Elixir, i was spoiled by Hexdocs. Is there something like that for Common Lisp?
<mfiano>
Quickdocs didn't have language docs.
zcheng3 has quit [Ping timeout: 272 seconds]
<thefunc5>
Is there a better way to navigate Hyperspec?
<thefunc5>
feels...cludgy?
<mfiano>
You can use the builtin function #'documentation, or browse any documentation in the repository manually.
<markasoftware>
thefunc5: slime has C-c C-d h
<thefunc5>
markasoftware: thx! that def helps!
<thefunc5>
mfiano: still VERY new...how do i call that?
<markasoftware>
do you have slime installed in emacs?
<asarch>
One stupid question: how do you do Test-Driven Development in Common Lisp?
<jmercouris>
You write a test, and then you try to pass the test
<jmercouris>
same as any other language
<jmercouris>
you can use ASDF to run your test suites
<jmercouris>
you can use Prove, or Rove, or FiveAM or anything you like
<jmercouris>
TDD is fundamentally the same everywhere, specify an API
<jmercouris>
and keep programming until you fulfill the API
<jmercouris>
if the API is sufficiently specified in the tests, then you are good
<jmercouris>
that said, I do not reccomend TDD, it is a idea that sounds good, but doesn't work well in practice
<jmercouris>
makes for cool demos though
abel-abel has quit []
<asarch>
What should I do instead of TDD, I mean, what do professionals do in this case?
<jeosol>
jmercouris: you sound like an evangelist, only to back way ...
<jmercouris>
asarch: that's subject to your organization
<jmercouris>
jeosol: :-D
<asarch>
I see
<asarch>
Thank you!
<asarch>
Thank you very much jmercouris :-)
<jmercouris>
no problem!
<jeosol>
asarch: If you are just starting you, you probably don't worry to too much about test, but if your team is in deployment mode and you are releasing versions to production,then you'd worry that things in the release branch pass tests, for example
<phoe>
asarch: do TDD the Lisp way
<asarch>
How?
<jmercouris>
phoe: you mean the REPL?
<phoe>
test your object in the REPL, then copypaste your REPL forms into test files
<jmercouris>
that's basically what I do
<phoe>
along with the expected values
<jmercouris>
I wish there was a way to remember all forms and copy them into a file automatically or something
johnjay has joined #lisp
pi123 has quit [Read error: Connection reset by peer]
<jmercouris>
what I will often do is just draft it into a file and then C-c C-c over and over again until it works
<jmercouris>
phoe: well, not exactly
<jmercouris>
phoe: I didn't mean *all* forms :-D
heisig has quit [Quit: Leaving]
<jackdaniel>
dribble has also a "meaningful-forms-only" mode, it is invoked like (dribble :meanigfull-p (lambda (form) (decide-whether-form-is-meaningful form)))
<jmercouris>
jackdaniel: you got me for a second I even opened up the CLHS
<jmercouris>
I thought maybe it would be some simple predicate that decides whether a form is 'meaningful' or not lol
liberliver has joined #lisp
andreyorst` has quit [Quit: andreyorst`]
zaquest has joined #lisp
zaquest has quit [Remote host closed the connection]
rumbler31 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
liberliver has quit [Quit: liberliver]
<phoe>
jmercouris: oh
<phoe>
I think that copypasting some forms into a separate buffer and going C-c C-c or C-c C-k on it is the best way forward, then
<phoe>
and making frequent git commits so the file history is remembered.
<jmercouris>
hai
<jmercouris>
I wonder though, is there a better way...
<jmercouris>
if we could reimagine things, what would we do?
<jmercouris>
what I always wanted was to be able to iterate on some form in the repl and say something like save function XYZ
<jmercouris>
if I defun'd it nicely
<jmercouris>
so let's say I'm in the repl and I (defun func (xyz) ..) and I really like it
<jmercouris>
if only there was a simple command
andreyorst` has joined #lisp
<jmercouris>
like update-or-save-function and I could type func and it would do it
<jmercouris>
that, that would be cool
EvW has joined #lisp
andreyorst` has quit [Client Quit]
francogrex has joined #lisp
andreyorst has joined #lisp
<francogrex>
Hi, is everyone ok with swig removing lisp support (cffi namely)? this seems harsh on the lisp community. I don't like it
<random-nick>
what's the default test for MEMBER? EQUAL or EQL?
<Bike>
default tests are almost always EQL.
<Bike>
including for member
<jmercouris>
what Bike said
<random-nick>
thank you
dim has quit [Ping timeout: 240 seconds]
<jmercouris>
francogrex: I don't use Swig, but I am not OK with that
<Bike>
didn't they drop it because the support was unmaintained and didn't work?
urek has quit [Ping timeout: 272 seconds]
<jmercouris>
presumably
<jmercouris>
I can still be salty about it :-D
drot has joined #lisp
zaquest has joined #lisp
zaquest has quit [Remote host closed the connection]
dim has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
JohnnyL has joined #lisp
thijso has quit [Remote host closed the connection]
hnOsmium0001 has joined #lisp
ldb has quit [Quit: ERC (IRC client for Emacs 26.1)]
krid has quit [Ping timeout: 240 seconds]
skapata has joined #lisp
zcheng3 has quit [Ping timeout: 256 seconds]
aartaka has joined #lisp
surabax has quit [Ping timeout: 256 seconds]
Codaraxis_ has quit [Ping timeout: 246 seconds]
aartaka_d has joined #lisp
Codaraxis_ has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
diamondbond has quit [Ping timeout: 256 seconds]
surabax has joined #lisp
rogersm has quit [Quit: Leaving...]
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
urek has joined #lisp
urek has quit [Remote host closed the connection]
urek has joined #lisp
Codaraxis_ has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
charlie770 has quit [Quit: thatsit]
<semz>
Aren't there lisp-side solutions that do something similar to swig?
<semz>
I suppose it wouldn't be able to reuse Swig-style interface definitions
<edgar-rft>
Lisp loves being autistic, it doesn't want to talk to the outside world.
<semz>
can you blame it? :-)
<francogrex>
Bike: yes that's what they say, the support was probably unmaintained, but it didn't didn't work! It was working ok. well there are still old releases
EvW has quit [Ping timeout: 260 seconds]
<francogrex>
semz: not that I am aware of (other sol)
<borodust>
but also worse, cuz it doesnt have any dics
<borodust>
err, docs
srji has joined #lisp
<borodust>
and god forbid you to look into sources of either one
srji has quit [Client Quit]
srji has joined #lisp
<borodust>
on the other hand, i wrap c++ stuff with it ;p
gioyik has quit [Ping timeout: 265 seconds]
diamondbond has joined #lisp
sjl has quit [Quit: WeeChat 2.3-dev]
KREYREEN has quit [Remote host closed the connection]
shka_ has quit [Quit: Konversation terminated!]
KREYREEN has joined #lisp
aartaka_d has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
pyc has joined #lisp
<pyc>
Do you use paredit while working with Emacs + SLIME + SBCL?
<phoe>
smartparens
EvW has quit [Ping timeout: 244 seconds]
EvW has joined #lisp
karayan has quit [Ping timeout: 260 seconds]
karayan has joined #lisp
sirvolta has joined #lisp
gioyik has joined #lisp
wsinatra has quit [Ping timeout: 264 seconds]
mbomba has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
<pyc>
Is there a SLIME command to evaluate the current expression? The C-x C-e evaluates the expression before the cursor and C-M-x evaluates the top-level form. Is there something to evaluate the entire current expression regardless of where the cursor is within the current expression?
<semz>
What does current expression mean here
frodef has joined #lisp
KREYREEN has quit [Remote host closed the connection]
KREYREEN has joined #lisp
<ane>
pyc: at least SLY has eval-region
<ane>
don't know if SLIME has it
frodef has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
wsinatra has joined #lisp
JohnnyL has quit [Ping timeout: 256 seconds]
Misha_B has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
karayan has quit [Remote host closed the connection]
karayan has joined #lisp
Rengan has joined #lisp
amb007 has joined #lisp
abhixec has quit [Ping timeout: 246 seconds]
<pyc>
semz: If I have an expression (+ (+ 1 2) 3) and the cursor is on '2', then I want only (+ 1 2) to be evaluated. Vim + Slimv has a command ,e does this. Wondering if SLIME has something for it.
hal99999 has quit [Quit: hal99999]
abhixec has joined #lisp
<Bike>
is 2 not its own expression?
<phoe>
is, it evaluates to 2
<phoe>
you might want to put your cursor on a parenthesis
zacts has joined #lisp
<asarch>
Thank you pfdietz!
<asarch>
Thank you very much :-)
<semz>
pyc: I'm not aware of an explicit command, though ) C-x C-e will have the same effect modulo changing your cursor position at least. For all I know, that might be enough for you.
mbrumlow has quit [Ping timeout: 265 seconds]
hal99999 has joined #lisp
francogrex has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
andreyorst has quit [Ping timeout: 240 seconds]
davisr_ has quit [Read error: Connection reset by peer]
davisr_ has joined #lisp
<ane>
pyc: with paredit you can use C-M-n (paredit-forward-up) to jump after to the nearest surrounding sexp, or, you could install expand-region, use it once to mark the surrounding sexp, and then use eval-region
dbotton has joined #lisp
frodef has joined #lisp
Inline has joined #lisp
zacts has quit [Quit: leaving]
mbrumlow has joined #lisp
zacts has joined #lisp
abhixec has quit [Ping timeout: 260 seconds]
random-nick has quit [Quit: quit]
surabax has quit [Ping timeout: 256 seconds]
random-nick has joined #lisp
ggole has quit [Quit: Leaving]
luis has quit [Ping timeout: 272 seconds]
luis3 has joined #lisp
Lycurgus has joined #lisp
narimiran has quit [Ping timeout: 256 seconds]
madage has quit [Remote host closed the connection]
madage has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
aaaaaa has joined #lisp
dim has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
<pfdietz>
asarch: Lisp continues the tradition of everyone + dog inventing their own test frameworks. But RT was the first, I think. It's available in quicklisp.
bcasiello_ has quit [Quit: Leaving]
bcasiello has joined #lisp
<pfdietz>
And you're welcome. :)
ebrasca has quit [Remote host closed the connection]
aartaka_d has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 260 seconds]
zacts has quit [Ping timeout: 264 seconds]
judson_ has joined #lisp
urek has quit [Ping timeout: 256 seconds]
zacts has joined #lisp
EvW has joined #lisp
nkatte has quit [Ping timeout: 244 seconds]
oni_on_ion is now known as oni-on-ion
cosimone has joined #lisp
zacts has quit [Quit: leaving]
imode has joined #lisp
matzesc has quit [Quit: Leaving]
dbotton has quit [Quit: This computer has gone to sleep]
<bqv>
there's a number of repos in quicklisp-projects that refer to bitbucket mercurial repositories
<bqv>
which is an issue, because bitbucket no longer supports mercurial repositories :D
<asarch>
Thank you very much once again pfdietz :-)
urek has joined #lisp
frodef has quit [Ping timeout: 256 seconds]
kaftejiman has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
EvW has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
shka_ has quit [Ping timeout: 265 seconds]
kaftejiman has joined #lisp
aaaaaa has quit [Quit: leaving]
dim has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
Lycurgus has quit [Quit: Exeunt]
kaftejiman has quit [Remote host closed the connection]
EvW has joined #lisp
kaftejiman has joined #lisp
aartaka has quit [Ping timeout: 272 seconds]
davisr_ has quit [Quit: Leaving]
Josh_2 has joined #lisp
<Josh_2>
Hey, whats the goto way to handle relative paths? so I need to make all paths relative to the system location?
<phoe>
asdf:system-relative-pathname you mean?
<phoe>
or something else?
pve has quit [Quit: leaving]
thijso has joined #lisp
<mfiano>
Just store relative pathnames, and build it up with asdf:system-relative-pathname or POSIX argv0 depending on your environment (the former isn't valid with relocated binaries).
skapata has quit [Ping timeout: 272 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
bilegeek has joined #lisp
<Josh_2>
Well the main concern is a dumped image
<mfiano>
Then you'll need to use argv0 or something, since the dumped image's asdf system path is not very useful to prepend to your relative pathnames.
<Josh_2>
Yes thats what I was thinking
<mfiano>
I might have some code laying around
<Josh_2>
If I could take a look that would be a great help
<mfiano>
=release= is set to T when deploying, otherwise when NIL during development uses asdf
frodef has joined #lisp
dim has quit [Ping timeout: 246 seconds]
<Josh_2>
Okay thanks
<mfiano>
This means that you need to build your full pathnames at runtime, of course.
<mfiano>
Storing relative in code for production and development.
<Josh_2>
Yes thats okay
euandreh has quit [Ping timeout: 272 seconds]
frgo has quit [Read error: Connection reset by peer]
frgo has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
hal99999 has quit [Quit: hal99999]
skapata has joined #lisp
daphnis has joined #lisp
judson_ has joined #lisp
gioyik has quit [Quit: WeeChat 3.0]
bcasiello has quit [Quit: Leaving]
nij has joined #lisp
Rengan has quit [Quit: Leaving]
MichaelRaskin has joined #lisp
mbomba has quit [Quit: WeeChat 3.0]
<nij>
Hi! I'm reading /On Lisp/ upto chapter 8, and feel like to pause a bit to get my hands on writing some lisps. I will use /Land of lisps/ for that. However, I have the impression that the implementations are slightly different (clisp? vs??). Will I meet any trouble coming back to /On Lisp/ after fiddling with clisp for a while?
<no-defun-allowed>
The choice of Common Lisp implementation doesn't matter at all. CLISP isn't really maintained, though.
<no-defun-allowed>
The only difference is that CLISP has a readline-based system, but most people use a Lisp implementation from an editor plugin (such as SLIME or SLIMV) which provides its own completion and editing.
<nij>
Can I use SLIME for CLISP?
<no-defun-allowed>
Yes, but you may as well use a more maintained (and much faster) implementation like SBCL or Clozure.
<nij>
Excited!
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
<edgar-rft>
Hi nij! :-) Probably most people here use SBCL, you can use rlwrap (linux package) to get an interactive terminal line editor for SBCL, or Emacs+Slime.
<edgar-rft>
...and yes, Slime works also with CLISP
Josh_2 has quit [Remote host closed the connection]
dvdmuckle has quit [Quit: Bouncer Surgery]
Josh_2 has joined #lisp
dvdmuckle has joined #lisp
<Josh_2>
did my message about asdf:make get sent before I dc'd?
thmprover has joined #lisp
<thmprover>
Question: what equality operator should I use for comparing CLOS objects?
<thmprover>
I thought equalp, but that doesn't work :S
<Josh_2>
if you want to check if It's the exact same object as the other you can use eq
<Josh_2>
that will compare the pointers
<thmprover>
I want to see if they are "structurally isomorphic", not identical objects.
<mfiano>
You cannot
<mfiano>
equalp will do a shallow check for structure-objects, but there is no check for standard-objects.
<thmprover>
So it looks like I'll need to use defstruct, then, instead of defclass (to take advantage of equalp)
<mfiano>
It is not a deep comparison however
<thmprover>
What?
Blukunfando has quit [Ping timeout: 256 seconds]
<mfiano>
Like you're not going to know if some slot of a struct that holds a reference to some other aggregate object has changed state
<thmprover>
Ah, gotchya.
<mfiano>
Nothing is preventing you from using the MOP to do the same for standard-objects, though.
<mfiano>
I would strongly shy away from structs for 99% of use cases.
<no-defun-allowed>
I'm not sure if comparing objects by comparing their slots is morally the right thing to do, but I can't suggest a better alternative.
<thmprover>
Could I do something like (defmethod equalp ((self my-class) other) ...) ?
<mfiano>
Not unless you shadow CL's equalp
<mfiano>
equalp is not a generic function, and you can't redefine it to be one unless you make a new symbol in a new package
<no-defun-allowed>
Not with the name equalp. But you would generally want (defmethod somewhat-equal (a b) nil) (defmethod somewhat-equal ((a a-class) (b a-class)) ...)
kir0ul_ has quit [Ping timeout: 264 seconds]
<thmprover>
You wouldn't do (defmethod somewhat-equal (a b) (equalp a b)) ?
<no-defun-allowed>
Ah, you probably would.
<no-defun-allowed>
But note the multiple dispatch; you're losing out if you call one argument SELF usually.
random-nick has quit [Ping timeout: 256 seconds]
frgo has quit [Remote host closed the connection]
<Josh_2>
I have added this to my https://plaster.tymoon.eu/view/2181#2181 .asd and I'm using asdf:make to build my project, however my image is not being compressed