<minion>
p0a, memo from pjb: try to implement DO, then try to implement LOOP…
<p0a>
thanks
<aeth>
p0a: if you were questioning the utility of DO, macroexpand-1 different DOs a few times. It's implementation-specific, but normally it's bindings around fairly direct goto-utilizing code (using TAGBODY and GO).
<aeth>
Then macroexpand-1 LOOP, especially the same LOOP on different implementations. You'll see that LOOP is much higher level.
<p0a>
aeth: I was having a serious issue writing a binary search in DO but I wasn't at my best either
<p0a>
Right, that makes sense
<p0a>
macroexpand-1 is once right?
<aeth>
yes
<aeth>
otherwise it might e.g. macroexpand LET or TAGBODY or whatever, and then that's just a mess
<p0a>
Anyway I'm here for an exciting reason
<p0a>
I actually just came up with a cool project I could write and contribute so I want to ask for some guidance (if it already exists, or any hints about going about it)
<p0a>
So this is the idea: I want to write a function that 'guesses' an expression for a number. For example, (guess 0.7071).
<p0a>
What is 0.7071? Starting at it numerically doesn't give a hint but it's 1/sqrt(2) (or cos(pi/4) etc...)
<pjb>
aeth: are you sure? I thought macroexpand-1 would expand 3 times… I was puzzled or was I?
<p0a>
My approach would be to make a table of rational expressions with known constants and just look up the value.
<aeth>
p0a: So you want to find the nearest symbolic approximation of a given float?
<p0a>
aeth: Yeah, but a reasonable symbolic approximation. I don't want something that a person wouldn't know
<pjb>
p0a: would 7071/10000 do?
<p0a>
But fair enough, I suppose *any* symbolic approx is fine. I just think it's easier if you limit yourself to reasonable symbols
<p0a>
pjb: no
<pjb>
Why not?
<aeth>
p0a: How would it know to use a function like sqrt and not a rational?
<p0a>
pjb: 3.14 should give `pi'. Everyone knows it's pi
<pjb>
only, it's not.
<p0a>
aeth: It simply wouldn't bother with rational expressions
<pjb>
22/7 is pi!
<p0a>
lol yeah
<quazimodo>
pjb: random question, i've probably asked you this years ago, how do you feel about macros?
<p0a>
aeth: Or maybe as a last resort
paul0 has joined #lisp
<aeth>
p0a: 1/sqrt(2) or sqrt(2)/2 is rational, though
<pjb>
quazimodo: strange question. How do I fee about hammers?
<quazimodo>
it's been a long time and i still can't quite find myself being accepting of them
<p0a>
aeth: it's irrational because sqrt(2) is irrational, what do you mean?
Kundry_Wag has joined #lisp
<aeth>
p0a: What you probably want is for it to have a bunch of different representations and then choose the simplest. sqrt(2)/2 or 1/sqrt(2) is simple because it has two very small integers, and 7071/10000 has two really big integers so it's less preferable
<aeth>
p0a: sorry, not rational, you're right, I meant a fraction
<p0a>
aeth: sure, in fact any representation is as good as any other
<quazimodo>
i'll watch that
<p0a>
aeth: I don't care so much for simplicity as just the program recognizing that the number is not "Random".
<aeth>
p0a: Interestingly (/ (sqrt 2)) would win in the Lisp world because that's just one small integer, while the more common-to-humans (/ (sqrt 2) 2) is more complex to the Lisp world.
<quazimodo>
damn you, i thought it would be some articel on macros
sjl has joined #lisp
<quazimodo>
s/rick/hammer roll?
<p0a>
quazimodo: what about `until' ? That\s a common macro in lisp
<pjb>
p0a: LOL a number that's not random :-)
<pjb>
quazimodo: you asked for feelings!
<p0a>
pjb: a very special number indeed
iamFIREcracker has quit [Ping timeout: 240 seconds]
<p0a>
Anyway, any help with that idea? If you want to see something concrete I can cook up something
<quazimodo>
i don'tknow, every time i write a macro i feel 'icky'
<p0a>
quazimodo: also, macros are usually used in `environments'
<p0a>
quazimodo: such as `with-SDL' or `with-opengl' or something like that
<p0a>
`with-socket', etc
<quazimodo>
or, wrote, to be fair it's been a while because i've been doing a lot of web work where we don't really need them much
<quazimodo>
but i came back to learning rustlang some time ago and there are many macros there, they use them for 'zero cost abstractions' frequently in rustlang, also to define dsl
Kundry_Wag has quit [Ping timeout: 252 seconds]
<pjb>
60 years ago, "artists" could do songs from abroad (ten years later, it took this time to cross the pond). Nowadays, with the Internet, if comedians try to translate gags, they get sued and shamed about it. I prefer to watch Louis CK or Ricky Gervais, the originals anyways. :-)
<quazimodo>
maybe i'm just crazy
<pjb>
quazimodo: the question is what you write the macro for, then.
<pjb>
You could ask for specific macros you've written.
<pjb>
Most macros could be written with higher order functions.
<pjb>
But honestly, once you've written a few macros, you will find OO ways to do DSL to be horrible. You know, the kind like: 3.second.from.now
<pjb>
ick!
<quazimodo>
new random syntax via macros is shit
<quazimodo>
it's a tool that is veeerrrrry dangerous in my opinion
<pjb>
they add a method on 3 to produce a TimeInterval, and then a method on TimeInterval to add a Datetime and a method to get the current Datetime...
<pjb>
<*;o~(
<pjb>
bozoos.
<quazimodo>
i'm firmly out of the OO camp now
<quazimodo>
i write a lot of ruby and even then, it's as functional as i can make it
<pjb>
But then, when you don't have macro, it's a trick…
<pjb>
To say, don't be afraid of your macros.
<quazimodo>
the haskell typeclasses are freaking amazing
<pjb>
Unless writting the higher order function is way easier and clearer.
<quazimodo>
but yes back to macros, i _feel_ so much safer with higher order functions
<pjb>
haskell is like OO.
fortitude_ has quit [Read error: Connection reset by peer]
<pjb>
Actually, if you use higher order functions you will easily get something like 3.seconds.from.now
<quazimodo>
i don't follow
<loli>
. is completely different computationally
<loli>
plus the order is reversed from normal . semantics of method lookup
<loli>
lens tend to look like inner object lookup
<quazimodo>
oh you mean the haskell function composition?
<quazimodo>
i feel like this thing is much more sensible than 3.seconds.from.now
<quazimodo>
actually ignore that statement that I made
<aeth>
seconds.from.now is messy, but (seconds (from (now))) which actually reverses the evaluation order could still make sense
<p0a>
what the hell is seconds.from.now lol
<pjb>
(after (now) :seconds 3)
<aeth>
p0a: Some OOP code likes having hacks in their API so it looks like a sentence
<aeth>
p0a: pjb is arguing macros are way better
<quazimodo>
p0a: they violate this idea that an object should not be 'reached through' which I agree with, it's a bad idea because you end up in shit for maintainability everywhere
<p0a>
I see. Thanks for clarifying even though I read the chat I didn't get it
<quazimodo>
it's a different idea than function composition though
<loli>
lenses work through Haskell style macros from what I can tell
<p0a>
quazimodo: you're arguing against a.b.c ?
<quazimodo>
you end up doing '3.seconds.from.now' all over your code base, rather than having some function defined once somewhere that says (seconds-from-now 4) which can be maintained in 1 spot
<p0a>
quazimodo: I mean, is that what you mean by `reached through' ?
<loli>
trans^.em.at is more similar to object lookup syntax in java
<quazimodo>
yeah so '3' evaluates as a literal to some object, an instance of Number, for example. Then it has a method 'seconds' that returns maybe an instance of Seconds object, which has a method 'from' which might return an instance of IncompleteTimeFrom object, which has a method like 'now' which might return an instance of Time
<quazimodo>
that thinking isn't wrong
<aeth>
quazimodo: Is that a Rubyism in particular?
<aeth>
3.whatever seems pretty extreme
<quazimodo>
but the DSL of 3.seconds.from.now is fucked because people use it all over the place, and if that api changes you nend up with hundreds of places to fix
<p0a>
Yeah, so bad design is what it is
<quazimodo>
if it had been abstracuted to some function (or more ugly, a method on Number, which is bloated and a bad idea) you would have to fix it in 1 spot
<quazimodo>
aeth: in ruby all the things are classes or instances of classes
<quazimodo>
it's suuuuper coherent
<quazimodo>
that's something noone can take from ruby, it's so coherent. I stopped using common lisp a long time ago because it had so many vestigial 'things' that i couldn't get my head around
<aeth>
Well, you can do (defmethod seconds ((n number)) (make-instance 'seconds :number n)) in CL
<aeth>
It just is particularly inefficient so a CL programmer probably wouldn't think that way
<quazimodo>
common lisp somehow took the simplicity of lisp and made it very huge and very hard, for me and in my personal opinion
<p0a>
my understanding though is that common lisp is organically created
<p0a>
it wasn't a single imposing authority but rather the `common' parts of lisp code out there that were standarized
<aeth>
quazimodo: Three reasons: compatibility, performance, and flexibility
<quazimodo>
aeth: it felt very much like design by commitee to me
<oni-on-ion>
try scheme
<Bike>
it was, after all, designed by a committee.
<Bike>
but then so is scheme.
<aeth>
It is design by committee. Some of the committee agreed with pjb's style, some with my style, etc., and by some miracle all our styles are valid instead of one person's view winning.
<oni-on-ion>
the implementations are quite coherent. but it depends i think on how we can 'get our heads around' on how something appears coherent or not.
<oni-on-ion>
on=for
<quazimodo>
also in all my time being a programmer, pjb is still one of the scarier more ... scarily good? programmers i've read the source of
<p0a>
So if I were to create a function that takes a bunch of constants and makes various expressions with them, how exactly would I go about it?
<quazimodo>
this dude knows _waaayyyy_ too much
<p0a>
I think a convenient method would be to permute the AST tree in all possible ways (given the constants and allowed operations like + - * / etc)
<Bike>
does it get an AST as an argument?
<aeth>
Common Lisp is one of the last languages designed as an everything-for-everybody language. Most later dynamic languages are quite explicitly Unix/application scripting languages designed to be used with other languages.
<p0a>
Bike: something like (permute pi e 2) would give all [up to some depth] expressions from pi e and 2 using addition, multiplication, square roots, etc.
<p0a>
Bike: btw `pi' and `e' are famous math constants
<Bike>
yes, i have heard of them.
<oni-on-ion>
now i am thinking about Julia.
<quazimodo>
aeth: yeah that's interesting
<Bike>
if you stick with binomial operations it seems easy. (permute pi e 1) => ((* pi e) (+ pi e))
<Bike>
then for the second level you just do it recursively
<Bike>
oh, and include pi and e too i guess, since "up to"
<p0a>
Ah, right on point
<p0a>
I need to define an `operation' with `arity'. That's what it is. Thank you
<p0a>
then it's mix and match
<Bike>
no problem, apparently
<p0a>
Ok stupid question but it would be appropriate to use classes for this right?
<Bike>
i don't really see the point.
<p0a>
You would just remember the structure ?
<p0a>
I mean, an operation can simply be a CONS cell, sure. ('name . arity).
<Bike>
(defun permute (max-depth constants) (if (zerop max-depth) constants (let ((next (permute (1- max-depth) constants) (loop [pick two elements of next] collect `(+ ,element1 ,element2) etc)))))
<p0a>
I was thinking of a class `expression' and a class `operation'
<Bike>
would be the super basic version
<p0a>
sure but I want something a bit more scalable that's all
<p0a>
anyway I'm going to get on it now, thanks again
<pjb>
quazimodo: what parts of my code do you find scary?
<pjb>
By the way, if you have to write C code, using refcounts to manage memory, along with an autorelease pool, seem to lead quite clean code, where you don't have to do a lot of retaining/releasing. Basically, you need to do it only for the "root set", assuming retaining/releasing is done in your basic data structures such as cons cell or vector.
<pjb>
You just need to avoid circularities.
<pjb>
aeth: (seconds #C(1 4)) ; I like the concept too…
Kundry_Wag has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<grewal>
(meters #(0 0 0 -3)) ;As long as c=1
<oni-on-ion>
objective c is beautiful. rust seems messy with its borrowing. but also it provides two kinds of reference counting as well
<p0a>
in DEFCLASS must I provide :initarg?
Kundry_Wag has quit [Ping timeout: 252 seconds]
<Bike>
you don't have to provide an initarg if you don't want.
<p0a>
can I just do (defclass point () (x y)) for example? can x,y be accesssed by slot-value?
<Bike>
yes.
<p0a>
alright, I get it, thanks
<Bike>
i wouldn't recommend doing that though.
<p0a>
typically it's x :initarg :x right?
<Bike>
if you want to make it initializable through make-instance, yes.
<p0a>
gotcha, thank you
<aeth>
pjb: Well, #'- is generic so you would get *an* answer with a complex input
smasta has joined #lisp
okeg has quit [Quit: WeeChat 1.6]
<p0a>
okay a bit of a meta question
<p0a>
but in the theory of math experssions there's `types' and `operations'
atgreen has joined #lisp
<p0a>
I am not sure if I should use these names for my classes/methods because they mean different things in the programming world
<p0a>
should I go with what programmers would be familiar or with what math people would be familiar, as names?
<p0a>
I guess I'll go with the second because I'm not so sure about the first myself
<p0a>
another question: is there a `mapcar' but for ASTs?
<p0a>
wait what am I thinking about
<aeth>
mapcar in a mapcar.
<aeth>
Just have the function call itself if it's a list
<p0a>
aeth: I'm thinking of this: given '(a (b c)) I want to do (funcall (fn a) (funcall (fn b) (funcall (fn c))))
Demosthenex has joined #lisp
<p0a>
Here FN is a function that maps a symbol to the function it corresponds to
<p0a>
(which may be a function of zero arguments)
<p0a>
ok let me try
<p0a>
is there a version of funcall that is taking a list instead of &rest?
<p0a>
APPLY. nevermind
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<aeth>
reduce might also work, e.g. (apply #'+ '(1 2 3)) vs. (reduce #'+ '(1 2 3))
<aeth>
What they're doing is different. The apply is turning that list into (+ 1 2 3) and the reduce is starting with (+) which is 0 and then adding them up in pairs
<p0a>
Ah, alright. So reduce is using + multiple times
<aeth>
What reduce is doing is roughly equivalent to (+ (+ (+ (+) 1) 2) 3)
<aeth>
slime
<aeth>
oops
<p0a>
how can you make an FLET that refers to itself for recursion?
<p0a>
labels? right?
<aeth>
yes, labels
<pjb>
p0a: depends if you ar writting a program about mathematical stuff.
<pjb>
p0a: first, go with what YOU are familiar. Then you may go with what your TEAM is familiar with.
rumbler31 has quit [Ping timeout: 252 seconds]
<pjb>
p0a: and finally, people will get familiar with whatever they find and is useful. So see first point.
<pjb>
(assuming you will make more useful stuff using what you're familiar with).
<p0a>
I'll take a look soon, I'll first try to do it and see if I can
<pjb>
p0a: ie. you should abtract away your tree representation. COPY-TREE and SUBST and SUBST-IF work on trees of cons cells, which is not how you will represent your trees usually.
<pjb>
aeth: actually, reduce calls (+) only when given an empty list and no :initial-value.
<pjb>
(reduce (lambda (a b) `(+ ,a ,b)) '(1 2 3)) #| --> (+ (+ 1 2) 3) |#
<aeth>
pjb: Yes, I was talking about (reduce #'+ '(1 2 3)) and not all reduces, because e.g. there's also :from-end
<aeth>
pjb: it doesn't start with (+)?
<p0a>
what's a good pasting website
<pjb>
(reduce (lambda (&optional a b) (if a `(+ ,a ,b) `(+))) '()) #| --> (+) |#
<pjb>
(reduce (lambda (&optional a b) (if a `(+ ,a ,b) `(+))) '(1 2 3 4)) #| --> (+ (+ (+ 1 2) 3) 4) |#
<pjb>
(reduce (lambda (&optional a b) (if a `(+ ,a ,b) `(+))) '(1)) #| --> 1 |#
<p0a>
From `Diving in'. They wrote `(name p1)' so I didn't realize it should've been :name. Or is it because I *named* it :fn and :name ? whooops!
<p0a>
alright, thakn you
<quazimodo>
pjb: oh it wasn't scary code, it was just ... i've felt it before where what I'm reading indicates a developer with really really vast and deep knowledge
<pjb>
That's not it felt when I was writting it!
<quazimodo>
there are a couple dudes like that in ruby world
<quazimodo>
hehe i've got an acquaintance in ruby world that is pretty prolific and when i go through his stuff it's super clear that he's incredibly knowledgeable but he's also like a dude swinging a great sword in all directions, not caring who it hits
<p0a>
it'll hit his head one day
<quazimodo>
his stuff goes past automating the mundane and into the realm of automating stuff the developer really ought to be writing
<oni-on-ion>
ruby and other profane peasant languages are limited in the right ways for just that type of sword wielding. got to be good with the blade with things like C and common lisp
Bike has quit [Quit: Lost terminal]
<pjb>
Ah, ruby; I thought you wrote rugby; I was a little puzzled. Swords in the melée!
<p0a>
yeah fan attendance was low so they did what they could
<quazimodo>
ha
<p0a>
:P
<p0a>
hm so now I'm realizing there's two approaches to this
<p0a>
I can use a common lisp AST or I can use my own AST
<p0a>
so I can either have '(* (+ 1 2) (+ 3 4)) or '(mul (add 1 2) (add 3 4))
<oni-on-ion>
whats the diff
Ukari has quit [Remote host closed the connection]
<p0a>
the difference is that the first approach requires you to use valid lisp code whereas the second does not
<p0a>
oni-on-ion: in the second approach, I could have something like (lit 1) which would be the literal 1.
<p0a>
I don't know exactly what the difference is right now. Just got stuck thinking about this
<pjb>
quazimodo: I don't see where the ballon is!?
Kundry_Wag has joined #lisp
torbo has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 264 seconds]
<p0a>
how do you compare symbols?
<p0a>
with EQ ?
<p0a>
yeah
<p0a>
oh darn it this isn't quite easy
<p0a>
I think this will take some time before I actually write it
Aurora_iz_kosmos has joined #lisp
jakio has joined #lisp
<Aurora_iz_kosmos>
Does SBCL have a mean to create statically-linked images when one uses CFFI dependencies?
jakio has left #lisp [#lisp]
p0a has quit [Remote host closed the connection]
Bardicus has joined #lisp
Bardicus has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
torbo has joined #lisp
rwlisp has quit [Quit: rwlisp]
torbo has quit [Remote host closed the connection]
torbo has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<Aurora_iz_kosmos>
Hm. Seems like cffi-grovel & static-linking might do it.
igemnace has joined #lisp
_whitelogger has joined #lisp
anewuser has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
<pjb>
minion: memo for p0a: don't use EQ. This prevents your programs to evolve toward using numbers or characters in place of symbols (who knows what type of objects you'll have to process later). Instead, use EQL.
<minion>
Remembered. I'll tell p0a when he/she/it next speaks.
orivej has quit [Ping timeout: 250 seconds]
dddddd has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
pankajgodbole has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
Aurora_iz_kosmos has quit [Quit: later]
torbo has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
milanj has quit [Read error: Connection reset by peer]
dale has quit [Quit: dale]
milanj has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 252 seconds]
smasta has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
vlatkoB has joined #lisp
Inline has quit [Quit: Leaving]
smasta has quit [Ping timeout: 240 seconds]
leo_song has quit [Quit: ZNC 1.6.5+deb1+deb9u1 - http://znc.in]
<quazimodo>
pjb: where do you work that you get to do so much cl?
milanj has quit [Read error: Connection reset by peer]
milanj has joined #lisp
<beach>
Good morning everyone!
eminhi has joined #lisp
beach has quit [Ping timeout: 252 seconds]
beach has joined #lisp
zakora has joined #lisp
rumbler31 has quit [Remote host closed the connection]
mgsk has quit [Read error: Connection reset by peer]
fivo has joined #lisp
jhei has quit [Ping timeout: 252 seconds]
Duns_Scrotus has quit [Ping timeout: 258 seconds]
smasta has joined #lisp
XachX has quit [Ping timeout: 258 seconds]
billstclair has quit [Read error: Connection reset by peer]
smasta has quit [Ping timeout: 268 seconds]
fanta7531 has joined #lisp
splittist has quit [Ping timeout: 258 seconds]
sauvin has joined #lisp
libertyprime has joined #lisp
vlatkoB has quit [Ping timeout: 264 seconds]
eminhi has joined #lisp
splittist has joined #lisp
Duns_Scrotus has joined #lisp
physpi has joined #lisp
jhei has joined #lisp
mgsk has joined #lisp
XachX has joined #lisp
anewuser has quit [Quit: anewuser]
billstclair has joined #lisp
<refpga>
Hi, how can I save the sbcl image of the session in slime? I understand that sb-ext:save-lisp-and-die doesn
<refpga>
^.. doesn't work with multithreaded programs.
<refpga>
And slime runs multiple threads.
<refpga>
How can I save the slime session?
shrdlu68 has joined #lisp
ltriant has quit [Quit: leaving]
schweers has joined #lisp
dvkt has quit [Quit: leaving]
ricekrispie has quit [Read error: Connection reset by peer]
ricekrispie has joined #lisp
andrei-n has joined #lisp
<flip214>
refpga: I'm building an image with all wanted systems, but _don't_ start slime in it.
<flip214>
when running that image again I connect to swank in there.
libertyprime has quit [Ping timeout: 255 seconds]
<refpga>
Okay, I don't think I understand. Do you mean that you load packages and save the image, without slime, and use swank to connect to that image the next time?
vlatkoB has joined #lisp
scymtym has joined #lisp
zmyrgel has joined #lisp
stereosphere has quit [Remote host closed the connection]
eminhi_ has joined #lisp
jlarocco has quit [Ping timeout: 250 seconds]
eminhi has quit [Ping timeout: 240 seconds]
techquila has quit [Remote host closed the connection]
cyberoctopi has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
hhdave has joined #lisp
mgsk has quit [Ping timeout: 255 seconds]
hhdave_ has joined #lisp
Duns_Scrotus_ has joined #lisp
mgsk has joined #lisp
Duns_Scrotus has quit [Ping timeout: 252 seconds]
Duns_Scrotus_ is now known as Duns_Scrotus
Kundry_Wag has quit [Ping timeout: 264 seconds]
<flip214>
yes
<flip214>
so I get quick startup although lots of functionality is backed in
hhdave has quit [Ping timeout: 240 seconds]
hhdave_ is now known as hhdave
<flip214>
but if your use case is "snapshot of a process being debugged", that's hard... in any case the connections to slime get lost, multithreading, etc.
<flip214>
the best bet might be to find some way to "undump" a core dump, that was possible a few years ago
libertyprime has joined #lisp
refpga has quit [Remote host closed the connection]
<flip214>
I believe that use case was trashed by QuickLisp.
<jackdaniel>
lack of news means that the library is complete and there were no bugs ever since ;-)
<flip214>
and that _nothing_ in the whole environment changed to cause bitrot _anywhere_
bbbobbb has joined #lisp
atgreen has quit [Ping timeout: 240 seconds]
atgreen has joined #lisp
angavrilov has joined #lisp
refpga has joined #lisp
orivej has joined #lisp
<phoe>
scymtym: "a release based on SBCL 0.9.14"
<phoe>
could use an update
eminhi_ has quit [Ping timeout: 245 seconds]
refpga has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
refpga has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
<jackdaniel>
is there a reason why series:mapping wouldn't work in a loop I'm not aware of? I didn't find anything in the specification, here is the report: https://github.com/tokenrove/series/issues/1
eminhi has joined #lisp
<scymtym>
phoe: i pointed it out because i think it is interesting. i'm not suggesting that it is a practical solution without additional work
orivej has quit [Ping timeout: 268 seconds]
dddddd has joined #lisp
mingus has quit [Remote host closed the connection]
orivej has joined #lisp
<flip214>
jackdaniel: LOOP only looks at SYMBOL-NAME of things - and I guess MAPPING is a conflict with LOOPs MAPPING.
<flip214>
hmmm no, macroexpansion denies that hypothesis.
<flip214>
Same with ITERATE
mingus has joined #lisp
<jackdaniel>
when I put macroexpanded map-fn problem persists
<flip214>
even a (DOLIST (i '(1)) ...) shows the same symptoms
<jackdaniel>
looking briefly at the source code I see some (go tag) where tag is not gensymed, so maybe there is some kind of a conflict
<flip214>
ah, is that run in other threads?
<lieven>
However, if mapping is used in a situation where the output is not used, no computation is performed, because series elements are not computed until they are used. Thus iterate can be thought of as a declaration that the indicated computation is to be performed even though the output is not used for anything.
<jackdaniel>
no, I'm evaluating in the repl
<flip214>
I now put outputs to *trace-io* before and after the mapping, and got this output - followed by NIL from DOLIST.
<flip214>
and _after_ that I saw the "inside " lines!
<jackdaniel>
it seems that lieven suggestion checks out
<jackdaniel>
apparently mapping is assumed to have no side effects
ebrasca has joined #lisp
<jackdaniel>
adding print for the form makes it work
<lieven>
I was quoting the appendix of CLtL 2 :)
<jackdaniel>
you are right and I've missed this part
<jackdaniel>
thank you both
<flip214>
oh, that is the CL series? because of the Series: prefix (and having to QL it) I thought this is another implementation
<flip214>
and there's no documentation on MAPPING
<lieven>
series didn't make it into the standard
Kundry_Wag has joined #lisp
<jackdaniel>
fact that it works as specified is consoling, because while I had an easy workaround with iterating given that would be a bug I would be constantly suspicious where other bugs may appear
<lieven>
its use of #'(lambda () (go tag)) once triggered a bug in Allegro CL if the tag was lexically defined after the capture
<lieven>
it is fairly cutting edge code
<lieven>
unfortunately it also uses COMPILER-LET so not really portable
<lieven>
I had a brief look at removing that but it was beyond me
Kundry_Wag has quit [Ping timeout: 252 seconds]
m00natic has joined #lisp
<jackdaniel>
I'm not that much bothered with compiler-let, but sure, that renders the library not being a portable CL code
fanta1 has joined #lisp
Kundry_Wag has joined #lisp
rumbler31 has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Ping timeout: 250 seconds]
fanta1 has quit [Quit: fanta1]
no-defun-allowed has quit [Quit: The assumption that what currently exists must necessarily exist is the acid that corrodes all visionary thinking.]
orivej has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
fanta1 has joined #lisp
gxt has quit [Quit: WeeChat 2.4]
orivej has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
_whitelogger has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
keep_learning has quit [Quit: Ping timeout (120 seconds)]
Kundry_Wag has quit [Ping timeout: 255 seconds]
zigpaw has quit [Remote host closed the connection]
milanj has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
ricekrispie2 has joined #lisp
rumbler31 has quit [Ping timeout: 252 seconds]
ricekrispie has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
orivej has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
refpga has quit [Ping timeout: 252 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
notzmv has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
zmyrgel has quit [Remote host closed the connection]
moldybits has quit [Quit: WeeChat 2.4]
Kundry_Wag has quit [Ping timeout: 250 seconds]
moldybits has joined #lisp
asdf_asdf_asdf has joined #lisp
<asdf_asdf_asdf>
Hi. How compile .obj file with .lisp file? (Windows) I want use function from another module.
<beach>
asdf_asdf_asdf: That is usually not how Common Lisp works. What is the other module?
<beach>
Am I understanding your right that you want to generate standard object code from a Common Lisp source file?
zakora has quit [Ping timeout: 264 seconds]
selwyn has joined #lisp
patlv has joined #lisp
<beach>
asdf_asdf_asdf: Hello?
Bike has joined #lisp
lavaflow has quit [Ping timeout: 246 seconds]
patlv has quit [Ping timeout: 246 seconds]
<asdf_asdf_asdf>
beach; sorry I was AFK. I have .obj file. Inside this file I have function. I want use function which is in .obj file. How it do?
<beach>
Oh, I see.
<beach>
What language was used to generate the object file?
<p_l>
asdf_asdf_asdf: compile it into DLL, then access it using CFFI
<beach>
I assume .obj means object code.
<pjb>
Are you using ecl?
<pjb>
asdf_asdf_asdf: only ecl is able to generate files that can be linked with other object files produced by other (non-lisp) compilers.
<asdf_asdf_asdf>
asm x86, .asm --> .obj and I have use function from .asm to lisp code.
orivej has quit [Ping timeout: 264 seconds]
zakora has joined #lisp
<pjb>
asdf_asdf_asdf: on the other hand, you can use libraries compiled by other (non-lisp) compilers in CL implementations, using CFFI.
<asdf_asdf_asdf>
I want use function from .asm file.
<asdf_asdf_asdf>
In .lisp file.
<pjb>
asdf_asdf_asdf: but then, you don't produce .dll (unless you're using allegro or lispworks, they may be able to produce .dll)
<beach>
pjb: I think you are misunderstanding what asdf_asdf_asdf wants to do.
<pjb>
In that case, you would need to make a shared library of the .obj file, and then you can load this library with cffi.
<pjb>
So, just like p_l said.
<asdf_asdf_asdf>
I have this: Import func1 from xx.asm. <--
atgreen has quit [Ping timeout: 250 seconds]
<asdf_asdf_asdf>
I want.*
<asdf_asdf_asdf>
And apply it in code .lisp.
<p_l>
asdf_asdf_asdf: you need to make a DLL out of it so that Lisp can load it
<p_l>
(or rewrite it in your implementations variant of LAP)
<p_l>
writing custom loader is a bit harder task
<asdf_asdf_asdf>
Yes, so I think. How create .dll file from .asm file using gcc, ld, nasm?
<pfdietz>
169 of those files have a test-op. So, that adds about 200 more.
katco has joined #lisp
<pfdietz>
I wonder if any of the larger systems here were deliberately released without tests, as commercial teasers. A 1.2M line system with no tests is not going to be useful by itself.
<cage_>
i like a lot lmj's code
skidd0 has joined #lisp
<jackdaniel>
selwyn: thank you! as of interfacing with gnuplot, I'm sure such extension could be written but I don't see a use case for that
cl-arthur has joined #lisp
nowhere_man has joined #lisp
atgreen has joined #lisp
bbbobbb has quit [Remote host closed the connection]
<Demosthenex>
so i'm a total noob to the socket lib, and the examples i'm reading show using a blocking read-line to read data from a usocket connection. is there a way to detect if there's new data instead of blocking?
<jackdaniel>
stream-listen is one way to do that
<sjl_>
I have a local fork of 1am that adds slightly nicer error printing, but otherwise yeah, I like it. ~80loc, no bloat, just a good small unit test library.
<Demosthenex>
working with a server that only sometimes replies, like probing for a response.
<Demosthenex>
if i wait every time, won't work
<jackdaniel>
Demosthenex: see above
Zaab1t has joined #lisp
atgreen has quit [Ping timeout: 255 seconds]
ebrasca has quit [Remote host closed the connection]
<jackdaniel>
fwiw I've grown a 2am library based on 1am, but only for internal use (i.e I did not put it on ql)
<jackdaniel>
sjl_: stream-listen is the function (too)
<jackdaniel>
it is defined in gray proposal
<sjl_>
clhs stream-listen
<specbot>
Couldn't find anything for stream-listen.
<sjl_>
Ah, it's in gray streams
<jackdaniel>
gray streams
<jackdaniel>
but yes, usocket suggests simply using listen
<_death>
stream-listen is for extending listen
<sjl_>
stream-listen is what the implementor of the stream would define, but the end user would still be calling listen, right?
<jackdaniel>
they could, it will be ultimately delegated to stream-listen (in case of gray streams at least), but I don't see why could't that be use in application code (as in: if you call stream-listen something will not work or whatever, because it is for extending only)
tokik has joined #lisp
<_death>
it may be that certain streams are not defined in terms of the Gray stream protocol.. I guess it's yet another pitfall coming from Gray streams parroting the user's interface
<Bike>
i figured it was just like how you're not supposed to call print-object.
t58 has joined #lisp
atgreen has joined #lisp
lumm has joined #lisp
Zaab1t has quit [Ping timeout: 245 seconds]
rumbler31 has quit [Remote host closed the connection]
selwyn has quit [Remote host closed the connection]
knicklux has joined #lisp
hhdave has quit [Ping timeout: 264 seconds]
LiamH has joined #lisp
lumm__ has joined #lisp
lumm has quit [Ping timeout: 258 seconds]
lumm__ is now known as lumm
dtw has joined #lisp
tokik has quit [Quit: leaving]
asdf_asdf_asdf has quit [Ping timeout: 246 seconds]
smasta has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
lumm has quit [Read error: Connection reset by peer]
Jesin has quit [Quit: Leaving]
lumm has joined #lisp
edgar-rft has joined #lisp
lumm has quit [Client Quit]
lumm has joined #lisp
myrkraverk has quit [Remote host closed the connection]
asdf_asdf_asdf has joined #lisp
karlosz has joined #lisp
Jesin has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
<sjl_>
TIL that ROOM can take arguments
<_death>
too bad ROOM and functions like it print information instead of returning it
<sjl_>
yeah
<oni-on-ion>
hijack the stream and capture it
<oni-on-ion>
(let ((*standard-output* ...)) .. )
<Bike>
yeah but then you'd have to parse it and it's not built for that.
<oni-on-ion>
parse what, the string ? hm. is there sscanf-like feature in CL?
atgreen has quit [Ping timeout: 245 seconds]
scymtym has quit [Ping timeout: 252 seconds]
<Bike>
the information returned by room, yes.
<Bike>
there is no scanf but there are plenty of ways to parse a string
<oni-on-ion>
capture the stream into a string, of course
<_death>
I remember Xof's (setf format) hack
<Bike>
yes. capturing the string is easy. that's not the issue
<_death>
oni-on-ion: the output is implementation-dependent
<Bike>
_death: that sounds horrid, is it up anywhere?
<sjl_>
I think it's something like (let (x y) (setf (format nil "~D ~A" x y) "1234 (1 2 3)"))
pankajgodbole has quit [Ping timeout: 264 seconds]
<Bike>
"the use"
<phoe>
oh shit
<phoe>
~A must have issues with spaces though
beach has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 268 seconds]
d4ryus has quit [Quit: WeeChat 2.4]
cosimone has quit [Quit: WeeChat 2.3]
<Bike>
~a just takes a string, i guess. ~s requires whitespace but the comment says he wanted to make it better than that
milanj has joined #lisp
smasta has joined #lisp
beach has joined #lisp
d4ryus has joined #lisp
smasta has quit [Ping timeout: 245 seconds]
smasta has joined #lisp
asdf_asdf_asdf has quit [Remote host closed the connection]
jfe has joined #lisp
<jfe>
hi all
<phoe>
heyyy
cage_ has quit [Remote host closed the connection]
cyberoctopi has joined #lisp
warweasle has quit [Quit: bbl]
Arcaelyx has joined #lisp
orivej has joined #lisp
hugotty has quit [Quit: ZNC 1.6.5+deb1+deb9u1 - http://znc.in]
smasta has quit [Ping timeout: 246 seconds]
hugotty has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
khisanth_ has quit [Ping timeout: 250 seconds]
asdf_asdf_asdf has joined #lisp
Lycurgus has joined #lisp
khisanth_ has joined #lisp
knicklux has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 245 seconds]
ramHero has joined #lisp
smasta has joined #lisp
ramHero has quit [Client Quit]
ramHero has joined #lisp
ramHero has quit [Client Quit]
parjanya has quit [Remote host closed the connection]
lumm has quit [Ping timeout: 246 seconds]
djeis[m] has joined #lisp
lumm has joined #lisp
lumm has quit [Read error: Connection reset by peer]
atgreen has quit [Ping timeout: 268 seconds]
lumm has joined #lisp
atgreen has joined #lisp
mindCrime has quit [Read error: Connection reset by peer]
mindCrime has joined #lisp
lumm has quit [Ping timeout: 246 seconds]
oni-on-ion has quit [Ping timeout: 255 seconds]
amerlyq has quit [Ping timeout: 268 seconds]
lumm has joined #lisp
amerlyq has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
lumm has quit [Quit: lumm]
lumm has joined #lisp
gareppa has joined #lisp
shka_ has quit [Ping timeout: 268 seconds]
digash has quit [Ping timeout: 252 seconds]
vlatkoB has quit [Remote host closed the connection]
kajo has joined #lisp
kajo has quit [Client Quit]
kajo has joined #lisp
eschulte has quit [Quit: leaving]
orivej has joined #lisp
atgreen has quit [Ping timeout: 246 seconds]
skidd0 has quit [Quit: WeeChat 2.4]
milanj has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
gareppa has quit [Quit: Leaving]
myrkraverk has joined #lisp
ramHero has joined #lisp
rumbler31 has joined #lisp
libertyprime has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
smasta has quit [Ping timeout: 246 seconds]
mindCrime has quit [Ping timeout: 246 seconds]
cyberoctopi has quit [Ping timeout: 246 seconds]
Bike has quit []
jfe has quit [Ping timeout: 246 seconds]
amerlyq has quit [Quit: amerlyq]
karlosz has joined #lisp
rumbler31 has quit [Remote host closed the connection]
karlosz has quit [Client Quit]
karlosz has joined #lisp
cyberoctopi has joined #lisp
lisbeths has joined #lisp
<lisbeths>
can lisp do anything that category theory allows for?
<grewal>
What do you mean by that?
<lisbeths>
It is hard to explain but here it goes
<lisbeths>
I have a math professor I am teaching about lisp.
<lisbeths>
First of all he says he is unaware of if category can do everything set theory can do
<lisbeths>
he is also unaware of if set theory can do everything category theory can do
<lisbeths>
but he seems confident that lisp can not do everything category theory can do
<lisbeths>
and I am trying to determine the truth values of those three queries
<lisbeths>
He can't himself define what he means by "everything category theory can do" because he does not know category theory
<grewal>
You're probably better off talking about a turing machine rather than any particular programming language
<lisbeths>
can a turing machine do everythign that set theory can do?
oni-on-ion has joined #lisp
<lisbeths>
or in other words every operation that set theory allows for
oni-on-ion has quit [Quit: Leaving]
milanj has quit [Quit: This computer has gone to sleep]
gxt has joined #lisp
teej has joined #lisp
lumm has quit [Quit: lumm]
no-defun-allowed has joined #lisp
atgreen has joined #lisp
milanj has joined #lisp
White_Flame has quit [Ping timeout: 252 seconds]
<cl-arthur>
Is everything in set theory computable? :P
<grewal>
I really don't know what you're asking. Also, this might be off-topic. This channel is meant for common lisp. If you're interested in other lisps, check out ##lisp. Maybe look for math channels, or try math.stackexchange
White_Flame has joined #lisp
<no-defun-allowed>
cl-arthur: it would be slow to compute them using lists as sets, at least
sjl_ has quit [Ping timeout: 252 seconds]
<pjb>
cl-arthur: nope. set of all sets…
<pjb>
cl-arthur: also, Gödel theorem is direct application of set theory.
<pjb>
lisbeths: category theory is a formal system. lisp is a turing complete formal system. Therefore lisp can do everything that category theory can do.
<pjb>
have fun!
<lisbeths>
pjb: thank you what a wonderful lisper you always turn out to be
libertyprime has quit [Ping timeout: 246 seconds]
LiamH has quit [Quit: Leaving.]
<pjb>
lisbeths: seriously, have a look at eg. Reasoning about qualitative temporal information with S-words and S-languages
<pjb>
lisbeths: basically, nowadays, mathematical theories are formal systems. That is, a set of "objects", a set of axiomatic rules, and a set of deduction rules. All these can be represented in a lisp program, and the deduction rules can be used to perform automatic proof or generation of theorems.
<pjb>
What more would he want?
<lisbeths>
Well learning the limits of computation in terms of lisp are alot harder than doing it in terms of ordinary math because the math he uses is not formalized and he is using alot of different informal systems and mixing them together
<lisbeths>
and he seems unconvinced that I can take lisp and use macros to formally turn it into any system he throws at me
<Bike>
you don't need macros. just write an interpreter.
<lisbeths>
I like macros because it allows me to write rules for interpretation in the middle of my program and exit out of them again. To each their own.
cyberoctopi has quit [Ping timeout: 250 seconds]
<grewal>
It's fine if you're willing to do proof by exhaustion. But there's probably sufficient literature out there to prove what you want without actually doing much programming
cyberoctopi has joined #lisp
wxie has joined #lisp
chipolux has quit [Ping timeout: 250 seconds]
asdf_asdf_asdf has quit [Remote host closed the connection]
<lisbeths>
One of my life goals is to try to get people to teach lisp in schools instead of math
chipolux has joined #lisp
<grewal>
I hope you just mean higher level education, like an introductory course in college
<lisbeths>
starting from algebra and moving onwards
<lisbeths>
so you'd probably take lisp 1-4
<lisbeths>
and pre-lisp would just teach you s expressions
<grewal>
I was worried you wanted to teach lisp instead of math to young kids. Then we'd have another "new math" fiasco
<pjb>
lisbeths: also, have a look at sicm.
<grewal>
I think trigonometry is useful. But yeah, lisp, or just computer science in general, is totally a viable alternative to precalculus and calculus
<lisbeths>
Well for example you could not easily replace shool math with perl
<lisbeths>
or awk
<aeth>
One of my goals is to get people to teach Lisp in schools instead of English. (one (goals *aeth*)) => (teach +common-lisp+ :in *schools* :replacing *english*)
<aeth>
And of course +common-lisp+ is a constant because you all say time and time again there will never be another standard!
<lisbeths>
the closest thing I have foudn to lisp in human language is to put a verb at the end of the sentence
<lisbeths>
To the store he went. The milk up he picked. Drove back he did.
<grewal>
aeth: wrap that in a (unless (member country *native-english-speaking-countries*))
<aeth>
lisbeths: lingua latina Lisp est.
<aeth>
Latin is Lisp!
<grewal>
In latin (and other grammatically similar languages), you could put the verb first as well.
<aeth>
yes, it's just a convention, as much as *foo* is a Lisp convention
<lisbeths>
I dunno I speak spanish and it doesn to feel very lispy to me
<lisbeths>
but maybe its because I am so used to doing it I don't think it
<grewal>
Spanish isn't grammatically similar to latin, afaik. Just the vocabulary is
<aeth>
afaik, the verbs are fairly similar except for the position
<aeth>
simplified, of course.
<grewal>
But the nouns don't decline.
<aeth>
yes
<aeth>
If you're coming from Latin, though, you can pick up Romance languages since it's mostly simplifications and adding vocabulary.
karlosz has quit [Quit: karlosz]
<grewal>
My Latin teacher claimed that you could speak any Romance language fluently within 6 months if you knew latin
<aeth>
Absolutely not, but if you can get used to the different spelling conventions, it's very easy to be *literate* in the Romance languages. Listening/speaking it is harder.
<lisbeths>
This is pretty much true
<lisbeths>
the words are very similar across roman languages
<lisbeths>
Knowing spanish I could speak romanian or russian or ukranian or whatever I'd like fiarly quickly.
<pjb>
aeth: absolutely.
<lisbeths>
It is kind of like learning your first programming language. What you realize is you have to learn about 10,000 words to communicate.
<pjb>
aeth: Grammar rules are easy to learn. Vocabulary takes time.
<grewal>
aeth: I agree with you. If you discount french, I believe he was right.
<pjb>
aeth: being French, I learned Spanish watching TV during 2 months.
<aeth>
pjb: Going Romance-to-Romance is pretty easy. Going Latin-to-Romance is only easy in the written form, especially French, which is conservative in its spelling (e.g. "et"), but probably the most changed in pronounciation
<grewal>
Granted, I learned the ecclesiasitcal pronuciation of latin and not the classical, so that may bias me. It was very easy for me to start picking up Italian
karlosz has joined #lisp
<aeth>
Well, that's basically just Latin pronounced like modern Italian.
anewuser has quit [Ping timeout: 244 seconds]
digash has joined #lisp
<aeth>
So what's everyone doing this month in Common Lisp?
<no-defun-allowed>
hmm, i'm working on implementing/designing netfarm which is some kind of distributed trustless object system, have a school project i'll do in CL and i'm trying to find a job in CL
<no-defun-allowed>
i tried (find-if (alexandria:curry #'< 18) *jobs* :key #'job-age-requirement) to no avail
karlosz has quit [Quit: karlosz]
<grewal>
I'm working on a to-do list program. I haven't found an existing program that allows for quickly finding completed tasks.
<aeth>
<insert org-mode comment here>
wxie has quit [Ping timeout: 240 seconds]
<grewal>
...I guess I should learn emacs. But it feels like such a waste after spending so much time investing in vim
<no-defun-allowed>
# install org-mode
<no-defun-allowed>
grewal: you'll be much more productive in emacs, with SLIME and all that stuff
ltriant has joined #lisp
<grewal>
no-defun-allowed: I have slimv and paredit
<grewal>
no-defun-allowed: and I'm used to vim keybindings in many other programs
<no-defun-allowed>
evil-mode
<grewal>
I tried, but it doesn't implement everything
rumbler31 has joined #lisp
moldybits` has joined #lisp
moldybits`` has joined #lisp
moldybits has quit [Ping timeout: 250 seconds]
moldybits has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
moldybits has quit [Read error: Connection reset by peer]
moldybits` has quit [Ping timeout: 255 seconds]
<grewal>
org-mode might actually fit what I want, thanks