<Wezl>
a reading error, not because I miss-spelled end :)
<Xach>
Wezl: usually it is (defun reproduce (v) ...)
<Wezl>
:facepalm:
<Wezl>
yes, that was causing the problem, somehow I miss typed both the original code and the code to "reproduce"
mrchampion has joined #lisp
<Wezl>
the error messages weren't that nice though...
<Xach>
What's the error?
akoana has left #lisp ["Leaving"]
<Wezl>
In function SYMBOL-NAME, the value of the first argument is
<Wezl>
(INTEGER END)
<Wezl>
which is not of the expected type SYMBOL.
<Wezl>
which looks like the error is in multiple-value-bind
aeth_ is now known as aeth
<Wezl>
XD my number parser is the biggest function in my lisp parser
Wezl has left #lisp ["thanks for the help, folks"]
imode1 has quit [Ping timeout: 264 seconds]
vegansbane6963 has quit [Remote host closed the connection]
prxq has joined #lisp
prxq_ has quit [Ping timeout: 240 seconds]
yuan has quit [Ping timeout: 240 seconds]
vegansbane6963 has joined #lisp
<beach>
Good morning everyone!
Alfr_ has joined #lisp
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
kevingal has quit [Remote host closed the connection]
drbluefall has joined #lisp
karlosz has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
epony has quit [Remote host closed the connection]
supercoven has quit [Read error: Connection reset by peer]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
egp_ has quit [Quit: EXIT]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
karlosz has quit [Quit: karlosz]
holycow has joined #lisp
karlosz has joined #lisp
<Josh_2>
morning beach
Josh_2 has quit [Remote host closed the connection]
epony has joined #lisp
<susam>
Good morning beach
<susam>
Good morning and good evening everyone! :)
gj has joined #lisp
<holycow>
o/
<pyc>
hey beach. which timezone are you from? is it morning there?
<beach>
UTC+1
<gj>
good morning
<moon-child>
I guess beach is in CET
<charles`>
Hi everyone
karlosz_ has joined #lisp
<gj>
i have a few questions about lisp things.
<moon-child>
ask
<pyc>
beach: oh! 6:02 am there right now. you are a early morning riser! nice.
<gj>
if i want to use a package in my program, say something like Drakma, how do I tell the program to do that?
<susam>
gj: Are you using Quicklisp?
<beach>
pyc: It's a genetic defect in my family. My parents were so bored between 4am and the beginning of work that they got second jobs as newspaper distributors.
<charles`>
add it in the :depends-on section in your asdf
<gj>
I am, yes. Am not quite sure how it all works, though.
<beach>
gj: You make yourself an ASDF system definition with a :depends-on clause.
<susam>
gj: If you are using Quicklisp. It is as simple as (ql:quickload :drakma).
karlosz has quit [Ping timeout: 264 seconds]
karlosz_ is now known as karlosz
<gj>
Alright, I will go and try that, thank you all so much.
<charles`>
In general, what would it take to get one of you professional Lispers to review my code?
orivej has quit [Ping timeout: 265 seconds]
egp_ has joined #lisp
gj has quit [Quit: Connection closed]
<beach>
charles`: Just paste it to, say, plaster.tymoon.eu.
Nilby has joined #lisp
<charles`>
Thank
<holycow>
.... soooo .... i finally figured out how to load local files into a clog page
<holycow>
damnit
<holycow>
this means i will now have to take my stupid audio player app and make a stupid media server
<holycow>
i'm watchign 12 monkeys in clog right now. it took like 1 line of code
<holycow>
this is ridiculous. i'm too stupid to be able to code. and yet, this is possible.
mindCrime has joined #lisp
marusich has joined #lisp
mindCrime has quit [Ping timeout: 264 seconds]
kaiwulf has quit [Ping timeout: 264 seconds]
mindCrime has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 245 seconds]
<pyc>
http://clhs.lisp.se/Body/f_open.htm - :if-exists :rename-and-delete says "The existing file is renamed to some other name, then it is deleted but not expunged, and then a new file is created." -- What is the difference between delete and expunge?
luni has quit [Quit: Connection closed]
kam1 has quit [Ping timeout: 240 seconds]
holycow has quit [Quit: Lost terminal]
<Nilby>
pyc: In old OSs you could delete things, but they weren't really deleted until a system process expunged them. This allowed temporary un-delete. Sometimes the user could trigger an expunge. Now, in practice, there is no expunge. Except secretly there is in SSDs.
<pyc>
Nilby: Is there any best practice regarding whether to use :rename-and-delete or to use :supersede with :if-exists?
djuber has quit [Ping timeout: 276 seconds]
<Nilby>
I don't know about best practice, but on some systems rename-and-delete might lose file birth date, but preserve deleted running code. I would usually choose supersed, but it depends on some subtleties of your application.
gioyik has quit [Quit: WeeChat 3.0]
<saturn2>
i have always used supersede
<Nilby>
Supersede truncates the existing file and may preserve some meta data. But rename-and-delete could be more reliable with regardds to things like permissions.
<Nilby>
(or less reliable, depending)
<Nilby>
For example, when Emacs saves a buffer, it usually uses the equivalent of rename-and-delete.
<Nilby>
But many other applications, the "Save" operation is like :supersede.
waleee-cl has quit [Quit: Connection closed for inactivity]
<Nilby>
Sorry, I probably give too complicated answers.
alandipert has quit [Remote host closed the connection]
alandipert has joined #lisp
<pyc>
Nilby: no, that is a great answer. That is the kind of details I wanted to know. thank you for sharing your knowledge.
<pyc>
so looks like I need supersede because I want a more Unixy behavior
<saturn2>
the standard leaves it up to the implementation to decide on "reasonable" behavior, which in practice means if it's really important you'd better do it yourself
karlosz has quit [Ping timeout: 260 seconds]
<pyc>
It looks to list all files under a directory recursively I need to do (directory "foo/**/*.*"). For some reason, (directory "foo/**/*") shows filenames like "bar" and ".bar" but files like "bar.txt", "bar.txt.gz", etc. Where is the wildcard notation documented?
domovod has joined #lisp
<pyc>
http://clhs.lisp.se/Body/26_glo_w.htm#wild says it is implementation-dependent: wild adj. 1. (of a namestring) using an implementation-defined syntax for naming files
<pyc>
the problem I am facing now is that if so much is implementation-dependent, should I just choose SBCL as my implementation and write code for it?
<beach>
You may regret that some day. :)
<beach>
Just put an abstraction around it and customize its implementation for different Common Lisp implementations.
aeth has quit [Ping timeout: 260 seconds]
<saturn2>
you should probably use uiop:directory-files
<pyc>
saturn2: thanks
<pyc>
beach: thanks
aeth has joined #lisp
rwcom60280385034 has joined #lisp
rwcom60280385034 has quit [Client Quit]
rwcom60280385034 has joined #lisp
CEnnis91 has quit [Quit: Connection closed for inactivity]
<pyc>
saturn2: thanks! uiop is really extensive. I see it chooses *.* as the wildcard pattern automatically for directory listing on SBCL
<pyc>
It has a (defparameter *wild-file-for-directory* ...) in pathname.lisp to choose the right wildcard pattern based on implementation.
<saturn2>
yep
nostoi has joined #lisp
<saturn2>
the attempt to support every feature of every 1980s filesystem, while leaving it completely undefined what to do when such features don't exist, was probably the worst mistake in the CL spec
egp_ has quit [Remote host closed the connection]
egp__ has quit [Remote host closed the connection]
<markasoftware>
Why is CCL's generic function implementation so weird
<beach>
How is it weird?
<beach>
I mean, in what way is it weird?
frgo has quit []
<markasoftware>
I'm still trying to wrap my head around it...it seems they do not pass the next methods as an argument to the method-function
<markasoftware>
And it seems like they threw away MOP compliance to do it this way, because make method lambda does not exist
<beach>
The default way is to pass a list of next methods, but for specified classes and generic functions, they may change that for reasons of performance.
<beach>
Yes, make-method-lambda has been abandoned in several implementations.
pve has joined #lisp
<markasoftware>
What do you mean "for specified classes"?
<beach>
A general rule that says what client code can do is that a client-specific method must not be applicable when given only arguments that are direct instances of library classes.
<beach>
So since clients can't write such methods, the library is free to violate specified behavior when this violation can't be observed by client code.
<markasoftware>
But client code could access the method-function, right? So its not quite unobservable?
<markasoftware>
Using mop:method-function
<beach>
Hold on... the method function is not what receives the list of next methods.
<beach>
The method function has the same lambda list as the DEFMETHOD form, minus specialization.
<markasoftware>
The method-function takes a list of arguments and a list of next methods according to amop, I think.
<beach>
You may be right.
<beach>
But that doesn't count as observable.
<markasoftware>
What you just described is what ccl does
<beach>
I see.
<beach>
But I bet you it doesn't do that if you define your own method class.
<beach>
What CCL does in this case would be a very normal optimization for the case when only specified classes are involved, because it is way faster that passing a list of arguments and a list of next methods.
anticrisis has quit [Read error: Connection reset by peer]
<markasoftware>
I believe ccl does this for custom classes, which is how i discovered this in fact. There's some fancy magic (their word, not mine) that goes into call next method I'm still trying to figure out
scoofy has quit [Ping timeout: 265 seconds]
<Nilby>
The CCL MOP maybe a little messy but it ran on a 68k Mac with 1mb memory.
<markasoftware>
They admit their generic functions don't really work with amop
<beach>
I haven't studied what CCL does, so it is entirely possible that the violate specified behavior even when they are not supposed to.
<beach>
s/the/they/
<markasoftware>
Is it your understanding that a mop compliant implementation's method functions, for a custom method class, would always have to take a list of arguments, then a list of next methods
<markasoftware>
?
scoofy has joined #lisp
<beach>
Yes, I think so.
<beach>
Er, wait...
<markasoftware>
Thats my main concern, since I'm writing code that relies on this property, and while I'm OK with implementation specific exceptions I want to get my "default" code right
mindCrime has quit [Excess Flood]
<beach>
It is probably possible for client code to customize make-method-lambda, compute-effective-method, call-method, make-method, etc. to do something else
<beach>
Maybe it fixes this problem.
shka_ has joined #lisp
pankajsg has joined #lisp
zolferino has joined #lisp
zolferino has quit [Excess Flood]
bitmapper has quit [Quit: Connection closed for inactivity]
zolferino has joined #lisp
zolferino has quit [Excess Flood]
varjagg has joined #lisp
varjagg has quit [Remote host closed the connection]
zolferino has joined #lisp
zolferino has quit [Excess Flood]
zolferino has joined #lisp
iskander has quit [Quit: bye]
zolferino has quit [Excess Flood]
egp_ has joined #lisp
egp__ has joined #lisp
hendursa1 has joined #lisp
ljavorsk has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
iskander has joined #lisp
cage_ has joined #lisp
heisig has joined #lisp
zolferino has joined #lisp
zolferino has quit [Excess Flood]
zolferino has joined #lisp
zolferino has quit [Excess Flood]
zaquest has quit [Quit: Leaving]
zolferino has joined #lisp
zaquest has joined #lisp
orivej has joined #lisp
catt has joined #lisp
rgherdt has joined #lisp
Inline has quit [Quit: Leaving]
Inline has joined #lisp
carkh has quit [Read error: Connection reset by peer]
varjagg has joined #lisp
rogersm has joined #lisp
jonatack has joined #lisp
luni has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
<jackdaniel>
it does fix some problems with ccl, but at a cost of shadowing operators
toorevitimirp has joined #lisp
<jackdaniel>
i.e a casual standard-generic-function is not recognized by some closer-mop methods (because it provides its own defgeneric version - on ccl)
hiroaki_ has joined #lisp
skapata has joined #lisp
surabax has joined #lisp
<alanz>
I have a general question. I.n. e.g pharo smalltalk, you can load source from well-defined git repos etc via metacello. You can then work on the live image, changing whatever, and then do a diff for the modified in-image source vs the original, and possibly commit it back. Is that kind of workflow possible in common-lisp?
<alanz>
i.e. capture that changes from a live image and the files it was loaded from?
aartaka has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
<beach>
Certainly not using only the standard. An implementation could provide something like that, but I know of no implementation that does.
<alanz>
Thanks, I was pretty sure that was the case, just checking I was not missing something. FWIW, that experience is pretty good, in pharo
* alanz
loves the fact that anything is in principle *possible*
<Nilby>
I do in-image editing and have an in image git tool, but I like to save my work to permanent storage frequently. CL editors can do that, but we tend to like the emacs style of editing. I've tried the pharo style, but I'm not so fond of it.
<alanz>
Nilby, how do you keep things in sync? I find myself killing and restarting the lisp image frequently, to make sure I have everything lined up. Particularly when messing with package definitions, which affect scope
<alanz>
(I'm still learning what these things do, so mess it up often)
iskander has quit [Quit: bye]
<Nilby>
I usualy edit on the function or class level, so when I'm satisfied with the function I send it back to the file buffer which I can then git diff.
<beach>
alanz: Current Common Lisp implementations are easy to make inoperable. That fact discourages in-image manipulations.
<alanz>
"edit on the function or class level": In the REPL?
<alanz>
beach, so what is a normal workflow? restart the image often?
<beach>
I suspect that's what most people do.
<alanz>
ok, so I am not missing something then :)
<beach>
The plan for SICL is to use multiple first-class global environments so that if you mess up the current one, you will get a default one that works. And the plan is also to keep the source text associated with every definition, which would make your workflow possible.
<Nilby>
I don't restart much. But I use multiple images when I might do something that introduces bugs to the editor/repl. And it's true most modern lisps are easier to crash.
<Nilby>
But it's true I sometimes find order of definition/loading bugs I didn't notice when just editing functions/packages.
<Nilby>
I'll be glad to have first-class global environments again.
<beach>
One mistake I often make is to introduce some circular dependency. While working interactively, the dependencies exist, so the problem does not manifest itself.
iskander has joined #lisp
<alanz>
modern lisps are easier to crash: is this because they have drifted away from being first-class, do everything in them environments?
<alanz>
And what makes you think we will have first-class global environments again?
* alanz
just trying to understand the ecosystem
<Nilby>
Old LispOSs took a long time to boot. Also they had an (vague) idea of separate users/sessions.
<Nilby>
On on old lisps fully restarting the image was basically rebooting
<beach>
alanz: I guess Interlisp was more like Smalltalk. But Common Lisp is mainly derived from Maclisp.
<Nilby>
my memory is fuzzy on the specifics, but basically you could log-out to reset your environment
<moon-child>
fwiw work has been ongoing to revive interlisp
<beach>
alanz: We will have first-class global environments in SICL because I already implemented them.
<alanz>
Wikipedia interlisp: First appeared1968; 53 years ago. Respect.
<alanz>
so there was motivation to avoid that, so the effort was put in for hot code reload etc
<Nilby>
Yes. They have the old Interlisp environment working fairly well. The only problem I saw was that it doesn't know how to idle the processor.
<alanz>
beach, SICL is the common-lisp IDE?
<beach>
minion: Please tell alanz about SICL.
<minion>
alanz: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<alanz>
:+1:
<moon-child>
Nilby: iirc some of the machinery for idling was there, used for idle animations or screensavers I think?, so not a completely insurmountable task to restore
<Nilby>
I'm sure it's just a tweak to the VM
<Nilby>
But I didn't try since I'm pretty invested in CL
<alanz>
beach, what is the one-line motivation for SICL?
<moon-child>
as I recall, interlisp supports cl and 1 or 2 other lisps
<alanz>
apart from: it sucks, time to do it over
<beach>
alanz: Create a Common Lisp implementation that is adapted to modern processors, that uses CLOS a lot more than existing implementations, and that is way simpler to maintain.
<alanz>
:+1:
<Nilby>
Hmmm. Maybe I should try to port to it. Then I will have to figure out how to get it to not eat the full cpu.
<alanz>
how does it relate to the standard? will it do all of it, or leave parts out? eg that whole filepath back-compatibility wart?
<beach>
alanz: I was convinced that maintainers of existing Common Lisp implementations would not accept the fairly radical modifications that I wanted to see.
<beach>
alanz: SICL? It will follow the standard.
<alanz>
makes sense. Hard to move things when there is so much history behind it
<beach>
Yes, and my estimate was that it would be just as hard, perhaps harder, to transform an existing implementation, as creating a new one.
<Nilby>
moon-child: Awesome. Thanks!
vegansbane6963 has joined #lisp
kamen has joined #lisp
<Nilby>
If you read the code of most CL implementations, it's not hard to get the sense that they could really use a clean slate approach.
iskander has quit [Quit: bye]
<beach>
Indeed.
<alanz>
trouble with that is there is always so much baked-in hard-won knowledge in the old ones, that make them reliable
<alanz>
or at leaast predictable, or "known"
<Nilby>
The interesting thing about CL, is parts of an implementation would useful to many type of progams as separate customizable/subclassable module.
random-nick has joined #lisp
iskander has joined #lisp
<beach>
That's why I try to extract many SICL modules as separate repositories.
<beach>
We already have Clostrum (first-class global environment) Trucler (lexical compile-time environments), Incless (printer), Eclector (reader), etc.
<beach>
Oh, and Cleavir (compiler framework) of course.
<Nilby>
I'm already using Eclector, and I imagine I'll end up having to use some of those other pieces too. It's awesome that they can already work on top of other implementations.
cartwright has quit [Remote host closed the connection]
<beach>
Well, they had to from the start, because I am using them to bootstrap SICL on an existing host Common Lisp implementation.
<alanz>
sounds good
cartwright has joined #lisp
<beach>
Also, that means I can often persuade someone else to be the maintainer. :)
<Nilby>
A good deal all around
terpri_ has quit [Remote host closed the connection]
terpri_ has joined #lisp
iskander has quit [Quit: bye]
iskander has joined #lisp
rogersm has quit [Read error: Connection reset by peer]
luni has quit [Quit: Connection closed]
terpri_ is now known as terpri
_whitelogger has joined #lisp
ggoes has quit [Ping timeout: 256 seconds]
niac has joined #lisp
<semz>
Is there a trick to easily reading nested backquotes or do you just have to be very careful and strict about the various contexts you're working in?
pankajsg has quit [Ping timeout: 264 seconds]
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
<_death>
there are "pattern matching" hints in cltl2 backquote appendix
niac has quit [Ping timeout: 260 seconds]
<semz>
Thanks, that looks exactly like what I was looking for.
Sheilong has joined #lisp
hiroaki_ has quit [Ping timeout: 246 seconds]
nicktick has joined #lisp
<pyc>
What does UIOP stand for?
<beach>
Nothing. Just consecutive keys on a US keyboard.
<beach>
Just like ASDF.
<_death>
unother iystem oefinition pacility
<beach>
:)
<contrapunctus>
pyc: Utilities for Implementation and OS Portability IIRC
<beach>
pyc: We can figure one out if you are not happy with that answer.
<beach>
Like that, yes.
<contrapunctus>
Oh sorry I ruined it ^^'
<Xach>
U and I Overcoming Problems [With Lisp]
<contrapunctus>
rofl Xach
<susam>
I always wonder why ASDF does not stand for ASDF System Definition Facility.
<Nilby>
Is there some design decision why slime/sly subprocess output is not delivered to the repl buffer?
<pyc>
how stable is uiop? has it ever broken backward compatibility so far?
<Xach>
pyc: what prompts the question?
<pyc>
Xach: I am making my script depend on uiop functions rather than CLHS functions. I decided this after I realized that (directory "vid/*") lists all files in CLisp but not in SBCL. What the wildcard characters mean seem to differ greatly from implementation to implementation.
<pyc>
Xach: I realized I can't write even the most basic file I/O operation in a portable manner without writing a compatibility layer. UIOP seems like that compatibility layer.
<Xach>
pyc: it is a compatibility layer, yes
<pyc>
Xach: now the reason I chose CL was because I want my script to run without issues and without maintenance even 20 years into the future. That is why I want to know how stable UIOP is.
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
<pyc>
do you people write your script in portable manner using uiop or do you write for a specific implementation like SBCL?
<beach>
I don't write scripts.
<pyc>
beach: what do you write and how do you write them?
<beach>
I just consider the REPL to be my shell.
<Xach>
pyc: i generally write scripts in a way that works as i expect in sbcl.
<pyc>
beach: do you write any programs that you save in files for the long term? if so, do you use something like uiop or do you target a specific implementation like SBCl?
<pyc>
Xach: so you are okay to rely on SBCL-specific behaviour that may not be portable?
bitmapper has joined #lisp
<beach>
pyc: Yes, my programs are in files, and I use ASDF to load them.
<pyc>
Xach: can you point me to some of your code, especially if you have something that manipulates files? I am hoping as a beginner I can learn from code written by experts.
<beach>
pyc: I try very hard to write programs that don't use any implementation-specific features.
<Xach>
pyc: for getting wildcard entries, i don't mind using sbcl. that is a very tiny part of the programs that i write.
<pyc>
beach: so for something like list all the files in a directory recursively, you are likely to use UIOP instead of CLHS?
renzhi has joined #lisp
<pyc>
Xach: understood. thanks!
<pyc>
I think uiop has obvious benefits of portability. Are there any disadvantages of calling uiop functions in my code that I need to be aware of?
<_death>
pyc: I think there is a chance for uiop code to work in 20 years (maybe even the same uiop version, on sbcl ;).. but I dislike its interfaces
<Xach>
pyc: uiop includes a lot of things in it. if you are only concerned about one small piece like wildcards it may be prudent to extract it instead of taking all of uiop.
<pyc>
_death: what do you prefer then? hand-write what you need? another alternative to uiop?
eoyath has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
<beach>
pyc: I might use ASDF or UIOP occasionally.
eoyath has quit [Client Quit]
<pyc>
Xach: that makes sense. thanks for the advice.
<Xach>
pyc: it can also help if you make things that you need and like and don't worry about portability. if people want to use it, let them worry about it if they have a different environment. (this is just an option, not a requirement.)
<Xach>
pyc: i think sometimes the means of distribution and widespread use becomes a roadblock to even getting started.
<Xach>
that is, overthinking it.
<Xach>
"if i can't give my friend a 500KB executable that has a gui and runs on all OSs why even bother using lisp" is a little extreme but less extreme but similar sentiments have been expressed
aeth has joined #lisp
<pyc>
Xach: you are right. I guess I am overthinking it. I wish I started learning CL when I was much younger. I didn't worry about these kind of things when I was younger. Now I waste a lot of time in analysis paralysis.
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
<Xach>
pyc: I don't think portability is a bad thing, but it is not a simple story in CL, and you can actually ignore it for quite a while when learning and growing.
<Xach>
I wish it was simpler but its complexity need not be an initial roadblock (for many tasks)
Kingsy has quit [*.net *.split]
Kingsy has joined #lisp
eoyath has joined #lisp
<Nilby>
pyc: I just did a survey of some of my lisp scripts from 20 years ago. BTW uiop didn't exist 20 yrs ago. Everything that still works, works because they don't depend on external conditions. But for most useful things, the external conditions have changed enough that they don't run.
hendursaga has quit [Remote host closed the connection]
<_death>
pyc: I find myself still using cl-fad to walk directories.. because then I don't need to first gather all names into a list
hendursaga has joined #lisp
<susam>
I agree with Xach. If I could mangle a famous quote, I would say: Make it work. Then make it beautiful. Then if you really have to, make it portable."
<susam>
The programs you write for yourself should first solve your own problems. Only then it may solve others' problems.
carkh has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 276 seconds]
X-Scale` is now known as X-Scale
niac has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
ljavorsk has quit [Ping timeout: 245 seconds]
pankajsg has joined #lisp
kam1 has quit [Ping timeout: 264 seconds]
ggoes has joined #lisp
niac has quit [Ping timeout: 245 seconds]
niac has joined #lisp
sxmx has quit [Quit: WeeChat 3.0.1]
iskander has quit [Quit: bye]
kaiwulf has joined #lisp
iskander has joined #lisp
Josh_2 has joined #lisp
Nilby has quit [Ping timeout: 264 seconds]
sxmx has joined #lisp
<Josh_2>
Afternoon
iskander has quit [Quit: bye]
<Josh_2>
Is CFFI's foreign-string-to-list equivalent to pythons bytes_to_native_str(ffi.unpack ... ?
hiroaki_ has joined #lisp
<Josh_2>
I've been stuck for the past few days on a single function, I'll be happy to see the behind of this project
<Josh_2>
Well seems I solved that issue
<Josh_2>
:D
<Josh_2>
Well darn I finally figured it out
kam1 has joined #lisp
kevingal has joined #lisp
attila_lendvai has joined #lisp
puchacz has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
iskander has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Broken pipe"]
contrapunctus has joined #lisp
nicktick has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<Josh_2>
What is no-applicable-method-error (SBCL) a subclass of? I'm trying to handle a missing method error
contrapunctus has joined #lisp
<Josh_2>
Obviously I could just use condition or error but then if there is another type of condition then the test would still pass
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
hiroaki_ has quit [Ping timeout: 272 seconds]
<heisig>
Josh_2: Have a look at (sb-mop:class-precedence-list (find-class 'sb-pcl::no-applicable-method-error)).
<Josh_2>
Thanks
spxy has joined #lisp
niac has quit [Ping timeout: 264 seconds]
drbluefall has quit [Ping timeout: 276 seconds]
<phoe>
Josh_2: do you control the generic function?
<phoe>
if yes, maybe you instead want to add a method to NO-APPLICABLE-METHOD?
kevingal_ has joined #lisp
thmprover has joined #lisp
luni has joined #lisp
long4mud has quit [Read error: Connection reset by peer]
delezos has joined #lisp
domovod has quit [Quit: WeeChat 3.0]
jprajzne has quit [Remote host closed the connection]
jprajzne has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
hiroaki_ has joined #lisp
orivej has joined #lisp
delezos has quit [Quit: ERC (IRC client for Emacs 26.1)]
seok has quit [Quit: Connection closed]
aeth has quit [Ping timeout: 260 seconds]
waleee-cl has joined #lisp
aeth has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
holycow has joined #lisp
rogersm has joined #lisp
mindCrime has joined #lisp
Codaraxis has quit [Ping timeout: 276 seconds]
Codaraxis has joined #lisp
heisig has quit [Quit: Leaving]
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
attila_lendvai has quit [Ping timeout: 272 seconds]
iskander has quit [Quit: bye]
kaiwulf has quit [Ping timeout: 276 seconds]
pankajsg has quit [Ping timeout: 260 seconds]
iskander has joined #lisp
zooey has quit [Ping timeout: 268 seconds]
zooey has joined #lisp
<holycow>
hi.
<holycow>
noob question. so i am able to parse text files, chop up the input in interesting wasy now and stuff that into alists and plists and then get the data out sorted in various ways.
<Xach>
holycow: that's not a question!!
<holycow>
well, it's a predicate to a q
<holycow>
suppose i wanted to write a function that (using keystrokes) allows me to itarate up or down the list and 'pop' entries from the top of a pllist/alist and push it to the bottom or something like that
<holycow>
i've looked at loop and iterate and i thiiiink i kinda get some ways to think about that.
<holycow>
what might i want to look at as a concept and google to be able to do something like that? i'm not searching up anything obvious, everyone seems to iterate over a whole list and be done with it.
<Xach>
holycow: like keystrokes without hitting enter?
<holycow>
*nod* arrow keys
<Xach>
holycow: that's a good q, i haven't done something like that. i've always thought of making an emacs UI a la sldb or the inspector for that.
<fiddlerwoaroof>
holycow: basically you can choose between either implementing the terminal-control bits yourself, or use something like linedit/readline/etc.
<fiddlerwoaroof>
or curses
mh__ has joined #lisp
<holycow>
OH!
<fiddlerwoaroof>
for the key-handling
<fiddlerwoaroof>
You probably also need a "cursor" structure that maintains the current element of the list and the directions you can go from there.
<holycow>
ok, i knew i was completely not thinking about this right. that looks right.
<fiddlerwoaroof>
The annoying thing is that "raw" keyboard input is really crufty in terminals
choegusung has joined #lisp
<fiddlerwoaroof>
For navigation you might look into zippers
<holycow>
never heard of that before, huh
<holycow>
okay, lots to google. off i go. thanks for the directional tips
<fiddlerwoaroof>
It's basically a functional way to implement a navigable data structure
luni has quit [Quit: Connection closed]
terpri has quit [Remote host closed the connection]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
iskander has joined #lisp
kenran has joined #lisp
cage_ has quit [Quit: Leaving]
jonatack_ has quit [Read error: Connection reset by peer]
<holycow>
_death: oh very interesting. thank you kindly! added to notes/todo
ane has quit [Ping timeout: 246 seconds]
kenran has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
kenran has joined #lisp
phantomics has quit [Remote host closed the connection]
<_death>
well, gtg now.. but I updated it with move up/down commands
Petit_Dejeuner has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
<Petit_Dejeuner>
Hi, I'm trying to write a function that runs a server in another thread (bordeaux-threads). The server is blocking on accept (usocket). Is there any way for me to kill the thread while it's blocking on accept or make accept timeout? I'm using destroy-thread (bordeaux-threads) right now, but I wanted a less abrupt way to kill the server thread.
<Petit_Dejeuner>
The gist of what I've been trying: (loop while *server-is-alive do (let ((client-connection (usocket:accept server-socket))) ...))
shka_ has quit [Ping timeout: 240 seconds]
<Josh_2>
if you want a nicer way of stopping the thread you could use catch and then use interrupt-thread to get the thread to throw
<Josh_2>
You can also use (listen ..) to see if your socket will block
<Josh_2>
phoe: I didn't know you could do that, do you have an example?
Oladon has joined #lisp
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
nij has joined #lisp
<nij>
morning lispers :-D I wonder what you use for user selection?
<nij>
In elisp, there's ivy already, which lets the user select things with much flexibility.
IPmonger has joined #lisp
<nij>
.. and, if ivy/helm is really the way to go. Is there an easy way to call them within a drop-down frame from common lisp?
puchacz has quit [Quit: Connection closed]
terpri has quit [Remote host closed the connection]
<Josh_2>
phoe: dw I found one on stackoverflow
<Josh_2>
nij: I don't understand what you mean
akoana has joined #lisp
<nij>
Josh_2: you've used ivy or helm before?
<nij>
Or dmenu?
Sheilong has quit []
<phoe>
Josh_2: a tl;dr should be (defmethod no-applicable-method ((gf (eql #'my-gf))) &rest args) ...)
carkh has quit [Remote host closed the connection]
carkh has joined #lisp
carkh is now known as carkh_
carkh_ is now known as Carkh
<Petit_Dejeuner>
thanks josh, I was able to get it by looking closer at the bordeaux library, but instead of interrupt I ended up using the with-timeout macro. starting and stopping is very snappy now :)
jonatack has joined #lisp
leo_song has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
anticrisis has joined #lisp
luni has joined #lisp
leo_song has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
xlei has quit [Ping timeout: 256 seconds]
ljavorsk has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
asarch has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
mindCrime has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
_whitelogger has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
kenran has quit [Quit: leaving]
mindCrime has joined #lisp
Oladon has quit [Quit: Leaving.]
catt has quit [Ping timeout: 260 seconds]
terpri has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
vegansbane6963 has quit [Ping timeout: 245 seconds]
luni has quit [Quit: Connection closed]
xlei has joined #lisp
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
vegansbane6963 has joined #lisp
<Xach>
Merry distmas!
keja_ has joined #lisp
<Carkh>
what's a distmas ?
<Carkh>
oh
<Carkh>
quicklisp !
<Carkh>
merry distmas =)
attila_lendvai has quit [Ping timeout: 245 seconds]
attila_lendvai has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
pve has quit [Quit: leaving]
orivej has joined #lisp
attila_lendvai_ has joined #lisp
attila_lendvai has quit [Ping timeout: 260 seconds]
<edgar-rft>
distmas is the second-holy day right after indeterministmess
attila_lendvai has joined #lisp
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai_ has quit [Ping timeout: 272 seconds]
kamen has quit [Remote host closed the connection]
lowryder has quit [Ping timeout: 260 seconds]
lowryder has joined #lisp
mh__ has quit []
surabax has quit [Quit: Leaving]
karlosz has quit [Quit: karlosz]
hiroaki_ has quit [Ping timeout: 272 seconds]
varjagg has quit [Ping timeout: 265 seconds]
kam1 has quit [Ping timeout: 240 seconds]
arpunk has joined #lisp
iamFIREc1 has joined #lisp
iamFIREcracker has quit [Ping timeout: 260 seconds]