<mfiano>
I'm looking at your sandalphon.lambda-list library...
<mfiano>
I would like to write a macro that allows specifying types for each argument, so that I can include an ftype declaration in the expansion. Can you give me some pointers on how to use your library to do that? :)
<Bike>
i can't recommend using that library, i think it's better to use an actual parser with a grammar. i don't know if there are other independent parsers though. i know sicl has one
<mfiano>
Oh hmm
<Bike>
to be entirely honest, i don't remember how that library works.
fikka has joined #lisp
<mfiano>
Ha fair enough. I really don't want to parse a lambda list myself. My library is in disrepair right now ever since I ripped out the defstar library due to being GPLv3.
<Bike>
yeah, it kind of sucks honestly.
<mfiano>
There doesn't seem to be many choices here to just add typed arguments to a defun wrapper
<Bike>
the one in sicl, or rather concrete-syntax-tree, uses a proper earley grammar
<Bike>
but i don't remember more details
<mfiano>
I guess i'm pretty much screwed...oh well, moving on. Thanks
<Bike>
Sorry
fikka has quit [Ping timeout: 276 seconds]
buffergn0me has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
zachk has quit [Quit: Leaving]
mathrick has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
drl has quit [Quit: Ex-Chat]
fikka has quit [Ping timeout: 240 seconds]
housel has quit [Remote host closed the connection]
fikka has joined #lisp
markoong has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 264 seconds]
markoong has joined #lisp
markoong has quit [Read error: Connection reset by peer]
aindilis has quit [Remote host closed the connection]
nowhereman_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
papachan has quit [Quit: WeeChat 2.1]
aindilis has joined #lisp
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
robotoad has quit [Quit: robotoad]
fikka has joined #lisp
fikka has joined #lisp
_whitelogger has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
charh has quit [Quit: zZz]
brendyn has joined #lisp
fikka has joined #lisp
Oladon has quit [Quit: Leaving.]
buffergn0me has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
kozy has joined #lisp
dddddd has quit [Remote host closed the connection]
<loke>
pjb: Right, but in the discussion I had the person was arguing that the object orientation in Objective C was somehow fundamentally different from that of, say, Java because it's “message passing”.
fikka has joined #lisp
<aeth>
mfiano: I have a typed define-function
<mfiano>
I just wrote one, thanks
<aeth>
It's harder than it looks in edge cases. I don't currently have typed keyword/optional/rest, for instance. I'll probably copy the syntax from pillton's specialization-store there. Similar syntax already, except I don't provide a return type
fikka has quit [Ping timeout: 240 seconds]
<mfiano>
I do
<aeth>
My return-type will probably be in a keyword argument to the name-and-options instead of its own field after the lambda-list like in specialization-store because I rarely need it
<mfiano>
my signature is (name typed-args (-> result &key inline) &body body)
<mfiano>
and typed-args can be any OLL arguments aside &aux, because I'm lazy and never use them
<mfiano>
THis is for a specialized library anyhow
<White_Flame>
loke: wikipedia says the major difference is that the target method is determined at runtime by the object's code, instead of at compile-time. So that's a bit more CLOSsy, in the runtime aspect
<aeth>
specialization-store is (name-and-options typed-lambda-list result-type &body body) and mine is (name-and-options typed-lambda-list &body body)
<aeth>
In both, you'd inline like (foo :inline t) in the name arg
<mfiano>
Ok?
fikka has joined #lisp
johnvonneumann has joined #lisp
Guest35752 has quit [Read error: Connection reset by peer]
johnvonneumann is now known as Guest94636
<aeth>
All that's really missing is a defmethod that supports inline and classes for keyword/optional (which iirc are not supported, possibly because of the ambiguity in a straightforward attempt)
<aeth>
Then that part of CL is essentially complete.
proshlo has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
<proshlo>
I'd like to write a Common Lisp interpreter on a graphing calculator so I can use Macsyma on it. Where should I start? I have an almost-finished Scheme interpreter in C++. Do I add special forms to make it a Lisp-2 and add defmacro facilities to bootstrap the rest? Should I go off the Clisp source code instead?
fikka has joined #lisp
<Bike>
i recommend not doing it from scratch
<proshlo>
Is there an alternative?
<loke>
proshlo: You can already run Maxima on Android. It's based on ECL.
<blep-on-external>
if you can run C on it, porting ECL could be easier
<aeth>
Well, you can't have a significantly better one because they're mostly used on standardized tests or in classrooms.
<proshlo>
aeth: I think the most powerful version of the TI-84s has a 15mhz CPU and 24mB of ram.
<Bike>
proshlo: i mean, a lisp interpreter isn't really much harder than a scheme interpreter. having actual library functions is more work than the basic "if you type Z that evaluates to Y" stuff.
<blep-on-external>
i'm not saying get it from arxiv, but get it from arxiv and say if it's any good
<White_Flame>
proshlo: Scheme was intended as a minimalist language. Continuations can be kinda confusing, but would be a lot easier to implement in an interpreter than in a compiler
<loke>
proshlo: 24 millibyte?
<Bike>
i also thought modern graphing calculators had some basic CAS in them. i know mine does
<proshlo>
loke: 24mb of RAM
<loke>
proshlo: mb means millibits
<loke>
I'm guessing that you mean MB
fikka has quit [Ping timeout: 268 seconds]
<proshlo>
loke: yeah Bike: Mine can do numerical integration, but not symbolic. I'd like to have that because Calc II is hard. :)
<aeth>
And it's an old enough app that it doesn't have ads or microtransactions or other nonsense! (I don't think I would have found it in today's Android.)
<loke>
Me and a friend implemented LISP-EVAL on the hp48. It wasn't much code, and it gave us Lisp.
<aeth>
loke: Do you still have the program? It would be interesting to see if it runs in Droid 48
<loke>
aeth: LISP-EVAL? No... we wrote it on the actual device, and lost the code before we could save it.
<loke>
We only spent a couple of hours on it, but it was pretty complete.
<loke>
One interesting aspect of the HP-48 language is if A contains the symbol B, and B contains the symbol C, then evaluating A results in C.
<proshlo>
blep-on-external: Thanks for the link. I'll try implementing this.
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Domaldel has quit [Quit: Leaving]
fikka has joined #lisp
lnostdal has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
jibanes has joined #lisp
<beach>
Good morning everyone!
fikka has joined #lisp
xrash has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
surya has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
Axe_Yell has joined #lisp
lnostdal has joined #lisp
shangul has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
dieggsy has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
detectiveaoi has quit [Quit: Leaving...]
EvW1 has joined #lisp
dieggsy has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
skapata has quit [Remote host closed the connection]
EvW1 has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Remote host closed the connection]
karlosz has joined #lisp
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
jmsb has quit [Ping timeout: 256 seconds]
<makomo>
morning
<beach>
Hello makomo.
<makomo>
beach: where in SICL can i find the lambda-list parser?
<beach>
Hold on...
fikka has quit [Ping timeout: 268 seconds]
wigust has joined #lisp
<makomo>
i just found parse-macro-lambda-list, but i'm interested in the one using a proper grammar and an early parser
<beach>
The old one (deprecated) is in Code/Cleavir/Code-utilities/lambda-lists.lisp
<beach>
Oh, that one.
<beach>
It is in the CST repository.
<beach>
Concrete-Syntax-Tree
<makomo>
ah
<beach>
Not in SICL.
<makomo>
i see it, thanks :-)
<beach>
Great!
sbwhitecap has joined #lisp
_whitelogger has joined #lisp
smurfrobot has quit [Remote host closed the connection]
vitali has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
Bike has quit [Quit: Lost terminal]
fikka has quit [Ping timeout: 256 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
yangby has joined #lisp
fikka has joined #lisp
sbwhitecap has quit [Read error: Connection reset by peer]
surya_ has joined #lisp
surya has quit [Ping timeout: 240 seconds]
Axe_Yell has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
doesthiswork has quit [Quit: Leaving.]
buffergn0me has quit [Ping timeout: 245 seconds]
vtomole has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Oladon has quit [Quit: Leaving.]
smurfrobot has joined #lisp
davsebamse has quit [Ping timeout: 256 seconds]
vtomole has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
shka_ has joined #lisp
davsebamse has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
igemnace has joined #lisp
shrdlu68 has joined #lisp
fikka has joined #lisp
yangby has quit [Quit: Go out for a walk and buy a drink.]
fikka has quit [Ping timeout: 245 seconds]
vlatkoB has joined #lisp
fikka has joined #lisp
FreeBirdLjj has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
surya_ has quit [Ping timeout: 245 seconds]
Murii_ has joined #lisp
<Murii_>
Hi, how can I change a "car" ?
<Murii_>
I'm looking for something like: (setcar var val)
karlosz has quit [Quit: karlosz]
DataLinkDroid2 is now known as DataLinkDroid
fikka has joined #lisp
littlelisper has joined #lisp
<littlelisper>
any way i can convert a character into a string?
shrdlu68 has quit [Read error: Connection reset by peer]
<shka_>
the downfall of pascal is unfortunate imho
pjb has quit [Ping timeout: 245 seconds]
<beach>
Nah. It wasn't great.
<shka_>
i wasn't, but it was acceptable medium of education
<shka_>
unlike C
<beach>
That might be true.
makomo has quit [Ping timeout: 240 seconds]
<shka_>
decline of didactic languages is worrying trend
<shka_>
at least scheme keeps on living
robotoad has joined #lisp
vitali has joined #lisp
<shka_>
besides, at work C++ projects takes over 1 hour to build on modern PC
<shka_>
that makes me think that Turbo Pascal had it's merits :D
<shka_>
gladly, i escaped that trap
knicklux has quit [Ping timeout: 240 seconds]
pjb` has quit [Ping timeout: 256 seconds]
<Murii_>
shka_, that can happen with Java as well and thb I don't see the problem if you know what I mean ;)
makomo has joined #lisp
<shka_>
Murii_: corporations will find other language to build pyramids
<Murii_>
I mean, not really 1h but long compile times
<Murii_>
maybe
<shka_>
aaah, about that
<MichaelRaskin>
I think at the same level of implementation effort Pascal is better than C and Object Pascal chimera is better than C++.
<shka_>
no java, builds quite fast
<Murii_>
gwt does not
<Murii_>
java to js
<shka_>
well, but pascal is quite dead
<shka_>
delphi still lives, but barely
<MichaelRaskin>
The scary part that I am not sure there is anything better for quickly mashing together a native GUI app than Lazarus and FPC (Lazarus being a free/libre Delphi look-alike)
Axe_Yell has joined #lisp
Murii_ has quit [Ping timeout: 264 seconds]
vitali has quit [Ping timeout: 245 seconds]
<MichaelRaskin>
beach: how do you expect debugger thread to learn that the debugged thread has reached a breakpoint?
<LdBeth>
I think the breakpoint is injected into code
<MichaelRaskin>
LdBeth: this is what happens in the _debugged_ thread
<MichaelRaskin>
And for this I have something now.
<MichaelRaskin>
But the debugger thread says «step»
<MichaelRaskin>
What happens now with it? It waits on a lock? What if the step-over doesn't complete in any reasonable time?
<MichaelRaskin>
Or is it actively polling?
<MichaelRaskin>
Waiting with one-second timeout?
pagnol has joined #lisp
robotoad has quit [Quit: robotoad]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
MichaelRaskin: Good question.
<beach>
MichaelRaskin: I think that before going blocked, they will inform the debugger thread.
<MichaelRaskin>
That is for sure, but via which mechanism?
<beach>
I'm not sure. I am not so good with threads yet.
random-nick has quit [Read error: Connection reset by peer]
<MichaelRaskin>
OK, I can probably translate the properties of notification mechanism into thread primitives.
<MichaelRaskin>
When debugger says «step over», can it ever continue execution before step-over is complete?
<beach>
Yeah. I would have to look them up and make a choice.
<MichaelRaskin>
In a way, this is a separate layer so if you answer a few yes-or-no questions I can implement something, and this layer can be swapped out if needed
<beach>
Sure.
<Athas>
b
<beach>
Hello Athas!
<Athas>
Hi! That was a mere typo, unfortunately. I have nothing to contribute.
<MichaelRaskin>
Because the lowest layer (inject poll points, inject whole-function-skipping for undebugged threads, control debuggedness) works now.
<beach>
Athas: Still, good to see you back.
<beach>
MichaelRaskin: Oh, nice!
<MichaelRaskin>
Obviously, I use it for silly tracing
<beach>
Right. Interactive debuggers are not your thing as I recall.
<MichaelRaskin>
Also, it is not yet at the level where it can be even used as interactive.
<beach>
I understand.
<MichaelRaskin>
Which is why I ask about the communication logic.
<MichaelRaskin>
So, yes-or-no: debugger thread invoking setp-over has a chance to change its mind before step-over operation is complete?
<MichaelRaskin>
step-over
<beach>
Sure. But what do you think will happen if it changes its mind?
<MichaelRaskin>
Well, simple case: it could add more breakpoints.
<beach>
I think what I wrote in the specification is that the debugger creates volatile breakpoints and all those are removed when the debugged thread stops at any kind of breakpoint. So it's enough for the debugger to remove the volatile breakpoint before the application thread reaches it.
<beach>
Sure, I don't see a problem with that.
nowhereman_ has quit [Ping timeout: 245 seconds]
<MichaelRaskin>
My plan is to show you a demo where you will agree that details like breakpoint volatileness can be implemented independently of underlying implementation.
<beach>
OK. I think whether a breakpoint is volatile or not is just a bit set by the debugger in whatever representation it has for breakpoints.
<MichaelRaskin>
On the other hand, debugger thread constantly doing something (polling a variable) as fast as possible (a state known as spinlock) and maybe deciding to change its mind based on another variable it polls is probably a bad idea (spinlocks are often very efficient at hogging a core fore doing nothing)?
<MichaelRaskin>
Basically, if you reach a breakpoint, it is an expensive event and you can put whatever logic you want.
igemnace has quit [Quit: WeeChat 2.1]
<beach>
Sure.
<MichaelRaskin>
It can only happen at typing speed!
<beach>
I don't see why the debugger thread would lock at all. The user may want to interact with it when the application is running.
<MichaelRaskin>
Does user need to actively request status update to see if the breakpoint has been reached?
<beach>
I hope not.
<beach>
That would be very inconvenient.
<MichaelRaskin>
Unfortunately, if the thread is interacting with a user, there is always a risk it will enter a blocking wait for input.
<MichaelRaskin>
A notification could actually be printed by the debugged thread.
<MichaelRaskin>
(Notification callback is easy to replace at runtime as needed, f course)
<MichaelRaskin>
of course
<MichaelRaskin>
Then there is not even a notion of the debugger thread
<beach>
Or the debugger could have several threads, one waiting for the application to stop and one interacting with the user.
<MichaelRaskin>
Does this description mean that the debugger is another process?
<MichaelRaskin>
Basically, what is cheap for me is: there is no notion of «debugger thread»
<beach>
No, I definitely do not want the debugger to be another process (in the Unix sense of "process").
<MichaelRaskin>
Do you want to forbid it or do you just not care?
<beach>
I have absolutely no interest in designing a communication protocol between a debugger and an application.
<MichaelRaskin>
Fair enough.
<MichaelRaskin>
I think the notion of «debugger thread» might be misleading then
<MichaelRaskin>
There is no special status of «debugger thread»
<beach>
Correct. It's just the thread(s) that happen to run the code of the debugger. There is nothing special with it (them).
<MichaelRaskin>
There are instrumented functions. (SICL case: all of the user functions and some of the implementation functions. Portable prototype: the functions from files loaded in «wrapped» mode, the functions from files that declare themselves «wrapped», the functions that were declared wrapped on their own)
<MichaelRaskin>
Each instrumented function checks if it is in the debugger mode, if not — executes uninstrumented copy of its body, otherwise executes the body with polling points.
<beach>
Sounds good.
<MichaelRaskin>
Each polling point calls a hook (settable for each debugged thread separately)
<MichaelRaskin>
(Above this line is a summary of currently working code)
<beach>
Great!
<MichaelRaskin>
So the plan for the hook is: check if anything has to be done at all
<MichaelRaskin>
If a breakpoint (in some sense) is reached, the hook includes notification logic (simplest case: print to *trace-output*)
vitali has joined #lisp
<MichaelRaskin>
Then pauses itself
<beach>
Sounds right.
<MichaelRaskin>
After the pause it checks if a variable (tied to the thread) has been set to something it can evaluate. If it is null, it re-pauses itself (it is a loop), otherwise it evaluates the code put into the variable and clears it
<MichaelRaskin>
That code might tell it to set some breakpoints, or to evaluate stuff in context, or to exit the breakpoint and continue running
<MichaelRaskin>
We are same-process, so arbitrary code execution doesn't change anything
<beach>
Now I am a bit confused.
<beach>
Why is it the debugged thread that sets breakpoints?
<MichaelRaskin>
Good question. Examination of thread context (like thread-local values of global variables is still needed, though)
<beach>
Definitely.
<MichaelRaskin>
Where you keep the breakpoints is free choice, so yes, you can set them from debugger thread.
<MichaelRaskin>
Unless you want to have a thread-local global variable with breakpoints, then you need to do it from the debugged thread
<MichaelRaskin>
But anyway, debugger thread is nothing special unless your _notification_ logic is «unfreeze thread X»
skapata has joined #lisp
<beach>
Yes, I see, it would be highly implementation specific to examine the special variables of a different thread.
<beach>
Or anything else in the dynamic environment of some other thread.
<MichaelRaskin>
And I want something portable almost for free, so code injection for special-variable examination is my choice
<beach>
Got it.
FreeBirdLjj has quit [Remote host closed the connection]
<MichaelRaskin>
Anyway, if you want a global breakpoint table keyed on the debug session name — my current code doesn't care yet, and SBCL provides auto-locked hashtables, so it can be done externally.
<beach>
My plan was to keep the breakpoint table in the data structures of the debugger.
<MichaelRaskin>
Well, it needs to be accessible to both debugger and debugged thread
<beach>
Hmm.
SlowJimmy has quit [Ping timeout: 265 seconds]
<MichaelRaskin>
Either it is free-for-all, then it is a global hashtable/array.
<beach>
Yes, I see why it is necessary if you want your implementation to be portable the way you have said.
<MichaelRaskin>
There is another portable option that I do use for debug flag
flazh has joined #lisp
<MichaelRaskin>
Hm.
<MichaelRaskin>
I have freedom of representation, actually
<MichaelRaskin>
The other option is there is an object that the thread keeps in a thread-local global variable, and the external world accesses via a hashtable.
pagnol has quit [Ping timeout: 265 seconds]
<MichaelRaskin>
Which I actually prefer
<MichaelRaskin>
And which I should use in a less crazy way than right now
Guest94636 has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest30914
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
Lauven has joined #lisp
vitali has quit [Remote host closed the connection]
vitali has joined #lisp
margeas has joined #lisp
wigust has quit [Ping timeout: 265 seconds]
FreeBirdLjj has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
impulse has quit [Ping timeout: 256 seconds]
impulse has joined #lisp
nowhereman_ has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
nullniverse has joined #lisp
igemnace has joined #lisp
pagnol has joined #lisp
Lauven has quit [Ping timeout: 264 seconds]
ted_wroclaw has joined #lisp
Lauven has joined #lisp
xrash has joined #lisp
surya has quit [Ping timeout: 276 seconds]
nowhereman_ has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
Smokitch has quit [Remote host closed the connection]
Smokitch has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<shka_>
should i use print-object or print-unreadable for printing conditions?
Murii_ has joined #lisp
<beach>
FORMAT
<shka_>
sorry, let me rephrase it
<shka_>
i have my own condition
<shka_>
i want it to be printable
<shka_>
should i implement print-object or print-unreadable method?
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Athas has left #lisp ["ERC (IRC client for Emacs 26.1)"]
FreeBirdLjj has joined #lisp
<beach>
None of it. You should use the :report option to define-condition.
pagnol has quit [Quit: Ex-Chat]
FreeBirdLjj has quit [Remote host closed the connection]
doesthiswork has joined #lisp
housel has joined #lisp
SlowJimmy has joined #lisp
ted_wroclaw has quit [Read error: Connection reset by peer]
orivej has joined #lisp
FreeBirdLjj has joined #lisp
lumm has quit [Quit: lumm]
<shka_>
beach: oh, ok
<shka_>
i will read it
lumm has joined #lisp
paul0 has quit [Quit: Leaving]
Bike has joined #lisp
edgar-rft has quit [Remote host closed the connection]
<pjb>
com.informatimago.common-lisp.cesarum.list:nsplit-list-on-indicator is similar to your groupBy
<pjb>
ignore-errors is like mayBe; ignore-errors + parse-integer = readMayBe
<pjb>
and remove nil = mapMaybe
<pjb>
Notice that we don't have to specify any types, lisp is smarter…
<kuribas>
pjb: you don't need any in haskell either
<kuribas>
pjb: top level types are a convention, and readMaybe is ambigous.
<_death>
you can (loop for group in (group-by #'digit-char-p string) when (parse-integer group :junk-allowed t) collect it) .. just need to write group-by
<kuribas>
(Why Functional Programming Matters by John Hughes at Functional Conf 2016)
Beep-Lord has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has quit [Client Quit]
attila_lendvai has joined #lisp
<Beep-Lord>
Anyone know how to get the address of a foreign function with cffi? I have used defcfun and want to get the pointer using the symbol used for defcfun.
<pjb>
(callback fname) perhaps?
<Beep-Lord>
I believe that only works with defcallback
Fredman97 has joined #lisp
<_death>
maybe foreign-symbol-pointer
<Beep-Lord>
Needs a string
<Beep-Lord>
Case-sensitivity is lost with a foreign name translation
<Beep-Lord>
So I would need to brute force the Upper case combinations
<_death>
you've reached the wrong conclusion
<Beep-Lord>
In what way?
<_death>
f-s-p is the primitive you're looking for.. it needs a string indeed.. with defcfun, the lisp name is arbitrary, and there can be multiple lisp names for the same foreign name
buffergn0me has joined #lisp
<_death>
so if you want you can maintain a mapping from symbols to foreign names and write something to lookup and call the primitive
<Beep-Lord>
Okay, I see what you're saying. That's what I was hoping to avoid though.
attila_lendvai has quit [Quit: Leaving.]
SaganMan has joined #lisp
<_death>
you can patch cffi's %defcfun so that it will attach a foreign-name property to the symbol.. or define your own defcfun of course
daughertyh90 has joined #lisp
shangul has quit [Remote host closed the connection]
asarch has joined #lisp
shangul has joined #lisp
<Beep-Lord>
Yeah, I'll probably just wrap a macro around defcfun.
vitali has quit [Ping timeout: 255 seconds]
ckonstanski has quit [Quit: bye]
shangul has quit [Remote host closed the connection]
<Xach>
what on earth is up with different signatures for #-gsl2 #+gsl2
<Xach>
_death: thanks
<Xach>
And how did I go from one configuration to another...
Fredman has joined #lisp
Fredman97 has quit [Ping timeout: 265 seconds]
kuribas has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
lnostdal has joined #lisp
littlelisper has joined #lisp
rtt has joined #lisp
rtt has quit [Client Quit]
rtt has joined #lisp
<rtt>
hi
igemnace has joined #lisp
littlelisper has quit [Ping timeout: 240 seconds]
rtt has quit [Read error: Connection reset by peer]
<LdBeth>
Any advice on typesetting lisp code in LaTeX?
karlosz has joined #lisp
<Ukari>
is there a class or struct for representing nil? for example, (defmethod test ((x nil)) (print "nil"))
littlelisper has joined #lisp
<_death>
yes, it's called NULL
<Ukari>
well
milanj__ has quit [Read error: Connection reset by peer]
littlelisper has quit [Ping timeout: 264 seconds]
broccolistem has joined #lisp
karlosz_ has joined #lisp
milanj has joined #lisp
karlosz has quit [Ping timeout: 260 seconds]
karlosz_ is now known as karlosz
karlosz has quit [Client Quit]
karlosz has joined #lisp
groovy2shoes has quit [Ping timeout: 276 seconds]
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
milanj has quit [Read error: Connection reset by peer]
<Beep-Lord>
LdBeth, doesn't org-mode have a way to export to LaTeX? You could probably examine some of its exported code to see what it does with inline code.
milanj has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
groovy2shoes has joined #lisp
milanj has quit [Read error: Connection reset by peer]
nowhereman_ has joined #lisp
brendyn has quit [Ping timeout: 240 seconds]
josemanuel has joined #lisp
groovy2shoes has quit [Ping timeout: 276 seconds]
milanj has joined #lisp
<makomo>
Ukari: if you want to specialize on nil you can use EQL specializers: (defmethod test ((x (eql nil))))
<Ukari>
makomo, is it possible to write like this ? (defmethod test ((x (or null function))) (print "null or fun"))
proshlo has quit [Ping timeout: 240 seconds]
groovy2shoes has joined #lisp
<makomo>
Ukari: nope. a specializer can either by a CLOS class name or the special EQL specializer of the form (eql <something>) where <something> will be evaluated when the method is defined
<Ukari>
why defmethod not support different number arguments?
<pjb>
It supports it: (defmethod foo (x y) (list x y)) (defmethd bar (x) (list x))
<makomo>
Ukari: it's not that it doesn't support multiple arguments, it just doesn't support multiple *specializers*
<makomo>
well actually that's the wrong terminology
<makomo>
it doesn't support multiple types for a single specializers*
<Ukari>
i meant (defmethod test(x)) (defmethod test(x y))
<pjb>
it just doens't support TYPES!
<makomo>
pjb: true, CLOS classes/EQL specializers
<makomo>
my bad
<pjb>
methods are defined by CLOS, and CLOS defines CLASSES, not types.
<pjb>
(or x y) is a TYPE designer. There is no such thing for classes, (but perhaps, mixing subclasses: (defclass foo (a b) ()) but 1- it's not possible with built-in classes, 2- it's more like a AND than an OR.
<MichaelRaskin>
beach: OK, first use of my code to step through a loop in another thread
<Ukari>
which is recommand to use when have multiple types? single defgeneric or multi defmethod?
<pjb>
NONE!
<pjb>
Ukari: I just explained that CLOS doesn't work with types!
<makomo>
Ukari: you need both a defgeneric and a defmethod. the example that pjb wrote showed an "inline" definition of a method using the :method option with defgeneric
<pjb>
If you have multiple types, you have to use TYPECASE (or CTYPECASE or ETYPECASE) explicitely.
<pjb>
with defun.
<Ukari>
well, -> when have different typeclass
<pjb>
Notice that there is no CLASSCASE.
<Ukari>
typecase
<pjb>
defgeneric/defmethod is the classcase of CL.
<Ukari>
i found that it also supports struct and null in defmethod, are null and struct both a kind of classcase?
<pjb>
Class types are just a gateway between CLOS and CL minus CLOS, so that you can use TYPECASE with CLOS instances. But they're not useful otherwise. If you have classes, then just consider classes and do OOP. If you have types, then do usual procedural programming using typecase.
<ebrasca>
Can I overwrite one slot wich other name in some object making new subclass?
<makomo>
ebrasca: what do you mean by overwrite?
lumm has quit [Quit: lumm]
lumm has joined #lisp
<ebrasca>
mmm change some accesor name
<makomo>
ebrasca: accessors are just methods that are defined for you by defclass
robotoad has joined #lisp
<makomo>
i'm not 100% sure how accessor (:writer, :reader, :accessor) properties are inherited
<pjb>
Ukari: but be careful when reading clhs, because the information is spread all over the place. For example, clhs defstruct says "defstruct defines a structured type, named structure-type, with named slots as specified by the slot-options." but in the description of the :type option, it also says: "defstruct without a :type option defines a class with the structure name as its name. The metaclass of structure instances is
<pjb>
structure-class."
<makomo>
but if it isn't "by union", then you can just define your own on the side i guess
<ebrasca>
I am thinking how to implement ext2 and later maybe ext3 and ext4.
<pjb>
Ukari: this means that not all "structures" are classes. (defstruct point x y) -> defines a type and defines a structure class. (defstruct (point :type vector) x y) -> only defines a type!
<pjb>
Ukari: this is why if you just say that you have a structure, and moreover, if you say that you have a structure TYPE, then you CANNOT use defgeneric/defmethod because you've not affirmed you had a structure CLASS!
<pjb>
ebrasca: you can definitely add accessors to slots. And also change the type (as long as you respect the Lyskov substitution principle).
<pjb>
ebrasca: everywhere you have an instance of a class, you must be able to substitute an instance of a subclass and it should still work.
<makomo>
ebrasca: but why exactly would you want a different accessor for the same slot? what's the rationale?
<pjb>
ebrasca: this means that if you change the type of a slot in a subclass, you must still be able to to store the all the values of the type defined for the slot in the superclass, and the reader should not return any value outside of that type.
<ebrasca>
makomo: ext2 and ext4 use diferectly some slots.
<pjb>
This is why it is in your best interest to NOT specify any type to the slots of your superclasses or pre/post condition to methods of your superclasses!
<makomo>
ebrasca: in what way?
<pjb>
As soon as you specify them, you restrict greatly what the subclasses can do.
<makomo>
ebrasca: you'll have to explain that to me in the context of your CLOS model. i can't really go and read that
<ebrasca>
makomo: in ext2 it is s_log_frag_size and in ext4 it is s_log_cluster_size
<pjb>
(On the other hand, if you specify types and pre/post conditions in the superclasses, and respect them in your subclasses, you benefit greatly from OOP; few people understand it, and end rejecting OOP entirely, because they've spend all their time kludging and hacking around this).
<pjb>
makomo: sometimes it's only a question of renaming.
<pjb>
sometimes you need to enforce additionnal or different constraints, (but for additionnal constraints, you should just override the usual accessors).
<makomo>
ebrasca: and in what relationship are ext2 and ext4 exactly?
<pjb>
But it's right that it may be a hint that you're doing something very wrong: using subclassing for implementation, instead of structurally!
<ebrasca>
pjb: in both cases they are unsigned integers
<makomo>
how does your class hierarchy look like
<ebrasca>
makomo: ext4 is extension of ext3 and ext3 is extencion of ext2
<pjb>
ebrasca: don't look at what C coders wrote! They do horrible things, like reusing memory for different purposes, etc.
<makomo>
what pjb said ^. it doesn't necessarrily follow that the best model is ext2 <- ext3 <- ext4
<makomo>
although i don't know enough about ext to be confident about that
rumbler31 has joined #lisp
<pjb>
Well, you can mount an ext3 device as an ext2, IIRC. The journal is stored separately, and it will be rebuild when you remount it as ext3.
<MichaelRaskin>
I think ext4 violates some ext3 consistency guarantees
<ebrasca>
Yes it is inside some file.
<pjb>
So AFAIK, ext3 is indeed a subclass of ext2. For ext4, I don't know.
igemnace has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 256 seconds]
phoe has quit [Remote host closed the connection]
dddddd has joined #lisp
trittweiler has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
mflem has joined #lisp
Naergon has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 256 seconds]
karswell has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
cpc26 has joined #lisp
cpc26 has quit [Client Quit]
Fredman has quit [Quit: Leaving]
<shka_>
yo all
<shka_>
what is the best prolog implementation for CL out there?
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
<pjb>
(ql:quickload :paiprolog)
<shka_>
pjb: sadly, it is not as good as it can be
<pjb>
It's the most easily available.
<shka_>
no thread safety, no multithread unification
<shka_>
and codebase is rather messy
<pjb>
swi-prolog can be merged with ecl…
<shka_>
right
<shka_>
well, i guess my best bet is to get my hands dirty and work on better paiprolog
pierpal has quit [Ping timeout: 240 seconds]
Murii_ has quit [Quit: Leaving]
random-nick has quit [Read error: Connection reset by peer]
<Ukari>
(defun test (&optional x)), how could i know the difference between (test) and (test nil) ?
skapata has quit [Remote host closed the connection]
hph^ has joined #lisp
fikka has joined #lisp
Axe_Yell has quit [Quit: El Psy Congroo.]
shka_ has quit [Ping timeout: 240 seconds]
matijja has quit [Ping timeout: 248 seconds]
Smokitch has quit []
josemanuel has quit [Quit: leaving]
Pixel_Outlaw has joined #lisp
light2yellow has quit [Quit: light2yellow]
proshlo has joined #lisp
ineiros has quit [Ping timeout: 248 seconds]
ineiros has joined #lisp
xrash has quit [Remote host closed the connection]
mathrick has joined #lisp
troydm has joined #lisp
ineiros has quit [Ping timeout: 268 seconds]
vlatkoB has quit [Remote host closed the connection]
ineiros has joined #lisp
proshlo has quit [Ping timeout: 260 seconds]
buffergn0me has quit [Ping timeout: 256 seconds]
caltelt_ has joined #lisp
DataLinkDroid2 is now known as DataLinkDroid
Khisanth has quit [Ping timeout: 256 seconds]
didi has left #lisp ["there are always reasons to /part"]
Axe_Yell has joined #lisp
guaqua has quit [Ping timeout: 240 seconds]
caltelt_ has quit [Ping timeout: 265 seconds]
guaqua has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
varjag has quit [Ping timeout: 264 seconds]
random-nick has quit [Ping timeout: 264 seconds]
guaqua has quit [Ping timeout: 256 seconds]
Khisanth has joined #lisp
varjag has joined #lisp
karlosz has quit [Ping timeout: 276 seconds]
groovy2shoes has joined #lisp
varjag has quit [Ping timeout: 260 seconds]
guaqua has joined #lisp
al-damiri has joined #lisp
<drmeister>
How does write-to-string decide what width of character string its supposed to write to?
<drmeister>
If it gets a wide character does it switch to a wide character string?
ksool has quit [Ping timeout: 260 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
<Bike>
i think it's implementation dependent
<Bike>
it would be fine for it to always output a string of CHARACTERs, i think
<drmeister>
Ok.
Naergon has joined #lisp
loli has quit [Quit: WeeChat 2.1]
pagnol has quit [Ping timeout: 240 seconds]
pagnol has joined #lisp
pagnol has quit [Ping timeout: 264 seconds]
pagnol has joined #lisp
skapata has joined #lisp
Oddity has quit []
<pillton>
aeth: Was this a question about specialization-store? "All that's really missing is a defmethod that supports inline and classes for keyword/optional (which iirc are not supported, possibly because of the ambiguity in a straightforward attempt)"
drot has quit [Quit: Quit.]
sebboh has quit [Quit: WeeChat 2.0.1]
Axe_Yell has quit [Read error: Connection reset by peer]
Axe_Yell_ has joined #lisp
mega_beginner has joined #lisp
dmiles has quit [Ping timeout: 276 seconds]
logicmoo has joined #lisp
lumm_ has quit [Quit: lumm_]
Kaisyu has joined #lisp
margeas has quit [Ping timeout: 260 seconds]
* Xach
hopes he can work out his gsll issues
<mega_beginner>
Out of curiousity, is locality of reference a concern in lisp when writing code that usually requires it in C/C++/Fortran (insert "fast" language here) (such as matrix multiplication)?
<pillton>
Pardon?
proshlo has joined #lisp
<pierpa>
mega_beginner: of course it is. It is not something depending on language
<pierpa>
CL is great, but it's not magical
<mega_beginner>
I guess I have a nagging misunderstanding of how things operate at a lower level in lisp short of dissassembling everything.