<DrDuck>
it's just this propagator stuff absolutely requires amb
<Bike>
okay, so did you try screamer?
<DrDuck>
not yet
<Bike>
but you're still focused on continuations?
<DrDuck>
well amb yes
<LdBeth>
A subset of continuation can be implemented without sacrificing efficiency
<Bike>
No, continuations. You are asking about continuations, not amb.
<Bike>
You got an answer for amb but haven't done anything with it.
<aeth>
drmeister: thanks!
<Bike>
LdBeth: sure. lisp has escape continuations, even
red-dot has joined #lisp
<Bike>
continuations are pretty intrinsic to the entire evaluation semantics. You can't just add them on after the fact.
learning has quit [Remote host closed the connection]
<aeth>
DrDuck: As far as continuations go, you basically spend a ton of work implementing them in an otherwise simple implementation process... and then you spend work essentially removing them where they're not actually necessary, for added performance.
chipolux has quit [Ping timeout: 244 seconds]
<Bike>
i mean, it doesn't have to be catastrophic. but it's not easy
<LdBeth>
Unless you’d expect something like write a interpreter then get a good quality compiler from it
<Bike>
and you can do a "zero cost" thing in that it only takes extra time when you use the continuation functions
chipolux has joined #lisp
<DrDuck>
is amb a small subset of continuations?
alexanderbarbosa has quit [Remote host closed the connection]
saravia has joined #lisp
<DrDuck>
also i don't see the keyword amb in screamer code at all, and it looks to be just for constraint solving
<DrDuck>
i am a bit confused
<LdBeth>
It’s control flow, so it’s sort close to continuation
<Bike>
I don't think you understand what amb is.
<Bike>
So I'd rectify that first off.
<DrDuck>
i thought amb would take a piece of code for evaluation for later
<Bike>
You don't understand amb.
<Bike>
You should read SICP. It's good.
<LdBeth>
But it’s not necessarily continuation
<Bike>
and free online.
<LdBeth>
“Free online books”
<DrDuck>
:(
<Bike>
It's fine to not understand things. That's the first step to understanding them, after all
semz has quit [Ping timeout: 264 seconds]
<LdBeth>
I think a good way to learn about a thing is write it once, even when you think you already know how to write it
<stylewarning>
Has anybody written some kind of memory/object pool that tracks allocation sizes?
<LdBeth>
stylewarning: it’s that for garage collection?
Guest92857 has joined #lisp
liberiga has quit [Ping timeout: 260 seconds]
semz has joined #lisp
Guest92857 has quit [Ping timeout: 272 seconds]
learning has joined #lisp
wigust has joined #lisp
wigust- has quit [Ping timeout: 248 seconds]
shifty has joined #lisp
techquila has joined #lisp
mindthelion has quit [Ping timeout: 244 seconds]
chipolux has quit [Quit: chipolux]
fengshaun has joined #lisp
red-dot has quit [Remote host closed the connection]
red-dot has joined #lisp
akoana has joined #lisp
<stylewarning>
LdBeth: No, to avoid allocating many object MB in size
Insanity_ has quit [Quit: Connection closed for inactivity]
shwouchk has quit [Quit: Connection closed for inactivity]
semz has quit [Ping timeout: 264 seconds]
learning has quit [Remote host closed the connection]
oni-on-ion has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
akoana has left #lisp [#lisp]
Kundry_Wag has quit [Ping timeout: 248 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
zaquest has quit [Remote host closed the connection]
saravia has quit [Remote host closed the connection]
libertyprime has joined #lisp
alexanderbarbosa has joined #lisp
madand has joined #lisp
alexanderbarbosa has quit [Ping timeout: 252 seconds]
madand has quit [Remote host closed the connection]
zaquest has joined #lisp
<beach>
Good morning everyone!
Bike has quit [Quit: Lost terminal]
awolven has quit [Ping timeout: 244 seconds]
oni-on-ion has joined #lisp
xrash has joined #lisp
nanoz has joined #lisp
libertyprime has quit [Ping timeout: 245 seconds]
libertyprime has joined #lisp
EvW has quit [Ping timeout: 264 seconds]
zaquest has quit [Ping timeout: 245 seconds]
zaquest has joined #lisp
froggey has quit [Ping timeout: 272 seconds]
froggey has joined #lisp
anewuser has joined #lisp
gravicappa has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
vlatkoB has joined #lisp
<bmansurov>
aeth: ok, thanks
<bmansurov>
o/ everyone. How can I pass clauses to restart-case from a list? Here's what I'm trying to do:
<bmansurov>
(defun my-restarter ()
<bmansurov>
(let ((list '(1 2 3)))
<bmansurov>
(restart-case (error "some error")
<bmansurov>
(skip () nil)
<bmansurov>
;; Here I want to list options from list
keep_learning has quit [Quit: Ping timeout (120 seconds)]
sonologico has quit [Remote host closed the connection]
ggole has joined #lisp
<beach>
bmansurov: I think you would need some trickery for that, like nesting the restart-case forms.
<beach>
bmansurov: Also, where do the option-i symbols come from?
<bmansurov>
beach: I see. option-i is just name, similar to skip.
<beach>
Yes, but since the list has a variable number of elements, there must also be a variable number of options I suppose.
<beach>
So how do you know the names of those options?>
<bmansurov>
beach: I don't. I want to generate them on the fly as well.
hasebastian has joined #lisp
<beach>
That will be tricky since they are not evaluated by restart-case.
<bmansurov>
beach: OK, thanks
<beach>
You would have to do all this at compile time, rather than at run time, meaning you need to do it with macros.
yoeljacobsen has joined #lisp
<bmansurov>
I see.
<beach>
... which would seem reasonable anyway, because the code that invokes the restarts would have to know their names.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<beach>
What is the purpose of this code anyway?
<beach>
Are you sure you need such a complex mechanism?
<beach>
Perhaps something simpler like catch/throw will do?
<bmansurov>
beach: I am parsing a list of words and checking whether each word is in the dictionary. If not, I'm calculating the most similar words from the dictionary and want the user to select one.
<beach>
I see.
<bmansurov>
beach: would the code be simpler if I restricted the list of suggestions to at most 3?
<beach>
Yes, then you can enumerate all cases.
<bmansurov>
beach: something like (use-value (value) value)?
<beach>
Sorry, I need to go. I'll be back in a few hours.
<bmansurov>
beach: ok thanks
ltriant has quit [Quit: leaving]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
xrash has quit [Ping timeout: 268 seconds]
lalitmee has joined #lisp
ahungry has joined #lisp
abhixec has joined #lisp
lalitmee has quit [Quit: Leaving]
lalitmee has joined #lisp
stepnem has quit [Ping timeout: 245 seconds]
frgo has joined #lisp
lalitmee has quit [Quit: Leaving]
nanoz has joined #lisp
lalitmee has joined #lisp
JohnMS_WORK has joined #lisp
lalitmee has quit [Remote host closed the connection]
lalitmee has joined #lisp
ahungry has quit [Remote host closed the connection]
manualcrank has quit [Quit: WeeChat 1.9.1]
yoeljacobsen has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
scymtym has quit [Ping timeout: 245 seconds]
yoeljacobsen has joined #lisp
<DrDuck>
why does my interpreter error out when using symbol-value on a function i defined
<DrDuck>
(defun foo (x) (+ x 2))
<DrDuck>
(symbol-value 'foo)
<DrDuck>
errors and goes to debugger in slime
<no-defun-allowed>
(symbol-function 'foo)
<no-defun-allowed>
In Common Lisp (and Lisps preceding it), functions and variables have seperate namespaces.
<DrDuck>
agg
varjag has joined #lisp
yoeljacobsen has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
I can't think of any languages that do that other than CL, but it has some uses, like (defun foo (list) (list (mapcar #'single-foo list)))
vhost- has quit [Ping timeout: 245 seconds]
vyorkin has joined #lisp
hasebastian has quit [Remote host closed the connection]
SaganMan has joined #lisp
lalitmee has quit [Ping timeout: 246 seconds]
red-dot has joined #lisp
ravenous_ has joined #lisp
<DrDuck>
or something like that
<DrDuck>
parenedit?
<DrDuck>
ahh what was the other plugin i need with slime
ravenous_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<DrDuck>
parenmatch?
khisanth_ has quit [Ping timeout: 268 seconds]
<no-defun-allowed>
paredit?
<DrDuck>
yeah
lmln has joined #lisp
scymtym has joined #lisp
dddddd has quit [Remote host closed the connection]
anewuser has quit [Ping timeout: 245 seconds]
khisanth_ has joined #lisp
longshi has joined #lisp
aautcsh has quit [Ping timeout: 252 seconds]
SaganMan has quit [Ping timeout: 245 seconds]
igemnace has quit [Quit: WeeChat 2.5]
Nistur has joined #lisp
yoeljacobsen has joined #lisp
lalitmee has joined #lisp
vyorkin has quit [Ping timeout: 244 seconds]
vhost- has joined #lisp
vhost- has quit [Changing host]
vhost- has joined #lisp
lalitmee has quit [Ping timeout: 258 seconds]
lalitmee has joined #lisp
SaganMan has joined #lisp
manualcrank has joined #lisp
<Nistur>
greetings lispers :)
lalitmee has quit [Remote host closed the connection]
lalitmee has joined #lisp
rople has joined #lisp
rople has quit [Client Quit]
<stylewarning>
Hello hello
lalitmee has quit [Ping timeout: 245 seconds]
lalitmee has joined #lisp
<no-defun-allowed>
How do you do, fellow lispers?
m00natic has joined #lisp
<beach>
Nistur: Are you new here? I don't recognize your nick.
<Nistur>
I am :)
<beach>
Great! What brings you to #lisp?
<Nistur>
beach: give me a second, I'm actually writing a reddit post about this right now, so rather than me type it twice, I'll just link it, if that's ok :P
<beach>
Fine with me.
emma has joined #lisp
frgo_ has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
frgo_ has quit [Remote host closed the connection]
<stylewarning>
Nistur: Huh. It’s tough to give advice with this one.
<beach>
Nistur: This channel is dedicated to Common Lisp. But there is also a channel specifically for Lisp game development.
<beach>
#lispgames maybe?
<ck_>
Yeah I got as far as "Clojure inspired Lisp interpreter" before blinking
<no-defun-allowed>
Looking at the bullet points: - CCL and SBCL go straight to machine code, ECL to C and Clasp to LLVM IR, - Haven't used any game toolchains before, but if it's all C then I don't C why CFFI wouldn't work. - Common Lisp is Common Lisp regardless of implementation, and I think the size of it is often overstated - CFFI, as forementioned, does C interfacing - SWANK is good, but I imagine you'll get in hot water trying to
<no-defun-allowed>
publish a game with it nearby.
<no-defun-allowed>
ck_: MAL is a hell of a drug.
<stylewarning>
Nistur: it seems you simultaneously want to learn something about Lisp, while making some kind of Lisp, while making some kind of GOAL-like game engine. Is that right?
<no-defun-allowed>
Seriously though, I can't reccomend any free Lisp-interpreter-writing resources other than SICP since they jump around too much and have too many false premises.
Kundry_Wag has joined #lisp
<no-defun-allowed>
Probably because that book describes the semantics of the target language before it is implemented, so the authors have no excuse to, say, start with "well, if you have a list, then evaluate the arguments, then if the function is +, add them together, if it is *, take the product, ....." then go "actually, we'll use an alist/hash-table/something to make an assosciation between symbols and primops", then they finally
<no-defun-allowed>
spit out a reasonable environment model and the reader has had to wade through two bad ones, wasting time.
<no-defun-allowed>
Seems to happen a lot, and it drives me mad, but the target language is never CL (and rarely is the implementation language CL), so I'll shut it.
Kundry_Wag has quit [Ping timeout: 272 seconds]
<no-defun-allowed>
Though, perhaps the problem there is they try to teach (some absurd mutation of) Lisp and how to write an interpreter or compiler for it at the same time.
<beach>
no-defun-allowed: Did you really mean SICP?
<no-defun-allowed>
beach: Yes, I meant SICP.
<no-defun-allowed>
The semantics of the language are described in chapters 1 through 3, then chapter 4 presents an interpreter and chapter 5 presents a compiler.
<beach>
I see.
<beach>
I read the book a long time ago, and I forgot its structure.
<stylewarning>
did you at least remember its interpretation?
* beach
sees it on the shelf behind next to him.
<no-defun-allowed>
Those first three chapters do have those false starts/simplifications, but I think it is excusable because they are not being made while the reader should be writing a compiler or interpreter instead.
<beach>
s/behind//
oni-on-ion has quit [Remote host closed the connection]
<Nistur>
beach: I've joined #lispgames too :P But I'm considering CL as an option still (I mentioned it later) so I thought I'd join here
oni-on-ion has joined #lisp
<ck_>
stylewarning: maybe if he applies himself more .. or evaluates the statement?
* no-defun-allowed
pulls out her 80s toy keyboard and starts playing Jesu, Joy Of Man's Desiring
* ck_
points at the notes using a light-pen-controlled giant arrow.
<beach>
Nistur: It looks like stylewarning is telling you that you may be in for some adventure if you are trying to do all those things at once.
<Nistur>
stylewarning: I "know" lisp, as I've been using it for a while, but I am not comfortable using it, and I find it difficult to think in lisp, so it's more that I want to use it to do something substantial. I don't want to make a lisp specifically, but I _do_ want to make some kind of GOAL like thing, and I'm thinking, given how everything is very C-oriented in gamedev, having something I can more easily hack
<Nistur>
around in, and potentially write from scratch, would make negotiating console toolchains easier
<Nistur>
beach: I'm good with adventure :D
<no-defun-allowed>
Though, I'm not sure how different console OSes are to general purpose computer OSes, so it is possible you would also have to work with porting the Lisp system in mind.
<stylewarning>
There’s adventure and then there’s Adventure (TM) with all the bugs, gnats, upset digestive system, itchy eyes, and hunger
<ck_>
and grues(?)
<Nistur>
stylewarning: welcome to gamedev.
<no-defun-allowed>
Nistur: What do you consider fun?
<Nistur>
even when using "mature" game engines (we discovered last week that Unreal, when doing "AddUnique" to add a struct to a map, would only compare the first value in the struct and use that as an ID)
<stylewarning>
Nistur: how much time are you thinking about investing in such a project
<Nistur>
no-defun-allowed: I wrote an intel 8080 emulator, with debugger, for fun, and to learn how CPUs worked, and then hand assembled 8080 machine code to test it in a hex editor. This was a few years ago, and almost entirely during commutes on London underground... if that shows you what my idea of fun is :P
<no-defun-allowed>
Hey, I tried to do that once, gave up and emulated chip8 instead. I figure writing a game engine that runs on a proprietary environment is likely harder, depending on what you want out of it though.
<Nistur>
stylewarning: um, I have no deadline for this. If it moves forwards, or I learn things, then I'm good indefinitely in theory. I'd like to have _some_ lisp code running as a proof of concept in a couple of days.
<stylewarning>
Nistur: do cross-platform GUI toolkits interest you?
frgo_ has quit [Remote host closed the connection]
<Nistur>
and, in my Curriculum Vitae project, I decided it would be fun to add an incredibly minimal lisp interpreter https://github.com/nistur/cv/blob/master/src/lisp.c (it is still very much WIP as I try to decide what to do with it, but I _think_ it's correct)
<stylewarning>
Because if you make something like an open source CAPI you will be praised for decades to come by the entirety of the Lisp world (http://www.lispworks.com/products/capi.html)
frgo has joined #lisp
frgo has quit [Read error: Connection reset by peer]
<Nistur>
no-defun-allowed: the point was, my idea of fun is doing awkward and often pointless programming things to see what happens :P
<Nistur>
stylewarning: um. Much as the idea of being praised is tempting... I have a pet hatred for GUI toolkits as they never ever do what I want and I end up rolling my own in every single project... but then again, I do gamedev, and game GUI is different than application GUI
<Nistur>
(my CV lisp doesn't have macros... yet. I am aware of this flaw)
<stylewarning>
Nistur: another useful project would be to make a C backend for SBCL. Allow SBCL to compile code to C.
<no-defun-allowed>
Your CV Lisp also doesn't have lexical scoping, garbage collection and I don't think you've written much Lisp either.
<no-defun-allowed>
Is `(set 'test lambda () ...)` not a typo?
<Nistur>
no-defun-allowed: correct, correct, correct. As I said, I've wanted to write more lisp, but never got around to doing much apart from some basic emacs configuration. That specific one was written purely to be able to run a few lines, and I was intending to add GC etc in if I actually found a use for it
frgo has joined #lisp
<stylewarning>
Nistur: I don’t like being discouraging but the kind of project you’re suggesting is an extremely tall order. If you want to write a little assembler and runtime in Lisp, maybe that’s reasonable, and you could live-patch assembly code in this runtime.
<stylewarning>
The runtime is the most difficult part. If you decide to implement a Lisp aside/atop this runtime you could, but you need to solve problems like garbage collection and hot-loading first, which don’t require the idea of Lisp yet
<no-defun-allowed>
Anyway, what I should tell you, Nistur, is that you have two things to do: to learn Lisp, then write a game engine. If you try to do both at the same time, your engine will look very weird to you in a short amount of time, and you'll be less efficient at learning Lisp.
<Nistur>
My projects have always been big-goal, but I try to start off with something small as a proof of concept. Most of the projects I learn from the PoC and move on, I'm hoping (especially as I'm able to do this at work) that something might come from it, and I'll be able to roll with it
<no-defun-allowed>
(Maybe that's my problem there, that most resources out there try to teach the target language and interpretation/compilation techniques (and occasionally the implementation language) at the same time, resulting in a hard-to-follow book.)
<stylewarning>
Nistur: another idea: hack on Mezzano
<stylewarning>
Nistur: port Mezzano to the PS4
<stylewarning>
You will know Common Lisp inside and out after that
<Nistur>
no-defun-allowed: I shall. But I think perhaps my... ambitions may have obfuscated my actual plan right now. The ambition is to be able to make a lisp engine... but the plan was to get a lisp environment (and I have no particular attachment with any one lisp or implementation). To make this a sort of viable thing for me to be doing in personal development time at work is to be able do something which is able
<Nistur>
to run on console... which is why I wanted to get that out of the way first. mal and clasp both compile to LLVM IR, so I figured if I can do that, and hack in something so I can change clear colour of the screen from lisp or something, then I would have validated the tech, and could then start "learning" more... I wasn't going to dive right in and write a game engine without a more thorough understanding of
<Nistur>
the language. One of the things I _do_ find fun is architecture, and I know I cannot do architecture without greater understanding of what I'm building with.
* beach
thinks it is best for him to stay out of this discussion.
<no-defun-allowed>
And what do console SDKs give you? My guess is something like an implementation of OpenGL or Vulkan, or something completely proprietary and detached from any other existing system.
<Nistur>
beach: can I join you? :P
<stylewarning>
If Donald Knuth was a lisp hacker, he’d be indistinguishable from beach
<Nistur>
usually GL-like API for graphics, then wrappers for account access, controller input, and a bunch more things
<ck_>
don't worry, we'll all be out of the discussion as soon as someone chimes in with the "this is not Common Lisp so it is off topic"
<no-defun-allowed>
ck_: Schrodinger's topic: this discussion is about CL and not about CL until someone observes it
* no-defun-allowed
cannot find the two-dots-above-o compose-key combination ):
<ck_>
": o"
<stylewarning>
ck_: please see Section 1.5.3 of the HyperSpec on Conforming Discussions
<ck_>
or " o, I'm not sure :( I miss ComposeKey on macOS
<no-defun-allowed>
Of course it's ". I was thinking : but sideways somehow.
<no-defun-allowed>
*Schrödinger's topic
<no-defun-allowed>
Nistur: just saying, you started the discussion
<ck_>
just type "oe" etc. next time you want to asciify an umlaut
<Nistur>
no-defun-allowed: ;)
<no-defun-allowed>
So you should have told yourself half an hour ago to stay out of the discussion.
<beach>
no-defun-allowed: Nistur is already aware of those apparently.
asdf_asdf_asdf has joined #lisp
<no-defun-allowed>
Oh, didn't catch that.
<ck_>
Someone recommended Chicken on the reddit post. Why not? Personally I've never gotten fluent in scheme though
<stylewarning>
ck_: Scheme is sort of like studying Latin. You never really get fluent in it. (:
<no-defun-allowed>
Chicken compiles to C and has a lot of libraries ("eggs") which could be handy, but CL has CFFI and a lot more libraries, though they aren't eggs ):
asdf_asdf_asdf has quit [Ping timeout: 244 seconds]
asdf_asdf_asdf has joined #lisp
<|3b|>
stylewarning: is there that much demand for a portable CAPI replacement?
igemnace has joined #lisp
<stylewarning>
|3b|: IME there’s been a great deal of demand for making it easy to write a reasonable GUI, esp from newcomers
<stylewarning>
And the answer is always “Qt, LTK, CLIM, or HTML/JS”
<|3b|>
yeah, i've see that too. haven't looked at CAPI enough to tell if it qualifies though :)
<|3b|>
doesn't seem bad from what i've read of docs in last few min though
<stylewarning>
CAPI is sufficiently Lispy but not over the top
<no-defun-allowed>
A CAPI clone would be very antiCLIMactic
<stylewarning>
It’s the only GUI tech I’ve had the patience to use and build Real Things with
<|3b|>
probably wouldn't be too hard to write something capi-like for glop2 (once glop2 exists sufficiently)
* |3b|
adds it to the todo list
<beach>
I think that, with the right documentation for McCLIM, we can make it much easier for newbies to use than what it currently is.
<ck_>
I've used the Allegro Common Graphics once. It felt a little weird.
<Nistur>
no-defun-allowed: I was joking. I'm actually happy I've had the discussion. I've learned some things :P
<Nistur>
I was looking at chicken at one point. I cannot recall off hand why I ruled it out
thijso has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
<beach>
Nistur: For your information, I am working on a compiler framework for Common Lisp (called Cleavir) that can be customized to work with different Common Lisp implementations. Clasp uses Cleavir for its main compile, and there is also a Cleavir-based compiler for CLISP, written by karlosz. And of course, Cleavir is the only compiler for the SICL implementation of Common Lisp, which is still not finished, of course. Perhaps if you want
<beach>
to implement a Lisp system, you could save some work if you base it on Cleavir.
<Nistur>
hmmm ok
longshi has quit [Quit: WeeChat 2.5]
<beach>
Then again, maybe not. Just saying.
eschulte has joined #lisp
stepnem has quit [*.net *.split]
lalitmee has quit [*.net *.split]
manualcrank has quit [*.net *.split]
eagleflo has quit [*.net *.split]
dyelar has quit [*.net *.split]
X-Scale has quit [*.net *.split]
cods has quit [*.net *.split]
cmatei has quit [*.net *.split]
wooden has quit [*.net *.split]
h11 has quit [*.net *.split]
sindan has quit [*.net *.split]
ck_ has quit [*.net *.split]
minion has quit [*.net *.split]
sammich has quit [*.net *.split]
drot has quit [*.net *.split]
vt240 has quit [*.net *.split]
Finnfinn has quit [*.net *.split]
ecraven has quit [*.net *.split]
shenghi has quit [*.net *.split]
Lord_Nightmare has quit [*.net *.split]
hiredman has quit [*.net *.split]
Patzy has quit [*.net *.split]
Aritheanie has quit [*.net *.split]
Ankhers has quit [*.net *.split]
sukaeto has quit [*.net *.split]
luis has quit [*.net *.split]
justinmcp_ has quit [*.net *.split]
baskethammer has quit [*.net *.split]
asdf_asdf_asdf has quit [*.net *.split]
nanoz has quit [*.net *.split]
elderK has quit [*.net *.split]
Adamclisi has quit [*.net *.split]
nullman has quit [*.net *.split]
hjudt has quit [*.net *.split]
notzmv has quit [*.net *.split]
kini has quit [*.net *.split]
funnel has quit [*.net *.split]
saturn2 has quit [*.net *.split]
remexre has quit [*.net *.split]
Ekho has quit [*.net *.split]
jgkamat has quit [*.net *.split]
a7f4 has quit [*.net *.split]
threefjord has quit [*.net *.split]
NickBusey has quit [*.net *.split]
Tordek has quit [*.net *.split]
datajerk has quit [*.net *.split]
dvdmuckle has quit [*.net *.split]
fouric has quit [*.net *.split]
Nikotiini has quit [*.net *.split]
mason has quit [*.net *.split]
mfiano has quit [*.net *.split]
cross has quit [*.net *.split]
jackdaniel has quit [*.net *.split]
hiredman has joined #lisp
wooden has joined #lisp
wooden has quit [Changing host]
wooden has joined #lisp
datajerk has joined #lisp
cods has joined #lisp
minion has joined #lisp
shenghi has joined #lisp
Tordek_ has joined #lisp
cmatei has joined #lisp
sammich has joined #lisp
sindan has joined #lisp
ecraven has joined #lisp
Patzy has joined #lisp
funnel_ has joined #lisp
dyelar has joined #lisp
baskethammer has joined #lisp
manualcrank has joined #lisp
funnel_ has quit [Changing host]
funnel_ has joined #lisp
funnel_ is now known as funnel
X-Scale has joined #lisp
sukaeto has joined #lisp
ccl-logbot has joined #lisp
vt240 has joined #lisp
nanoz has joined #lisp
Aritheanie has joined #lisp
nil has joined #lisp
NickBusey has joined #lisp
luis` has joined #lisp
asdf_asdf_asdf has joined #lisp
jgkamat has joined #lisp
Lord_Nightmare has joined #lisp
justinmcp has joined #lisp
stepnem has joined #lisp
eagleflo has joined #lisp
threefjord has joined #lisp
JohnMS has joined #lisp
ck_ has joined #lisp
nullman has joined #lisp
ChibaPet has joined #lisp
Adamclisi has joined #lisp
jackdaniel has joined #lisp
cross has joined #lisp
elderK has joined #lisp
hjudt has joined #lisp
a7f4 has joined #lisp
remexre has joined #lisp
xkapastel has joined #lisp
Finnfinn has joined #lisp
q3d has joined #lisp
JohnMS_WORK has quit [Ping timeout: 245 seconds]
dvdmuckle has joined #lisp
kini has joined #lisp
Ekho has joined #lisp
<pjb>
stylewarning: nope. The answer I give to newbies is pgl!
<loke>
“Inspired by MACSYMA's history variables, MACLISP adopted the convention in early 197 1 that the variable "*" would hold the most recent quantity obtained at top level”
<pjb>
Who invented ** and *** then?
noobineer2 has joined #lisp
<ecraven>
aren't they kind of obvious (at least in hindsight)
q3d has quit [Remote host closed the connection]
<pjb>
But they could be invented by the authors of Macsyma, MacLisp or CL, or somebody else?
noobineer1 has quit [Ping timeout: 276 seconds]
Ricchi has joined #lisp
makomo has joined #lisp
aautcsh has joined #lisp
yoeljacobsen has joined #lisp
lalitmee has joined #lisp
Kundry_Wag has joined #lisp
luis` is now known as luis
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kundry_Wag has quit [Ping timeout: 258 seconds]
jonatack has quit [Quit: jonatack]
elimik31 has joined #lisp
lalitmee has quit [Ping timeout: 245 seconds]
aautcsh has joined #lisp
oni-on-ion has quit [Ping timeout: 264 seconds]
asdf_asdf_asdf has quit [Quit: asdf_asdf_asdf]
lalitmee has joined #lisp
nil has left #lisp ["Fairfarren."]
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<_death>
stylewarning: I recently shared a few videos that show another approach to GUI
jprajzne has quit [Quit: jprajzne]
mindCrime_ has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<beach>
Either I am missing something, or I am not thinking clearly. Did you describe this approach somewhere? I mean, I can see stuff happening in those videos, but I don't know what it is that I am seeing and what is "another approach" about it.
<|3b|>
_death: that's using 'dear imgui' through ffi?
<_death>
it's work in progress, but basically I embedded ecl into a C++ program that uses imgui and started to write bindings.. I can edit things live with emacs, using slime for communication
red-dot has joined #lisp
lalitmee has quit [Quit: Leaving]
lalitmee has joined #lisp
lalitmee has quit [Remote host closed the connection]
<_death>
since I use an opengl/glfw backend for imgui, I can also use the corresponding CL libraries (just have to run such code in the GUI thread)
lalitmee has joined #lisp
<_death>
I added a rudimentary lisp error window yesterday, and there is a restart to end the "current tick", but a debugger interface would require more effort
* |3b|
is starting work on a CL implementation of immediate mode gui idea, mostly aimed at gles/gl/vk (though possibly will also try to make it work on framebuffer at some point)
<|3b|>
(on framebuffers without gles that is... one of the things i want it for in near term is linux fb with gles)
Kundry_Wag has joined #lisp
* |3b|
will probably take a while to catch up to 'dear imgui' though, it has lots of nice features :/
<_death>
3b: cool, wasn't aware of these projects.. but the approach is quite different
<|3b|>
yeah, we CL people like our subtly different libs :)
<_death>
with this approach it's also easy to integrate with other C++ libraries.. a pro (that's also a con) is that you don't need complete bindings, just add things incrementally, and that it's easy to avoid twisting your lisp code to fit the C++ API..
<_death>
I was aware of the nuklear one.. seems both take a CLOS approach, sometimes mirroring the underlying library.. my approach is ad hoc balancing of Lispy code and imgui API ;)
<_death>
also I want to avoid depending on opengl and such in ordinary gui code
<|3b|>
yeah, i'll probably do same thing as imgui and nuklear and just generate a command list, with utilities to make it easy to dump that to GL or whatever
v0|d has joined #lisp
Bike has joined #lisp
<_death>
one issue is that imgui is not very forgiving and would crash with asserts if, say, you didn't pop what you pushed.. I bet there's a way to give your own handler, but still.. in the meantime it's best to use with- macros for paired actions
<|3b|>
c/c++ libs that like to assert are annoying :/
<amerlyq>
simply befriend gdb :)
<amerlyq>
I find long lisp backtraces no less annoying, matter of habit
<|3b|>
seems like you'd have to get pretty friendly to convince the lib to keep running after a failed assert
<amerlyq>
yep, different development cycle, altogether
<|3b|>
backtraces might be annoying, but being able to fix it and try again is very nice
frgo_ has joined #lisp
<_death>
yep, let me record a video showing the rudimentary error reporting :)
<|3b|>
particularly when i'm doing 5 things at once in that image, having 1 of them kill the others for no good reason is not fun :/
Ricchi has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
nwoob has joined #lisp
ChibaPet is now known as mason
lalitmee has quit [Remote host closed the connection]
thijso has quit [Read error: Connection reset by peer]
LiamH has joined #lisp
<_death>
I thought about having an editor window with the lisp source inside imgui.. and with a real inspector, it would be closer to a smalltalk-like environment.. but maybe it's a phantom, because using emacs to develop is just so convenient ;)
thijso has joined #lisp
<|3b|>
yeah, just run emacs in a terminal and display that in your window :)
* |3b|
has done that before, unfortunately doesn't work on windows so had to abandon it :(
<_death>
but it's definitely useful, and a repl window that can easily show charts, animations, etc. would be great.. in the same way that jupyter is :)
<|3b|>
(windows emacs uses windows console instead of vt-whatever style, so only 1 per process, and slow/ugly even for that 1)
<_death>
heh, didn't think of that.. I thought to look for a code editor module for imgui
* |3b|
will try some of the lisp-based editors at some point, though mixing editors is messy
Shinmera has joined #lisp
<Shinmera>
_death: Might want to check out Dissect if you want to include backtraces in your error dialog.
<_death>
Shinmera: thanks, that will be helpful in writing a debugger
* |3b|
considers running emacs on a remote linux box connected to slime on windows box, just so i can have multiple terminal connections to it, but that seems a bit too ugly :p
<_death>
what about writing a console driver for emacs?
<|3b|>
hmm, i need to catch up on pull requests one of these days :/
<|3b|>
yeah, other option is to learn elisp well enough to just grab window data directly and send it over a socket
* |3b|
doesn't consider learning emacs internals well enough to hack the C part a valid option
<|3b|>
probably wouldn't be able to get it upstream even if i did manage to hack that
<_death>
what's that chart on the top left
<|3b|>
of the youtube vid? fps and frame time i think
<_death>
ah :)
<|3b|>
possibly also draw time
<_death>
I ask because I also started on another imgui-related project that begins by capturing pulseaudio output and plotting charts
<|3b|>
that graph is just immediate-mode GL lines i think, so nothing particularly interesting
<|3b|>
yeah, definitely something i want in my im ui lib
Inline has joined #lisp
asdf_asdf_asdf has joined #lisp
thijso has quit [Read error: No route to host]
thijso has joined #lisp
frgo has joined #lisp
FreeBirdLjj has joined #lisp
EvW1 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nwoob has quit [Ping timeout: 245 seconds]
Necktwi has joined #lisp
FreeBirdLjj has quit [Ping timeout: 244 seconds]
knicklux has joined #lisp
lavaflow has quit [Ping timeout: 258 seconds]
<DrDuck>
when i'm defining something in slime, and try to go to a new line, it just evaluates while i'm using paredit
<DrDuck>
how can i get around this?
<_death>
3b: there was this emacs package that allowed you to "view" emacs contents in a browser, live
lavaflow has joined #lisp
<|3b|>
_death: sounds like a useful starting point, will have to look into that when i get a bit further in current stuff
jonatack has joined #lisp
q9929t has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
<beach>
DrDuck: It is better to work with a source file in parallel, and to make your permanent definitions there. Then you can use C-c C-c to have the top-level form evaluated in your Common Lisp system. The REPL is best used for testing small stuff.
<beach>
DrDuck: But yeah, I can see how paredit interacts in funny ways with the REPL.
* |3b|
just doesn't use paredit in repl (and doesn't use repl that much to start with, mostly type random forms into source and evaluate there with C-c C-c, C-M-x, C-x C-e, etc
<DrDuck>
i wanna use the repl while i speed read "on lisp" today
<DrDuck>
they got some continuations stuff in there i wanna understand
<Bike>
graham's book? that has continuations?
<_death>
DrDuck: I think he also defines the amb operator there
<Bike>
does cps conversion. right.
<_death>
Bike: yeah, for the prolog part iirc
<Bike>
and nondeterminism two chapters later
<DrDuck>
yeah and no exercises so i wont feel guilty
<Bike>
guilty?
<DrDuck>
idk if it's amb but there's significant continuation stuff compared to other options, i guess
<DrDuck>
yeah for not doing them lol
<Bike>
the point of exercises isn't to punish you, it's to get you experience
<Bike>
and nondeterminism is pretty much amb
<Bike>
he calls it choose, though
<Bike>
did you try screamer?
moldybits` has joined #lisp
<DrDuck>
no i just can't see how screamer could be something that i can use related to this paper
<Bike>
it's a library that does amb.
<DrDuck>
why doesn't it have the phrase 'amb' in it anywhere. confuses me so much
<DrDuck>
gonna download it now
<DrDuck>
but i'm still gonna speedread graham too
<Bike>
because sometimes, people call the same thing by distinct names.
<Bike>
fucked up but true!
madand has joined #lisp
<Bike>
seriously, did you just look for "amb", not find it, and go "oh this obviously completely different"?
<vms14>
they're just 3 functions, but sure I'm doing wrong stuff yet
<vms14>
or you have a better way to do it
<vms14>
they're functions to call perl oneliners and later perl scripts
<verisimilitude>
Firstly, you'd be better off giving your array a better default size than empty.
<Bike>
do you always need to close the input and output streams to a process?
<vms14>
I guess it closes automatically, but I should
<vms14>
I'm closing the input because I had the program waiting for more input
<Bike>
it might be good to use a string output stream instead of an adjustable string, but i haven't checked
<vms14>
and closing it is like it receives end of file, because I've tried flushing and nope
<vms14>
it works, format can work with this kind of arrays
<Bike>
sure, but you asked for improvements
<verisimilitude>
My second thought is why not rewrite the Perl in Common Lisp?
<vms14>
right
<vms14>
verisimilitude: I try to mix perl and lisp
<verisimilitude>
I'm not seeing anything particularly wrong with this, sans that it only works with SBCL; this works correctly, vms14?
<vms14>
yes, the "portable" library for run programs was very slow compared with the sbcl one
<Bike>
yeah it seems okay at worst.
<vms14>
so it's not portable, unless I improve the performance
<verisimilitude>
If you're going to process the output as lines, why not collect a list of lines, instead?
<vms14>
because the only way to improve performance is daemonize perl and make some sort of socket evaluating input and giving output
<vms14>
verisimilitude: collecting will give me a list instead of only one string, not?
<verisimilitude>
It's more efficient.
<vms14>
I want the output as just one string
<verisimilitude>
You're constantly readjusting an array.
<verisimilitude>
Anyway, my fourth thought is to implement Perl in Common Lisp and then use that.
<vms14>
then I should create a stream like Bike suggested
<|3b|>
(format in "~a~%" input) seems a bit odd, do you care about values other than strings for INPUT? i'd probably write- and terpri if not, and document which others make sense if you do
<|3b|>
docstrings in general would be a good improvement too :)
<|3b|>
alexandria:read-stream-content-into-string would be simpler if you want entire output in 1 string
<vms14>
maybe have a list of lines is more interesting in some cases
<vms14>
so I could put a key parameter to choose if you want a list of lines instead of one string
<|3b|>
possibly should also wait for process to finish before exiting, seems like you have a race with it as it is
<verisimilitude>
There's nothing I love more than a program that drags in Alexandria for one convenience function.
<|3b|>
i guess if read-line blocks, maybe not
<verisimilitude>
What an inconvenience.
<vms14>
I have tried it and it's not failing, at least wasn't failing for not waiting
<vms14>
reading blocks
<verisimilitude>
You can turn the list into a string at the end, vms14.
<|3b|>
yeah, i'm probably wrong about race there
lmln has quit [Quit: Connection closed for inactivity]
* |3b|
loves things that pull in their own random utility lib for one convenience function more than ones that pull in the utility lib i'm already using (= alexandria) :p
<vms14>
verisimilitude: right
<vms14>
then I'll add a key parameter
<vms14>
and collect lines in while
<vms14>
yeah, it's better
aautcsh has joined #lisp
cosimone has quit [Quit: Leaving]
ravenous_ has joined #lisp
vms14 has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 268 seconds]
Ven`` has joined #lisp
Ven`` has quit [Client Quit]
kajo has quit [Ping timeout: 250 seconds]
kajo has joined #lisp
nanoz has quit [Ping timeout: 268 seconds]
aautcsh has quit [Read error: Connection reset by peer]
sauvin has quit [Read error: Connection reset by peer]
lukego has quit [Read error: Connection reset by peer]
lukego has joined #lisp
scymtym has joined #lisp
whartung has quit [Ping timeout: 268 seconds]
<DrDuck>
is the difference between (lambda ..) and #'(lambda ..) that the latter is like a function pointer?
<Bike>
There's no difference in most contexts. The former macroexpands into the latter.
shifty has quit [Ping timeout: 246 seconds]
<Bike>
Sometimes older code prefers the latter, because in pre-common-lisp languages that macro wasn't in place, I think.
EvW1 has joined #lisp
ebrasca has quit [Remote host closed the connection]
random-nick has joined #lisp
karlosz has joined #lisp
<edgar-rft>
There are hairy cases like ((lambda ..) ..) is a valid function call but ((#'lambda ..) ..) isn't, it would require (funcall #'lambda ..) ..) to work.
ravenous_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
vms14 has joined #lisp
<edgar-rft>
sorry nonsense, once again: ((lambda ..) ..) is a valid function call but (#'(lambda ..) ..) isn't, it would require (funcall #'(lambda ..) ..) to work.
reyman has quit [Ping timeout: 252 seconds]
whartung has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
alexanderbarbosa has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
madand has quit [Remote host closed the connection]
Bike has quit [Quit: Bike]
Oladon_work has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
jackotobacco has joined #lisp
<jackotobacco>
Hi, so if I (require :log4cl) at the repl, I can use log:info
<jackotobacco>
compile the file I get 'undefined variable log:info'
<jackotobacco>
function just fine, but if I require in a file and try to
Oladon_work has joined #lisp
<jackotobacco>
whoops on the format
learning has quit [Remote host closed the connection]
Ven`` has joined #lisp
<edgar-rft>
jackotobacco: try this in your file and see if it goes away, replace (require :log4cl) with (eval-when (:execute :load-toplevel :compile-toplevel) (require :log4cl))
learning has joined #lisp
gravicappa has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
<jackotobacco>
edgar-rft: same result. Thanks for trying!
vms14 has quit [Remote host closed the connection]
<ck_>
what do you mean "undefined variable", isn't log:info a function?
<ck_>
jackotobacco: what lisp imlementation are you using?
<jackotobacco>
ck_: actually you just solved it for me. So sorry, but I had a different chunk of code that said log:info outside of a sexp...
<jackotobacco>
Sorry for wasting yall's time. Total CL noob, and it is taking me a sec to get up to speed
ggole has quit [Quit: Leaving]
jackotobacco has quit [Remote host closed the connection]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
amerlyq has quit [Quit: amerlyq]
karswell has quit [Remote host closed the connection]
karswell has joined #lisp
<thijso>
wow, compiling ironclad on ECL is slooooowwww
wigust has quit [Read error: Connection reset by peer]
dale_ has joined #lisp
dale_ is now known as dale
seok has joined #lisp
<seok>
What happens if I call defpackage twice?
<seok>
does the second one override the first? or do all imports from either defpackage get imported?
<semz>
you may be lucky that your implementation defines the consequences so that code relying on it will at least work there
<semz>
but if it doesn't, relying on it gets you into pretty deep circles of hell
<semz>
iirc redefining (or only recompiling?) functions is actually undefined, but almost every implementation supports it
<semz>
so it's not like it doesn't happen, but you should probably try to rewrite the code in a standard-compliant way or consult your impl's docs
zgasma has quit [Ping timeout: 244 seconds]
karswell has quit [Ping timeout: 258 seconds]
smazga has joined #lisp
LiamH has quit [Ping timeout: 245 seconds]
karlosz has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Lord_of_Life_ has joined #lisp
hiroaki has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<Bike>
redefining functions is usually defined. multiple different defpackages is undefined though.
mindCrime_ has quit [Ping timeout: 246 seconds]
<seok>
Ya seems like it, thanks guys
kamog has quit []
liberiga has quit [Quit: Leaving]
chipolux_ has joined #lisp
lmln has joined #lisp
karlosz has quit [Quit: karlosz]
chipolux has quit [Ping timeout: 264 seconds]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
samlamamma has joined #lisp
Ven`` has joined #lisp
cl-arthur has joined #lisp
alexanderbarbosa has quit [Read error: Connection reset by peer]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Ven`` has joined #lisp
Ven`` has quit [Client Quit]
iovec has joined #lisp
samlamamma has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 245 seconds]
lavaflow has quit [Ping timeout: 245 seconds]
learning_ has joined #lisp
learning has quit [Ping timeout: 258 seconds]
cl-arthu1 has joined #lisp
cl-arthur has quit [Ping timeout: 258 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
cl-arthu1 has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
chipolux_ has quit [Quit: chipolux_]
cl-arthur has joined #lisp
chipolux has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
learning_ has quit [Remote host closed the connection]
seok has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
lavaflow has joined #lisp
cosimone_ has joined #lisp
permagreen has quit [Remote host closed the connection]
cosimone has quit [Ping timeout: 250 seconds]
permagreen has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: No route to host]
Kundry_Wag has joined #lisp
karlosz has joined #lisp
karlosz has quit [Client Quit]
karlosz has joined #lisp
jxy has quit [Quit: leaving]
Oladon_work has quit [Ping timeout: 260 seconds]
learning has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
gxt has joined #lisp
karlosz has quit [Ping timeout: 245 seconds]
zaquest has quit [Remote host closed the connection]
cosimone__ has joined #lisp
random-nick has quit [Ping timeout: 245 seconds]
cosimone_ has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
permagreen has quit [Remote host closed the connection]
permagreen has joined #lisp
varjag has quit [Ping timeout: 244 seconds]
poet has joined #lisp
<cl-arthur>
If I want to say (defclass class-name () ((some-slot ... :unique t))) and have that ensure all instances have a unique value for some-slot (by e.g. throwing an error otherwise), is that when it's time to hack together a metaclass?
lucasb has quit [Quit: Connection closed for inactivity]
<no-defun-allowed>
I think so. I did something similar for netfarm, where we have a second external name for serialisation, but we compare between slots instead of instances.
<no-defun-allowed>
Though, you'd need to keep a finger on all instances that you're interested in and make sure that slot can't be updated.
libertyprime has quit [Ping timeout: 244 seconds]
<Bike>
cl-arthur: adding additional slot definition initargs will require a metaclass, yes.
<no-defun-allowed>
However, if you are going to use the same slot every time (or don't mind writing similar code for different classes), you could just use one class-allocated hash-table and an :after method on initialize-instance that checks if the slot value is present in the table, then adds that object to the table.
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
frodef has quit [Ping timeout: 246 seconds]
Kundry_W_ has joined #lisp
<cl-arthur>
Thanks for the replies: sounds like it's time to dig into the MOP. (Certainly sounds a lot more fun than writing out repetitive code :) )
Kundry_Wag has quit [Read error: Connection reset by peer]
cosimone__ has quit [Ping timeout: 264 seconds]
akoana has left #lisp ["Leaving"]
Kundry_W_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
chipolux has quit [Quit: chipolux]
smazga has quit [Quit: leaving]
iovec has quit [Quit: Connection closed for inactivity]
cl-arthur has quit [Quit: Lost terminal]
moldybits has quit [Quit: WeeChat 2.4]
moldybits has joined #lisp
Jeanne-Kamikaze has quit [Remote host closed the connection]