<selwyn>
i added a few small changes to expose v2.4 functionality which i am using in my project
bitch has quit [Read error: Connection reset by peer]
Lord_of_Life has quit [Read error: Connection reset by peer]
<selwyn>
specifically relating to hermite polynomials
<jcowan>
not to be confused with hermite crabs
<selwyn>
i would be happy to turn it into a patch, though i wonder if it is planned to move to v2.4 or not
<selwyn>
also the 'gitlab common lisp' is down, hopefully this is temporary
hhdave has quit [Quit: hhdave]
Ellusionist has quit [Ping timeout: 265 seconds]
z3t0 has joined #lisp
z3t0 has quit [Client Quit]
wxie has joined #lisp
<jmercouris>
You know, I'm not sure sure common-lisp.net has any active administration, I emailed about getting a mailing list like 2 months or so ago, and had no response
convexferret has quit [Ping timeout: 252 seconds]
bailon has quit [Ping timeout: 252 seconds]
rgrau has quit [Ping timeout: 252 seconds]
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
Lord_of_Life has joined #lisp
Lord_of_Life has joined #lisp
alms_clozure has quit [Ping timeout: 252 seconds]
nimiux has quit [Ping timeout: 252 seconds]
alms_clozure has joined #lisp
akkad has quit [Ping timeout: 252 seconds]
pierpa has quit [Quit: Page closed]
<dmiles>
jmercouris: might try #common-lisp.net
micro has quit [Ping timeout: 264 seconds]
rgrau has joined #lisp
nimiux has joined #lisp
convexferret has joined #lisp
bailon has joined #lisp
bitch has joined #lisp
felideon has quit [Read error: No route to host]
trocado has quit [Ping timeout: 248 seconds]
nowhere_man has quit [Ping timeout: 265 seconds]
akkad has joined #lisp
Baggers has joined #lisp
varjagg has quit [Remote host closed the connection]
varjagg has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
varjagg has quit [Ping timeout: 265 seconds]
nowhere_man has joined #lisp
<jmercouris>
thanks for the tip, at this point though I've kinda resigned to just running my own server at some point if nEXT gets big enough
fittestbits has joined #lisp
pilfink has joined #lisp
<bms_>
jmercouris: You make the nEXT browser? I've been hearing about it for a while and now that I'm taking a look at it, it looks really nice.
<jmercouris>
bms_ Well, it isn't just me, but I am the main author yeah
<jmercouris>
thank you for the kind words
<bms_>
Sure thing. I'm setting up my new laptop right now and think it might be a good opportunity to use nEXT as much as I can.
<jmercouris>
Are you on Linux or MacOS?
<bms_>
Linux.
<jmercouris>
Okay, well, a few things remain till I merge GTK in main branch, but I will keep this channel updated, so you'll definitely see it!
<Baggers>
jmercouris: keep up the good work, since vimperator died I'm very tempted to switch
<bms_>
Okay, thanks.
<jmercouris>
Baggers: Thank you :) I hope it will meet your expectations!
<p_l>
to be truly switchable it need µBlock Origin and/or µMatrix :)
<jmercouris>
Ah yeah, that's a challenge that because I'd need to do stuff for the network stack on both Cocoa/Linux, unless I do some naieve js blocking, which is of course possible
<jmercouris>
Belive me, I wish I had an ad-blocker every day
<jmercouris>
It's pretty high up on there on my todo list lol
fikka has joined #lisp
selwyn has quit [Remote host closed the connection]
turkja has joined #lisp
_krator44 has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 268 seconds]
damke has quit [Ping timeout: 264 seconds]
funnel has joined #lisp
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<Xach>
Hmm, is there a way to have 600.0 print as 600 but 600.12345 print as 600.12?
fikka has joined #lisp
<Xach>
I can think of many ways to clean up after
<jmercouris>
minion: memo for jasom: lparallel waiting on a promise for js seems to freeze execution, what could possibly be occuring? I guess that the callback is executed on the same thread, and thus never returns since force is blocking: https://gist.github.com/6ced6e99634f2c10994753c679bacdb2
<minion>
Remembered. I'll tell jasom when he/she/it next speaks.
qjube has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
gilberth has joined #lisp
FreeBirdLjj has joined #lisp
ykoda has joined #lisp
red-dot has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<gilberth>
Hi there --- this is off topic --- but is anybody digging the Meltdown exploit? I have not seen any PoC yet, that would allow me to read^Wmeasure more than the L1 cache.
<Xach>
gilberth: this is not a good place
<gilberth>
Xach: Sorry, but I figure, that I'll find the best hackers in #lisp.
bms_ has quit [Read error: Connection reset by peer]
bms_ has joined #lisp
kenster has joined #lisp
<Xach>
gilberth: They are here to discuss common lisp
<gilberth>
Xach: Sorry again, I am pretty aware of this.
fikka has joined #lisp
jcowan has quit [Ping timeout: 260 seconds]
sebbot has quit [Ping timeout: 240 seconds]
itruslove has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 265 seconds]
giraffe has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Baggers has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
<jmercouris>
so at the conclusion of the JS execution, this callback will be invoked
<craft00>
hello, anybody know about common lisp game in irc now?
<jmercouris>
From what I can tell, the js call, and the callback appear to occur on the same thread
Karl_Dscc has joined #lisp
<jmercouris>
craft00: Like game engines or?
giraffe has joined #lisp
<craft00>
no, just a chanel
<jmercouris>
Anyways, I tried to use a promise in order to wait for the callback to be invoked, this caused my system to hang
<jmercouris>
craft00: lispgames I think is the name
<jmercouris>
Something like that
<aeth>
Yes, it's #lispgames
<craft00>
I just try to join it, but false
<jmercouris>
maybe there are two pound signs?
<aeth>
It might require registered nicks because of the recent spam attack on Freenode
<craft00>
now I need a tutorial about game programming by common lisp
<jmercouris>
craft00: That really depends on which framework/path you go
<jmercouris>
There's no de-facto lisp game engine standard
<jmercouris>
It's not like C# or something
<craft00>
something for me to begin programming games?
<aeth>
There are 3 2D and 3 3D engines/frameworks that are released to some degree, and probably just as many that are unreleased.
<craft00>
ok, bad thing
itruslove has joined #lisp
<jmercouris>
So, anyways, the issue is, webkit_web_view_run_javascript will invoke the callback, so how can I make sure it is on a new thread so that my function can complete upon the js callback?
<Xach>
craft00: in my experience, it is usually because of a http proxy or something similar.
<craft00>
and?
<Xach>
craft00: and you need to avoid or work with the proxy. do you have a proxy involved that you know of?
<craft00>
Oh no, I don't
<craft00>
So I need to connect a proxy and download again?
<Xach>
craft00: No. If you don't have a proxy, it must be something else.
<craft00>
something what?
<Xach>
Else.
<Xach>
craft00: Do you have other computers you could try it from?
<craft00>
No, I don't
<Xach>
I've been able to use it successfully myself, I am using a mac.
<craft00>
rich man
<Xach>
craft00: Where are you located? Is there a national proxy or firewall?
fikka has quit [Ping timeout: 252 seconds]
<craft00>
I'm using linux debian
<Xach>
Might there be an anti-virus program intercepting http traffic?
<craft00>
No, I don't thing so.
<Xach>
craft00: Does it happen if you try the same command again?
jcowan has quit [Remote host closed the connection]
<craft00>
something bad happend but I don't know how to fix it :(
<craft00>
I tried
<Xach>
craft00: Where are you located? Is the network relatively slow or prone to interruption?
jcowan has joined #lisp
<craft00>
8.8.8.8: icmp_seq=24933 ttl=48 time=32.1 ms 64 bytes from 8.8.8.8: icmp_seq=24934 ttl=48 time=32.2 ms 64 bytes from 8.8.8.8: icmp_seq=24935 ttl=48 time=32.1 ms 64 bytes from 8.8.8.8: icmp_seq=24936 ttl=48 time=32.1 ms 64 bytes from 8.8.8.8: icmp_seq=24937 ttl=48 time=32.1 ms 64 bytes from 8.8.8.8: icmp_seq=24938 ttl=48 time=32.3 ms 64 bytes from 8.8.8.8: icmp_seq=24939 ttl=48 time=32.0 ms 64 bytes from 8.8.8.8: icmp_seq=24940 ttl=48 t
<Xach>
That does not have much meaning
<craft00>
I don't think my network is slow
<craft00>
why not?
<Xach>
craft00: What command did you use when you got that error?
<Xach>
craft00: 8.8.8.8 is regionally routed
<craft00>
ctrl-C and try again
<Xach>
Pinging bodge.borodust.org would be more relevant
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<craft00>
root [~] ping bodge.borodust.org PING bodge.borodust.org (128.199.46.62) 56(84) bytes of data. 64 bytes from borodust.org (128.199.46.62): icmp_seq=1 ttl=49 time=1191 ms
<craft00>
well, it's slow
<craft00>
bad thing
milanj has quit [Quit: This computer has gone to sleep]
<Xach>
that could be a source of trouble.
<craft00>
any solution to fix it?
<Xach>
When I had a similar problem I paid to use a content-delivery network. But that is up to borodust.
<Xach>
I don't know what you can do on your end, sorry.
<craft00>
ok friend
<Xach>
Well, I do have one idea!
<Xach>
It is not great but it might work.
<Xach>
craft00: Do you have a ~/quicklisp/dists/org.borodust.bodge/archives/ directory?
<craft00>
yes, so?
thinkpad has quit [Quit: lawl]
<Xach>
craft00: from that directory, the following command might install everything you need
<Xach>
for f in $(awk '{print $2}' < ../releases.txt );do curl -O $f;done
<craft00>
oh dear, I understand, I will do it
fikka has joined #lisp
ckonstanski has joined #lisp
<Xach>
craft00: how is it going?
<craft00>
I trying to download it and I will install it by hand :))
<craft00>
few seconds to done
emacsoma` has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<Xach>
after those files are fetched, quicklisp should be able to operate on them as though they were downloaded with quicklisp.
orivej_ has quit [Ping timeout: 256 seconds]
megalography has quit [Ping timeout: 248 seconds]
<craft00>
I got it :))), thank to you
<craft00>
~/quicklisp/dists/org.borodust.bodge/archives/ directory thank for it
megalography has joined #lisp
FreeBird_ has joined #lisp
thinkpad has joined #lisp
knobo has joined #lisp
turkja has quit [Ping timeout: 268 seconds]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
ckonstanski has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
fikka has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
thinkpad has quit [Quit: lawl]
beach` is now known as beach
damke has quit [Ping timeout: 264 seconds]
fortitude__ has joined #lisp
bms_ has quit [Ping timeout: 248 seconds]
damke has joined #lisp
<beach>
Good morning everyone!
<jasom>
Good morning
<minion>
jasom, memo from jmercouris: lparallel waiting on a promise for js seems to freeze execution, what could possibly be occuring? I guess that the callback is executed on the same thread, and thus never returns since force is blocking: https://gist.github.com/6ced6e99634f2c10994753c679bacdb2
bms_ has joined #lisp
<jasom>
minion: memo for jmercouris: I thought I checked that we aren't on the GTK thread for my macro; did I PR an older version?
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
fortitude_ has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
OS-26949 has quit [Quit: Leaving]
schoppenhauer has quit [Ping timeout: 260 seconds]
pransninja has joined #lisp
schoppenhauer has joined #lisp
<pransninja>
It is crazy how simple lisp is yet it looks so complicated.
<beach>
Doesn't look complicated to me.
<pransninja>
before learning lisp, (map 'vector #'1+ *v*) would have looked so strange to me.
<pransninja>
come on.
<pransninja>
Does that read simple to you?
fikka has quit [Ping timeout: 240 seconds]
<bms_>
It looks weird if you don't know it, definitely.
<pransninja>
It is a simple construct, but every token requires understanding what it means in the given context.
<beach>
pransninja: That's the same thing with every language. Nothing special here.
<pransninja>
I think that is the *hard* part of lisp, it is rather contextual, in contrast to more _modern_ languages.
fortitude_ has joined #lisp
<bms_>
Well, it's really only complicated because it looks nothing like most other languages. S-exps probably scare some people off.
<beach>
Clearly, if you have studied the same family of languages for a long time and then you discover that there are languages that are different, then they look hard to begin with. Again, nothing new.
<pransninja>
No.
<pransninja>
beach: That is not the point.
<pjb>
pransninja: and map(VECTOR,add1,v); wouldn't have looked strange to you?
wxie has quit [Remote host closed the connection]
jmercouris has joined #lisp
<Bike>
', #', and ** almost always mean the same things
<Bike>
regardless of context i mean
fortitude__ has quit [Ping timeout: 240 seconds]
fortitude__ has joined #lisp
<bms_>
It depends on where you're coming from. If you started in C-style languages (like I did), map(VECTOR, add1, v); looks normal.
<Bike>
sure, but it's this complaint about context i don't get
<pjb>
Anyways, the problem with other languages is that you assume the context and meaning of what you read, and you're wrong almost all the time, without knowing it.
<jmercouris>
jasom: this isn't for your macro, it's for the js execution which I also need to synchronize
<minion>
jmercouris, memo from jasom: I thought I checked that we aren't on the GTK thread for my macro; did I PR an older version?
<Bike>
those things don't have different meanings in different contexts
<jmercouris>
jasom: I tried following your approach (at least I think I did), but couldn't get execution to not freeze
<Bike>
you have to know what MAP is going to do with them, but that's just a matter of knowing what one function does, which is a pretty common thing across programming languages
<pjb>
for example, people believe that in C a+b will add two integers. Wrong!
<jmercouris>
pjb: How so?
<pransninja>
Bike: I think lisp reuses many of the tokens in strange ways.
<pransninja>
* has so many meanings lisp.
<pjb>
if a and b are unsigned, it's a modular operation, otherwise it's unspecified when the sum cannot be held in the signed result type.
fikka has joined #lisp
<pransninja>
Where in most languages, it just *, maybe there is the ** power, and C-block comments, but * is just that.
<pransninja>
Also, - means mines.
<beach>
jmercouris: And one could be a pointer.
<pransninja>
So a-b is a minus b, but in lisp, it is not minus at all.
<Bike>
in lisp it's just a part of a token, though those tokens indeed have different conventional meanings
<jasom>
jmercouris: you will deadlock if you block on a promise that is submitted to the current thread
<pransninja>
Yes.
<Bike>
so it's not that things are different in different contexts, it's just that lisp is lexed differently than you're used to
fortitude_ has quit [Ping timeout: 248 seconds]
<jmercouris>
jasom: Right, that makes sense of course
<pransninja>
Whatever conventional or part of language makes little different that same token means different things.
<jasom>
jmercouris: easiest way to check is to just add a line that prints the name of the current thread before you block on the promise. Then when you deadlock the last name printed is what caused the issue
<jmercouris>
jasom: The issue therefore how I might get the callback to invoke on a separate thread
<pjb>
pransninja: * is a symbol, it has only few meanings: as a function it's the multiplication, as a variable, it's most recent primary result, in type specifiers, it denotes some type or dimension wild-card.
<pjb>
pransninja: what you don't belong is that *a* is not different from xax syntactically.
<Bike>
#' and ' however don't have as many meanings, and mean the same thing practically anywhere in a lisp program except in a string
<pransninja>
pjb: in variable names, as *ear-muffs* it is something else.
<jmercouris>
jasom: (print bt:thread-name)?
<pransninja>
What other language exists where * can exist in so many different ways?
<pjb>
No, it doesn't mean anything in *eaer-muffs*!
<jasom>
if you know it's issuing on the same thread, no need to do a promise
<jasom>
jmercouris: yeah
<jmercouris>
I am pretty confident that is the issue, but I guess it is best to check
<jasom>
jmercouris: probably ad a (Terpri) as well
<Bike>
pransninja: any other language that allows * as part of a token, probably. this seems like a mere convention difference than something very deep.
<pjb>
pransninja: read chapter 2.
<pransninja>
Bike: Can you give me an example?
<Bike>
of another language that has * as part of tokens?
<jmercouris>
jasom: Okay, I still need some way to block though, because even though it may be on the same thread, C is invoking the callback at some time after my function already returns
<pransninja>
pjb: I am on chapter 11, so obviously I know lisp pretty damn well ;)
<jasom>
parjanya: it's like FOO_BAR for constants in C;
<pransninja>
Bike: Can you name one?
knobo has quit [Ping timeout: 268 seconds]
<Bike>
not off the top of my head, no. that wasn't really my point, though.
<pransninja>
Also, a language where allows - in names.
<Bike>
you were phrasing your complaint as some deep property of language design but it sounds like it's coming down to using characters in ways you aren't used to.
<jmercouris>
Or rather that function
<pransninja>
Which makes lisp/scheme et al more contextual.
<Bike>
how is it "contextual"?
<jasom>
jmercouris: you can't do it blocking if you only have an async call and you are already running in the thread in which it will be run
<jasom>
jmercouris: call/cc would allow this, but it exists not in common lisp
<Bike>
in C "-" means things in different contexts, and can't be part of a token except maybe if it's in a trigraph
<Bike>
part of a symbol, rather
damke_ has joined #lisp
<pransninja>
Bike: different things, as in?
<bms_>
I think Apple's Swift might allow * in variable names. It allows emoji (who knows why?) and I don't remember * meaning anything else in Swift.
<pjb>
there are no symbols in C, only identifiers and other such tokens.
<jmercouris>
jasom: What if I were to spawn a new thread for the call and have the promise in the main thread or something?
fikka has quit [Ping timeout: 265 seconds]
FreeBird_ has quit [Remote host closed the connection]
<bms_>
Of course, I could be wrong, I never went too far with Swift.
<Bike>
in C it can be the - binary operator, the - unary operator, --, ??-
<Bike>
it's a bit confusing at first, but usually doesn't present a problem, at least speaking for myself
<pjb>
-=
<pjb>
->
<jasom>
jmercouris: there is no need to do a callback at all if you are already in the main thread, right?
<Bike>
* of course means both multiplication and dereference, which does sometimes confuse me, but i don't think this is a major flaw or anything
<pransninja>
pjb: okay, maybe you have a point.
<pransninja>
But I still feel like lisp overloads many of the tokens.
<Bike>
though the lexer hack could be considered a real flaw.
<pransninja>
but that is my impression so far anyways.
damke has quit [Ping timeout: 264 seconds]
<resttime>
It's contextual in C++ too I think as well since you can overload operators
<jmercouris>
jasom: I'm not opting for doing a callback, that's the nature of the webkit api
<pransninja>
resttime: Yes. true.
<pransninja>
I think I am over stating how contextual stuff are in lisp compared to other languages.
aindilis` has quit [Ping timeout: 256 seconds]
<pransninja>
But good lord (map 'vector #'1+ *v*) still looks weird to me. :P
<Bike>
i don't understand the "contextual" part. in lisp, outside of strings and stuff * is always part of a symbol. as it happens, * is a symbol with pretty different meanings from *v*, but that's just because they're different names. "print" and "function" mean pretty different things as well, sort of deal
<pjb>
pransninja: you can write it as: (map (quote vector) (function add1) v)
<beach>
pransninja: Yes, we get it. Just don't imagine this is an objective observation. It is all relative to what you already know.
<jmercouris>
Am I making sense or is this not possible?
<aeth>
pransninja: *v* is supposed to look weird to you. You shouldn't use *...*s unless you have a good reason, which is why they stand out
fikka has joined #lisp
<aeth>
1+ is perfectly natural. 1- is... unfortunate. (1- x) looks like (1 - x) but is really (x - 1)
<loli>
isn't *..* because the variables are dynamic
<loli>
and thus denote they have special scoping
<pransninja>
aeth: I thought globals were meant to have earmuffs?
<aeth>
inc and dec probably would have been more natural than 1+ and 1-, and would have had parallels in incf and decf
<jasom>
jmercouris: there's no point to the (force promise) at the end
<aeth>
pransninja: dynamically scoped globals
<pransninja>
so defvars?
<aeth>
and defparameter
<pransninja>
cool beans
<pransninja>
back to reading I go
<pransninja>
you guys are a good bunch.
<jasom>
jmercouris: you have to force the promise on a new thread, and if you are, then it's no longer synchronouse
<aeth>
Implementations can have lexically scoped globals, they're just not portable
<jmercouris>
jasom: In the example I gave, web-view-execute will return BEFORE the callback is invoked
<aeth>
And you can have local dynamically scoped things, they're just not useful unless you're overriding a global, e.g. you can do this: (let ((*standard-output* some-stream)) ...)
<pransninja>
Note: guys was used in a general sense and I do not condone the exclusion of people based on gender or other kind of identity.
<pransninja>
lel.
<aeth>
The point of these variables are so you don't need to pass streams all the way down the call stack to where you actually print
<aeth>
And you can just use format t or whatever if you rebind *standard-output*
<jmercouris>
jasom: At least I believe it to be so
<aeth>
(At least, as long as you stay wtihin a thread. Threads make them complicated.)
<jmercouris>
jasom: Is there no way that I may get the return value of the callback within web-view-execute?
<jasom>
jmercouris: it *must* return before the callback is invoked *if* you are in the thread in which it will be invoked
<jasom>
if you can manage to not ever call web-view-execute from the thread in which the callback will execute then you can make it blocking
<jmercouris>
jasom: Ok, let me verify that assumption first, one moment please
<jmercouris>
jasom: I'm afraid if I change the context of that call, then the callback will also execute in that new thread
<jmercouris>
which is why I wanted a macro like (execute-in-new-thread) or something where I could do the webkit-web-view-run-javascript call
fikka has quit [Ping timeout: 263 seconds]
<jasom>
jmercouris: the callback can only be scheduled in a thread that is running an event loop for webkit
jpx__ is now known as jpxe
<jasom>
jmercouris: there's no magic here
<pransninja>
What is the difference between Vectors and Lists? #() vs '()?
<jasom>
pransninja: one is a linked list, the other is a vector
<loli>
they are different data structures
<jasom>
pransninja: as in the CS 101 definition of those two terms
<pransninja>
lists are linked list?
<jasom>
pransninja: yes
<loli>
yes
<Bike>
the links are cons cells.
<pransninja>
righto.
<jmercouris>
pransninja: They don't have to be, but in the context of lisp, yes
<pransninja>
So very expensive to walk through compared to vectors?
<loli>
arbitrary access is expensive, not walking through
<jmercouris>
pransninja: Not necessarily, a linked list may have a data structure on top like a skip list, or something
<pransninja>
jasom: CS 101 covers vectors and lists in a language agnostic way? ;)
<loli>
lists are very easy to deconstruct
<Bike>
linear rather than constant time random access.
<Bike>
pransninja: well, hopefully
<jmercouris>
pransninja: Or it could be an arraylist
<jasom>
pransninja: walking them is identical asymptotically, random access is slow on lists
<loli>
arraylists are really just extensible arrays
<jmercouris>
loli: mostly
<Bike>
the implementation putting something on top of basic lists in lisp is unlikely, because it does have to be possible to access them as a bunch of conses
<jasom>
pransninja: fair enough, I think that was a 200 level class
* jasom
is old so college just feels like all the same year now
<aeth>
There is one additional thing about vectors vs. lists. Lists contain elements of type T. Arrays can be specialized to contain elements of one type (usually numeric, with the exception of characters, and implementation-specific with the exception of bits and characters)
<pransninja>
jasom: ;) I think while vector is expected to be sequential, list can be other than linked list, in general cs sense.
<loli>
it's a shame I can't type the elements of my lists in CL
<aeth>
(a vector in CL is just a 1D array)
<jasom>
pransninja: right, which is why I specifically said "linked list"
nika has joined #lisp
<pransninja>
righto
<pransninja>
So stick with vector unless you need list?
<pransninja>
or the other way around?
<loli>
use what is natural for the algorithm
<pransninja>
or if you need random access, vector, otherwise list?
<jasom>
pransninja: if you want to share structure, add to the beginning and don't need random access, list. Otherwise vector
<pransninja>
loli: Some thumb rules help the mere mortal.
<loli>
I tend to use structs, and lists mostly as I adhere to the functional style
<jasom>
pransninja: also lisp has easy destructuring of lists builtin. apply, destructurig-bind &c.
<aeth>
loli: You can type them, with structs! Just create a new cons element whose car contains something of a given type and whose cdr must be (or null your-new-cons-type). Unfortunately, I tested this in CCL, ECL, and SBCL, and this only works perfectly on SBCL. For the other two, one doesn't type check in the constructor and the other doesn't type check on access (I forget which)
<loli>
that's a shame
<loli>
I'll keep that in mind
<aeth>
If you do some implementation-specific workarounds for ECL and CCL, you can get it working everywhere.
<loli>
when I make adt's I really want to type my lists
Oladon has joined #lisp
<jasom>
pransninja: one of the reason for using functional types in clojure was to allow what lisp traditionally does with lists to work on other datatypes
sebbot has quit [Ping timeout: 248 seconds]
<pransninja>
aeth: That is more or less how PHP implements it's infamous bucket of everything arrays.
<pransninja>
Though, in C, obviously.
<jasom>
loli: yeah, the lack of recursive algebraic types in lisp is a real limitation. It's easy to see that this falls out of the fact that lisp is untyped; you can't efficiently check the type of (CONS X Y) for recursive types unless you already strongly know the value of Y, but as lisp is untyped you can't strongly know the type of Y
JenElizabeth has quit [Remote host closed the connection]
<loli>
aeth: I might be able to try a work around some time for this, the only issue is that I don't get reduce or mapcar from it
<loli>
jasom: I found a nice work around
JenElizabeth has joined #lisp
<loli>
I use deftype, with many structs and an ending symbol
<loli>
I can write defmethods for all of them
<aeth>
(Btw, by everywhere I do mean everywhere, btw, not just ECL and CCL, since combined they fail in every possible way I can think of, so you'd just need to keep a list of where a given implementation fails.)
<loli>
yes and you can do #+ to fix it
<loli>
if you find a fix for every way it is borken
<loli>
broken*
<jmercouris>
jasom: they are indeed on the same thread
<loli>
jasom: I might make a macro that automatically generates an ADT. It wouldn't be hard
<aeth>
Right, so you make the constructor name %make-foo in implementations where the type-checking in the constructor is broken and for those implementations only define an inline make-foo that calls %make-foo after type checking.
<loli>
and have it's own special little defmethod
<aeth>
And you can do something similar for the accessors.
<pransninja>
How do you properly indent (map 'vector #'(lambda which I want to be multi line) *v*)
<pransninja>
Does the *v*) go in it's own line?
<jasom>
pransninja: yes
<aeth>
pransninja: each thing should go on its own line
<loli>
the statement is short enough that I put it on one line, if the lambda gets big 1 line for each argument
<jasom>
pransninja: anything that would be indented lower than the current line should get a newline
<loli>
I keep the first argument with the function name
<pransninja>
So a line for 'vector too?
<jasom>
pransninja: with the exception of ) of course
<pransninja>
and not have it next to map?
<pransninja>
jasom: of course. :0
<pransninja>
:)*
<jasom>
pransninja: that's more a style question
<pransninja>
righto.
<pransninja>
Is there a paste that you guys prefer?
<jasom>
pransninja: I've seen that both ways.
<pransninja>
online paste, that is.
<jasom>
pransninja: the former official paste got spammed to death, so whatever now. gist will syntax highlight lisp, so it's what I use, but anything is fine
<pransninja>
jasom: I want to know what happened, haha.
fikka has joined #lisp
<aeth>
pransninja: The capcha was weak, it was just a 4-5 digit number
<pransninja>
"Due to continued abuse, this service has been disabled" what is the story?
<pransninja>
oh
<pransninja>
that should be easy to fix?
<jasom>
pransninja: 1000s of spam pastes per day. The maintainer no longer used it
<Bike>
if you have suggestions, you can give them in what was it, #common-lisp.net?
<aeth>
pransninja: There are *many* ways to fix it. The maintainer is just not interested in fixing it, I guess
<pransninja>
maybe I can do this as a pet project.
<pransninja>
will the let me use the subdomain?
<jmercouris>
pransninja: Let's not get ahead of ourselves here
<pransninja>
Who manages lisp.org?
aindilis has joined #lisp
<pransninja>
I have some ideas, I could try compiling sbcl to asm.js and run it on the browser.
<aeth>
The home page has just been a tribute to McCarthy since 2011. https://lisp.org/
<pransninja>
Ka bom! magical lisp paste.
<aeth>
pransninja: asm.js is no longer recommended, web assembly is the new way forward
<aeth>
iirc, web assembly does not yet support GCed languages, but it's on the roadmap
<aeth>
Clasp (for LLVM), ECL (maybe?), and ABCL (there is a JVM->WASM effort) should be the easiest to port, not SBCL
<pransninja>
You know John MacCarthy's eyebrows reminds me of Oscar Wilde's "Life imitates Art far more than Art imitates Life".
<pransninja>
PS. I have very similar eyebrows, so I get to make a joke.
<pransninja>
aeth: I know llvm has been ported, so probably clasp is the way to go then.
<aeth>
My guess is that Clasp and ABCL should be the easiest, followed by ECL.
smasta has joined #lisp
<pransninja>
That is a solid guess, I think.
fikka has quit [Ping timeout: 240 seconds]
<pransninja>
pretty sure I saw an llvm port somewhere.
<rme>
I have every confidence that web assembly will end up being a mostly-unsuitable target for a Common Lisp compiler.
<jasom>
pransninja: floor/round/truncate all return multiple values
<aeth>
In addition, multiple values are pretty useful
<pransninja>
I see
<rme>
That makes imperative loops in Clojure look kind of strange (they have to use the recur form). But Clojure people will just say that you are loser if you write an imperative loop, anyway. :-)
<pransninja>
they sure damn are
<aeth>
I use multiple values to write pure functions for mathematical vectors of sizes 3 and 4
<aeth>
Vectors would otherwise either have to cons or modify
<loli>
does clojure have an imperative loop, their loop is really recursion
fikka has joined #lisp
<jmercouris>
jasom: is there no way around this problem?
<jmercouris>
jasom: I can't think of anything
<loli>
it shuns imperative solutions due to being functional
<jasom>
jmercouris: it's bad design to require an asynchronous call from the thread that is going to do what you want. I can't think of away around, other than moving all of your code out of that thread
<pransninja>
loli: If they don't have tail call elimination, recursion for loop sounds like trouble.
<pransninja>
as rme said.
<jmercouris>
jasom: But it is not my design :(
<loli>
parjanya: they can simulate loops
<jasom>
jmercouris: I know
<loli>
for example Let over lambda puts TCO in CL through a macro with gotos
<loli>
it should be considered reucrsion, just the user doing the compilers job
<jasom>
they don't use recursion for loops in clojure their loop is not recursion
<pransninja>
Yeah, I hope so.
<loli>
it is not a form of recursion?
JenElizabeth has quit [Ping timeout: 265 seconds]
<jasom>
loli: it sort of is, but it's an explicit loop construct
<pransninja>
Because without tail call elimination, how do you even loop with recursion?
<loli>
pransninja: you bake it in with gotos, it's what compilers do for languages with TCO
<loli>
lambda the ultimate goto talks about that
aindilis has quit [Remote host closed the connection]
<pransninja>
loli: sauce?
<jasom>
(loop BINDINGS ... (recur new binding values)) <-- it looks like that
<loli>
this is the let over lambda code for the Tail call in CL
<jasom>
pransninja: all tail-calls in scheme are guaranteed to not grow the stack
aindilis has joined #lisp
<jasom>
pransninja: most compiled tail calls in most CL implementations with high optimization values will also not grow the stack.
<jasom>
pransninja: even GCC won't allocate a new stack frame for a tail call on high optimization levels
<pransninja>
So it becomes a loop? ;)
<pransninja>
I know that is binding the rules, but how do you define recursion vs iteration?
<jasom>
pransninja: it's arbitrary control transfer; it's only a loop if it's a recursive tail call
<pransninja>
at least, in general sense?
<jasom>
pransninja: recursive is self-referential
<pransninja>
Hmmm.
<pransninja>
loli: I will read through! and try to understand it.
<jasom>
pransninja: If the result of F is defined in terms of F (including using functions that might be defined in terms of F) then it is recursive
<jasom>
this is why I think clojure's loop is not recursive; there is no defined in terms of self, it's rather an explicit "do another iteration"
<loli>
jasom: would you consider fold a looping mechnism instead of recursion?
<jasom>
but it's a well known theorum that one can always transform a loop into a tail-recursive form
<jasom>
loli: inasmuch as HoF are either, map/fold &c. I would call looping
FreeBirdLjj has quit [Remote host closed the connection]
<rme>
I look at it as a question of notation.
<rme>
When the computational process runs in constant space, that's iterative.
<jasom>
loli: obviously they could be defined either way.
<loli>
yes I choose to view them as recursion due to no mutation
<loli>
that's where I tend to place the term looping
<pjb>
loli: if you have a defective keyboard, it's easy enough to get a good one and change it.
<pjb>
loli: so now you may be able to type your list elements.
<loli>
thank you pjb
<loli>
that would solve that problem
<rme>
Whether that process is notated using tagbody and go or as a tail-recursive function call makes no difference.
<pjb>
loli: I would advise a Das Keyboard, but there are cheaper options.
<jasom>
loli: (loop repeat 5 collect 'a) ; <-- no mutation there; is it recursive?
<loli>
does "loop" not mutate things as it does this computation?
<loli>
let me see the expansion
<pjb>
loli: unspecified.
<jasom>
loli: that's up to the implementation
<loli>
it can ve either then
<loli>
can be either*
<pjb>
You cannot rely on one expansion, another implementation may do it otherwise.
<jasom>
loli: let's look at the disassembly of a tail-call in haskell and see if it mutates registers :)
<pjb>
or the RAM!
<loli>
I'm sure it does
<loli>
haha
<jasom>
loli: therefor it's not recursive!
<pjb>
unless you have a lambda calculus processor.
<loli>
ahh but jasom, nothing is recursive
sebbot has joined #lisp
<loli>
so just put a not infront of my statements
<loli>
and it's all fine
<jasom>
any definition that relies on what the implementation does is not useful for discussing recursion vs iteration. A compiler is free to transform a tail-recursive function to a loop or not (in most languages) and that ought not change if it's considered recursive
<loli>
also jasom you forgot one thing, you don't tail call in Haskell
<loli>
you let laziness take you away
<jmercouris>
jasom: I do not think there is literally any way around this, and if there is, I cannot think of i
<jmercouris>
think of it*
<jasom>
jmercouris: what code will actually need the result?
<jmercouris>
jasom: Anythink can call web-view-execute to get the JS result
<jmercouris>
jasom: For example, in link-hints, it gets an array of links, and associated hints that it uses
<jasom>
jmercouris: hmmm
<jasom>
jmercouris: you may have to change web-view-execute to CPS style
<pransninja>
jasom: So that means that the discussion of stack in the context of recursion vs iteration is out of scope?
<jmercouris>
jasom: I might, but how will that work within the synchronous cocoa context?
<jasom>
pransninja: In my opinion, yes
<jasom>
jmercouris: just call the callback immediately
<pransninja>
jasom: Fair point, considering that most languages let the compiler do whatever it fancies.
<jmercouris>
jasom: Feels so wrong, there must be a way
<jasom>
pransninja: scheme and python are the two that immediately come to mind for having requirements
<jasom>
jmercouris: what happens if the javascript has a delay in it? The whole thread hangs for that time?
<jasom>
jmercouris: surely cocoa has an asynchronous interface?
<pransninja>
jasom: for low level details of implementing recursion and iteration?
<jmercouris>
jasom: the newest one, but since ffigen is broken I am using a quite old api
<jasom>
pransninja: yes
<rme>
However, the whole point of fussing over "proper tail recursion" is that it is safe for space.
<jasom>
jmercouris: *sigh* the world is truely an imperfect place
<pransninja>
jasom: interesting.
<jasom>
pransninja: scheme requires all tail-calls to consume zero extra space. Python reuires all calls to allocate a stack frame.
<jmercouris>
jasom: Seems like I will have to do CPS
<pransninja>
jasom: to what end goal? specially the Python's requirement?
<jmercouris>
I'll probably introduce some macro like (with-java-script-result (script) (...forms))
<jasom>
pransninja: the BDFL thinks it hinders debuggability
fikka has joined #lisp
<pransninja>
jasom: How is it different than debugging a simple goto loop?
<loli>
taking away stack frames is something he doesn't want to do
<pransninja>
Or is that where the BDFL aspect comes into question ;)
<jasom>
pransninja: that's where the BDFL aspect comes in, though you can find his reasonings on the mailing list I'm sure
<pransninja>
I like the discussions of language design very interesting.
<pransninja>
It is interesting because there is so much opinions in what ought to be mostly objective.
<rme>
I've worked with a client who wanted ccl never to do tail calls for debugging reasons.
<loli>
rme: but what about debug 3?
<pransninja>
But then again, it is design, and that says a lot about the opinions aspect.
<loli>
doesn't that just remove TCO?
<rme>
They wanted it as standard optimize settings.
* jasom
thought ccl had lots of optimization tunables
<jasom>
or am I thinking of sbcl?
<loli>
huh, that's rather strange
<Bike>
"I want to tune how things are optimized, but without actually touching the dials"?
fortitude__ is now known as fortitude_
<rme>
There's a thing called a compiler policy in ccl that lets you tweak stuff like that on a more fine-grained basis.
<rme>
Clients. Can't live with 'em, can't live without 'em.
<pransninja>
Is SBCL hastables O(1)?
<loli>
huh, did that effect your solutions much
<loli>
yes pransninja
fikka has quit [Ping timeout: 265 seconds]
<loli>
I assume you mean for lookup
<pransninja>
So a real hash table. :)
<pransninja>
Yes.
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
sebbot has quit [Ping timeout: 256 seconds]
<rme>
For small amounts of data, though, searching an alist or a plist might be faster than a hash table lookup.
<rme>
It's interesting how CL exposes these performance trade-offs.
<pransninja>
Is the only way to call '(format t "much wow") is to eval it?
<Bike>
you mean like you have a function that receives that list?
nika has quit []
<pransninja>
rme: I will read about them, currently playing around with hashmaps, and true to most other things, I like how it gives you perf trade-offs with different :test funcs.
<pransninja>
Bike: As in, I save that on a variable and later execute it.
<Bike>
that's what eval does, sure. but whether you HAVE to use eval depends on what other forms you want to allow
<pransninja>
say I have (defvar wow '(format t "wow"))
<loli>
for example you can stick it in a macro
<loli>
and no funcall would be needed
<pransninja>
and now the time has come to say print wow.
<Bike>
what i'm saying is, if you have (defvar wow '(let ((x "wow")) (format t x))), does that have to work as well?
<loli>
(macrolet ((te () '(format t "wow"))) (te))
<pransninja>
Yes, so not really looking for macros.
<Bike>
so, yes, if you want to evaluate an arbitrary expression you have to evaluate it, basically.
<pransninja>
I am looking into the eval business right now
<Bike>
though i'd caution against designing your system in this way.
<pransninja>
so want to see how else you can execute what eval does.
<loli>
eval should be used very sparingly
<pransninja>
Just a learning exercise in eval, not being evil with my code, just yet anyways ;)
<Bike>
(eval x) is mostly equivalent to (funcall (compile nil `(lambda () ,x))), for one
<pransninja>
Ah.
<Bike>
you could also write your own eval in terms of apply and such.
<pransninja>
that is cool.
<pransninja>
So the lisp runtime comes with a lisp compiler?
<Bike>
yes (some commercial implementations allow or require the compiler to be removed in deployed applications)
<jcowan>
Haskell and Scala both allow * (or any symbol or punc mark) in the name of an operator
<pransninja>
jcowan: Too late to the party, I am afraid. ;P
fikka has joined #lisp
sebbot has joined #lisp
jmercouris has quit [Ping timeout: 265 seconds]
fikka has quit [Ping timeout: 264 seconds]
Bike has quit [Quit: Lost terminal]
randomstrangerb has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
emacsoma` has quit [Ping timeout: 265 seconds]
randomstrangerb has joined #lisp
pransninja has quit [Quit: Page closed]
FreeBirdLjj has quit [Ping timeout: 246 seconds]
safe has joined #lisp
Oladon has quit [Quit: Leaving.]
<aeth>
Any language that separates things with whitespace should permit just about anything
<aeth>
You don't need s-expressions to write foo-bar, you just need to require "4 - 5" instead of "4-5"
fikka has joined #lisp
sebbot has quit [Quit: Lost terminal]
fikka has quit [Ping timeout: 248 seconds]
_krator44 has quit [Ping timeout: 255 seconds]
asarch has quit [Quit: Leaving]
orivej has quit [Ping timeout: 252 seconds]
_krator44 has joined #lisp
<jasom>
did pransninja leave? I was going to suggest a lambda in teh defvar; that's the obvious solution
orivej has joined #lisp
krwq has joined #lisp
patche has joined #lisp
patche is now known as sebbot
<krwq>
hello, is there an easy way to write defmethod which would do something like (defmethod foo ((arg (eql (or :a :b)))) ...)?
<beach>
krwq: Just create an auxiliary function with the body, and call it from two methods.
groovy2shoes has quit [Ping timeout: 252 seconds]
safe has quit [Read error: Connection reset by peer]
<krwq>
beach: that's what I did but was wondering if there was some syntax for that already
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
turkja has joined #lisp
fikka has joined #lisp
yeticry has quit [Ping timeout: 260 seconds]
yeticry has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
eazar001 has quit [Quit: WeeChat 2.0.1]
rippa has joined #lisp
fikka has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 265 seconds]
attila_lendvai has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
attila_lendvai has quit [Client Quit]
fikka has joined #lisp
Oddity has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 268 seconds]
randomstrangerb has quit [Ping timeout: 248 seconds]
DeadTrickster has quit [Remote host closed the connection]
randomstrangerb has joined #lisp
Oddity has joined #lisp
Oddity has quit [Changing host]
Oddity has joined #lisp
conceivably has quit [Remote host closed the connection]
DeadTrickster has joined #lisp
moei has quit [Quit: Leaving...]
lnxm8 has joined #lisp
_krator44 has quit [Quit: --]
randomstrangerb has quit [Ping timeout: 268 seconds]
randomstrangerb has joined #lisp
bms_ has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<phoe>
krwq: not in vanilla CLOS.
fikka has quit [Ping timeout: 248 seconds]
<phoe>
AFAIK (or :a :b) up there will evaluate to :a since it's a normal Lisp form.
arbv has quit [Ping timeout: 248 seconds]
damke has joined #lisp
damke__ has joined #lisp
orivej has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
kenster has quit [Remote host closed the connection]
damke has quit [Ping timeout: 264 seconds]
lnxm8 has left #lisp [#lisp]
fikka has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
damke has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
damke__ has quit [Ping timeout: 264 seconds]
fortitude_ has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
smasta has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 265 seconds]
logicmoo has joined #lisp
dmiles has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
_krator44 has joined #lisp
fikka has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
damke has quit [Ping timeout: 264 seconds]
igemnace has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
krwq has quit [Remote host closed the connection]
versatile has joined #lisp
damke_ has joined #lisp
damke has quit [Read error: Connection reset by peer]
LocaMocha is now known as Sauvin
moei has joined #lisp
fikka has joined #lisp
orivej has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 248 seconds]
knobo has joined #lisp
mishoo_ has joined #lisp
knobo has quit [Client Quit]
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
igemnace has quit [Quit: WeeChat 2.0.1]
fikka has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
hexfive has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
damke has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
narendraj9 has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
damke has joined #lisp
fikka has joined #lisp
damke has quit [Ping timeout: 264 seconds]
quazimodo has quit [Ping timeout: 248 seconds]
pilfink has joined #lisp
craft00 has joined #lisp
hexfive has quit [Quit: re-evaluating their poor programming decisions]
damke_ has joined #lisp
resttime has quit [Quit: Leaving]
makomo has joined #lisp
arbv has joined #lisp
craft00 has quit [Ping timeout: 260 seconds]
Karl_Dscc has joined #lisp
orivej has joined #lisp
nowhereman_ has joined #lisp
nowhere_man has quit [Read error: Connection reset by peer]
Ellusionist has joined #lisp
arbv has quit [Ping timeout: 248 seconds]
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
fikka has joined #lisp
damke has quit [Ping timeout: 246 seconds]
myrkraverk has quit [Remote host closed the connection]
Ellusionist has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
arbv has joined #lisp
sebbot has quit [Quit: Lost terminal]
nowhereman_ has quit [Ping timeout: 240 seconds]
nowhereman_ has joined #lisp
fikka has joined #lisp
dddddd has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
Karl_Dscc has quit [Remote host closed the connection]
qjube has joined #lisp
varjagg has joined #lisp
Ellusionist has joined #lisp
shifty has joined #lisp
pilfink has quit [Ping timeout: 260 seconds]
craft00 has joined #lisp
craft00 has quit [Client Quit]
orivej has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
random-nick has joined #lisp
beach` has joined #lisp
milanj has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
beach has quit [Ping timeout: 252 seconds]
narendraj9 has quit [Remote host closed the connection]
quazimodo has joined #lisp
EvW has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
scymtym has quit [Ping timeout: 276 seconds]
milanj_ has joined #lisp
milanj has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
damke_ has joined #lisp
fluke` has joined #lisp
Karl_Dscc has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
qjube has quit [Quit: qjube]
scymtym has joined #lisp
Jen has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
prometheus_falli has quit [Remote host closed the connection]
Ellusionist has quit [Ping timeout: 248 seconds]
gravicappa has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
SuperJen has quit [Ping timeout: 264 seconds]
fluke` has quit [Remote host closed the connection]
fluke` has joined #lisp
fikka has joined #lisp
wg1024 has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
red-dot has joined #lisp
fluke` has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 265 seconds]
fluke` has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
wg1024 has quit [Quit: Leaving.]
random-nick has quit [Remote host closed the connection]
fluke` has quit [Remote host closed the connection]
random-nick has joined #lisp
fluke` has joined #lisp
markong has joined #lisp
versatile has quit [Quit: WeeChat 1.4]
quazimodo has joined #lisp
<dim>
Happy New Year lispers!
<Shinmera>
Wish I could say it was
<easye>
Shinmera: is at any more unhappier than 2017 was?
<Shinmera>
Kinda early to say that, don't you think?
<easye>
Well, human history is pretty miserable in the first place. So, I have low expectations...
<easye>
There's ELS 2018 to look forward to.
fikka has joined #lisp
<kolb>
Human history is the main reason why pessimism is foolish
<kolb>
You want to contract sickness 100 years ago?
fikka has quit [Ping timeout: 265 seconds]
<kolb>
Happy new year:-)
<easye>
kolb: Same to you!
milanj_ has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
orivej has joined #lisp
<kolb>
My predictions for ELS 2018: lots of missed talks but many cool drinks at the beach
fluke` has quit [Read error: Connection reset by peer]
fluke` has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
* easye
is looking forward to chats. Especially to share experiences with using CL to make tooling to deal with the mess that is known as "crypto-currencies".
* jackdaniel
is looking forward to make a photo on a beach with beach` sharing a jackdaniel's drink :p
<phoe>
sipping jackdaniel while laying on a beach?
<kolb>
LOL
<phoe>
this sounds horribly wrong and horribly lispy at the same time
<phoe>
ELS'18 is indeed going to be fun
<kolb>
I have to be there
makomo has quit [Ping timeout: 240 seconds]
<kolb>
Which poor soul has to deal with crypto currencies? (I really only know from bitcoin in meatspace by friends... procuring things.)
<kolb>
I figured it was mostly a hype for gamblers other than that
* easye
is dealing with crypto-currencies.
fikka has joined #lisp
<kolb>
easye: with ABCL? at the edge of invention I see :-)
<easye>
I really don't know the endgame, but what happening with Bitcoin, Ethereum, Sia, and others makes this period of experimentation with store of value and smart contracts mediated by decentralized trust systems as important as the 1993-1995 (NSF commercializing the "internet"
<easye>
Usually these days I develop with CCL. I use ABCL wihen I need to bridge to Java ecosystem, which is mainly to get access to OWL2-capable reasoners and cheap SPARQL endpoints.
fikka has quit [Ping timeout: 264 seconds]
nirved has joined #lisp
<kolb>
gogo CCL :-)
TCZ has joined #lisp
<kolb>
easye: I heard that bitcoin mining draws more power than some nation states nowadays, how do you feel about that?
<easye>
Warmer?
<kolb>
:-)
* easye
cries for the loss of entropy.
<easye>
But since we are barely a type I Kardashev, there is a lot of other waste I would think we should get mad at. Not much we can do until we build a partial Dyson mesh.
<easye>
The precursor to a sphere. A bunch of solar arrays, the scaffolding for a sphere. (I just made this up).
<kolb>
ah yeah just found the article for dyson sphere. so may I ask what it is you are doing in particular with cryptographic currencies?
TCZ has quit [Quit: Leaving]
<easye>
Right now I am preparing to issue and disburse ERC-20 tokens for <https://etch.work> while modeling how to securitize payrolls streams via smart contracts.
<kolb>
sci-fi dystopia writes itself :D
shifty has quit [Ping timeout: 252 seconds]
<easye>
kolb: thanks for the Stross link to the talk at 34C3.
_krator44 has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
varjagg has quit [Ping timeout: 265 seconds]
lnostdal has quit [Excess Flood]
wxie has quit [Quit: Bye.]
lnostdal has joined #lisp
<kolb>
so a dyson sphere/mesh would darken the sun and we’d heat and vitamin d-bask artificially?^^
<kolb>
vampires will be happy
fikka has quit [Ping timeout: 252 seconds]
<easye>
Naw, we'd put the Dyson sphere at least around Saturn.
<easye>
I like the sun.
<easye>
Anyways, this ain't very CL related, so I will share the hope that CL will still be running in some form when we start building such structures as a species. Of course, I hope we have standardized a few things since 1993...
thinkpad has joined #lisp
<easye>
But now is the time to experiment with what will be standard in 10, 100 years.
xantoz has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
<pjb>
kolb: one can live a long time on grilled sardines, so you could just throw away your return ticket and stay on Marbella's beaches for ever.
orivej has quit [Ping timeout: 276 seconds]
<pjb>
kolb: vitamine D wouldn't be an issue anymore once you live on a dyson sphere.
thinkpad has quit [Quit: lawl]
mishoo__ has joined #lisp
* easye
envisions a technomadic Lisp beach-bum fellowship.
<kolb>
count me out I like my hills and meadows
mishoo_ has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
<easye>
I would keep the Earth as it is, as well as all the terrestial bodies. If we build a mesh that we can "shutter" dynamically, we can keep the Sun shining on the Earth. Isn't the point of the Dyson sphere to harvest the energy of that huge local fusion reactor?
<easye>
While I guess there are those who envision the inside of a Dyson sphere at 1 AU as a huge "inverted Earth", I think that would be way too many people to be around. Personally, I'd rather make a Ringworld at, say, 1.3 AU.
<borodust>
is there autoresponse bot around?
<easye>
minion: help
<minion>
There are multiple help modules. Try ``/msg minion help kind'', where kind is one of: "lookups", "helping others", "adding terms", "aliasing terms", "forgetting", "memos", "avoiding memos", "nicknames", "goodies", "eliza", "advice", "apropos", "acronyms".
<phoe>
" These macros allow the conditional execution of a body of forms in a clause that is selected by matching the test-key on the basis of its identity."
fikka has joined #lisp
<phoe>
"...of its identity." - this implies EQ.
<phoe>
And henceforth might be a bug in the specification.
Jen has quit [Remote host closed the connection]
<Shinmera>
"identity" is not specified. "identical" is, but it doesn't use that word.
Jen has joined #lisp
<mfiano>
I think the fact that it also says unless a specific test is written, it is assumed to be EQL, so it covers its mistake :)
fikka has quit [Ping timeout: 248 seconds]
quazimodo has quit [Ping timeout: 248 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
ikopico has quit [Quit: ZNC 1.6.4+deb1 - http://znc.in]
jfb4 has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
jfb4 has joined #lisp
EvW1 has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
damke has joined #lisp
red-dot has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
mishoo_ has joined #lisp
mishoo__ has quit [Ping timeout: 265 seconds]
Murii has joined #lisp
fikka has joined #lisp
damke_ has joined #lisp
Ellusionist has quit [Ping timeout: 268 seconds]
ikopico has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
fikka has joined #lisp
ikopico has quit [Quit: ZNC 1.6.4+deb1 - http://znc.in]
ikopico has joined #lisp
ikopico has quit [Client Quit]
ikopico has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 256 seconds]
damke has joined #lisp
_krator44 has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
wol has joined #lisp
ikopico has quit [Quit: ZNC 1.6.4+deb1 - http://znc.in]
ikopico has joined #lisp
ikopico has quit [Client Quit]
ikopico has joined #lisp
heurist`_ has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
ryanbw has joined #lisp
ikopico has quit [Client Quit]
ckonstanski has joined #lisp
sellout- has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
ikopico has joined #lisp
fikka has joined #lisp
ckonstanski has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
bms_ has joined #lisp
EvW1 has quit [Ping timeout: 255 seconds]
sellout- has quit [Quit: Leaving.]
fikka has joined #lisp
ikopico has quit [Quit: ZNC 1.6.4+deb1 - http://znc.in]
ikopico has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
SaganMan has quit [Quit: laters]
red-dot has joined #lisp
fikka has joined #lisp
heurist`_ has joined #lisp
orivej has joined #lisp
turkja has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 264 seconds]
jfb4 has quit [Ping timeout: 248 seconds]
jfb4 has joined #lisp
asarch has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
ryanbw has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
Arcaelyx has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
EvW has joined #lisp
ryanbw has joined #lisp
Ellusionist has joined #lisp
xantoz has quit [Read error: Connection reset by peer]
xantoz has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
mn3m has joined #lisp
Ellusionist has quit [Ping timeout: 260 seconds]
makomo has quit [Ping timeout: 248 seconds]
shka has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<peterpp>
how can I check in a function definition if what the user passed is a place?
<Shinmera>
Functions don't deal with places.
<peterpp>
oh they don't?
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<peterpp>
I guess I have some misconceptions here
<Shinmera>
A form is a place if: it returns a value when evaluated, and it can be used as a SETF place expression.
red-dot has joined #lisp
<Shinmera>
A "place" is thus a question of SETF machinery.
<Shinmera>
When a function receives an expression it cannot use it as a place, because the expression needs to be available at compile time for SETF to be able to interpret it as one.
<Shinmera>
peterpp: What exactly are you trying to do?
<peterpp>
I'm just going through 'ansi common lisp'
<peterpp>
and it was a question that popped up in my mind while doing the exercises
<peterpp>
thanks for enlightening me
<Shinmera>
What you can do is use get-setf-expansion to get what SETF would use in its expansion
openthesky has joined #lisp
<Shinmera>
Note however that what you get there will not tell you whether the expression is necessarily usable as a place, as there's a default expansion that is returned for expressions not handled through define-setf-expansion
Ellusionist has joined #lisp
<Shinmera>
Either way, the point is that a "place" is more a concept than a tangible, concrete thing.
fikka has joined #lisp
<phoe>
in other words, CL doesn not have first-class places.
fikka has quit [Ping timeout: 252 seconds]
<Shinmera>
It gets a bit washy because with some trickery (possibly implementation-dependent) you can determine whether an expression is usable as a setf place.
Karl_Dscc has joined #lisp
josemanuel has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
gravicappa has quit [Ping timeout: 264 seconds]
Jarwin has joined #lisp
Jarwin is now known as Jarwin
fikka has joined #lisp
<pjb>
peterpp: a function can take as argument a closure that accesses the place.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
<jcowan>
Yes, places are one of the fairly small number of things in CL that are second-class (other things being macros, tagbody tags, and a few others)
Ven`` has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
<Shinmera>
types
Ven`` has joined #lisp
<phoe>
Shinmera: types are first class in Lisp
<phoe>
which surprisingly doesn't prevent from being second class at the same time
varjagg has quit [Ping timeout: 260 seconds]
<pjb>
jcowan: macros are first class: (funcall (macro-function 'cond) '(cond (x nil) (t t)) nil) #| --> (if x (progn nil) (cond (t t))) |#
shifty has joined #lisp
<phoe>
^
<phoe>
also what do you mean by tagbody tags not being first class?
<Shinmera>
phoe: They're not first class in the sense that they don't have a distinct type of their own.
<phoe>
ooooh, right.
<jcowan>
pjb: I would rather say that it is possible to coerce a macro to a first-class type
<pjb>
this is not required for first classness.
<phoe>
macros don't have this either now that I think of it.
<phoe>
jcowan: what first-class operations do macros *not* support?
<pjb>
As soon as something can be bound to a variable, basically, it's first class.
<pjb>
(tagbody (let ((tag 'end)) (go tag)) end) proves that tags are not first class.
<pjb>
(let ((k (macro-function 'cond))) (funcall k '(cond (x nil) (t t)) nil)) #| --> (if x (progn nil) (cond (t t))) |# proves that macros are first class.
<pjb>
(let ((vs (values 1 2 3))) vs) #| --> 1 |# proves that multiple values are not first class.
random-nick has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 276 seconds]
<jcowan>
I would add that a first-class value has to be containable in a (suitably typed) data structure, passable as an argument, and returnable as a function value
<pjb>
(let ((l (list 1 2 3))) (let ((p (second l))) (setf p 42)) l) #| --> (1 2 3) |# proves that places are not first class.
<pjb>
jcowan: in lisp, anything that can be bound to a variable has those properties.
<pjb>
The suitable type being T
<jcowan>
Algol 60 had arrays of tags, but no tag-valued functions
<jcowan>
I am speaking more generally
<phoe>
you can contain macro functions in any data structure you want, you can pass it as an argument and return it as a function value
<pjb>
Granted you can refine the definition for more generality. Nonetheless, macros are first class.
<phoe>
s/macro //
bms_ has quit [Remote host closed the connection]
<phoe>
you can do it for all sorts of functions. macro functions are no exception.
<jcowan>
Of course macro functions are first class, the question is whether that makes macros first class.
<phoe>
1) is a form and therefore an atom or a list, both are first class. 2) is a function, which is first class. 3) is a symbol, which is first [1;5Dclass.
smasta has joined #lisp
<phoe>
3) can also be (setf something) methinks.
<phoe>
...actually wait a second
<phoe>
no, it can't.
<phoe>
therefore a symbol, even simpler.
pmetzger has joined #lisp
<phoe>
"what is a macro? a miserable little pile of Lisp forms"
smasta has left #lisp [#lisp]
<logicmoo>
well functions (including i suppose macro functions) are missing a couple nice things that would make them more first class.. being able to compare them with each other and analyse them outside of executing them
<pjb>
Remember, in lisp, everything (that exists) is of type T.
<logicmoo>
for example they might always present a lambda-list
erikc has joined #lisp
Ven`` has quit [Ping timeout: 276 seconds]
<logicmoo>
instead they are often opache pointers that dont throw an error if you use them as a first argement to funcall
<phoe>
logicmoo: that's beyond the standard, but implementations often provide the mechanism to retrieve a lambda list from a function object
<phoe>
swank uses this a real lot
<phoe>
comparing them with each other is doable, they're EQ to each other
<phoe>
I mean, a function is EQ to itself
Ven`` has joined #lisp
<phoe>
and itself only
<phoe>
as for comparing functions, it's undecidable in general if two functions return the same results for all inputs
libreman has quit [Ping timeout: 240 seconds]
<phoe>
as for analyzing them outside of executing them, what do you mean?
<phoe>
you can always #'DISASSEMBLE if that's what you mean
<phoe>
the implementation is permitted to return anything as a result of DISASSEMBLE
<phoe>
but usually it's useful stuff.
KZiemian has joined #lisp
<pjb>
First-classness doesn't imply random operations. There may be rules on how to use those values. A lambda-list is a sexp with a specified format. You can bind them to variables, pass them as function arguments, obtain them as function result (since they're mere lists), and you can use them in a lambda expression passed to COMPILE, EVAL or COERCE. There's no need to have a function to go from FUNCTION to lambda-lists.
fourier has joined #lisp
<logicmoo>
i suppose most lisps are much better at return a result to dissassemble than with lambda list
<phoe>
logicmoo: nah
fourier has quit [Changing host]
fourier has joined #lisp
<phoe>
#'DISASSEMBLE is a part of the standard, so it's somewhat implied that the implementation should implement it
<phoe>
(somehow)
<phoe>
and for returning lambda lists, implementations return these anyway,
<phoe>
this falls back to SWANK which implements it somewhat portably across implementations.
<logicmoo>
ah nice this is the closer-mop as to clos is but for function arglists?
fikka has joined #lisp
Ellusionist has quit [Ping timeout: 252 seconds]
KZiemian has quit [Client Quit]
<logicmoo>
(works arround the various impls who dont equally implement things)
<phoe>
all portability libraries are like this.
fourier has quit [Remote host closed the connection]
<phoe>
trivial-arguments is for lambda lists, trivial-garbage is for finalizers/garbage collection/weak hash tables, bordeaux-threads is for threads, usocket is for TCP/UDP networking, ...
<phoe>
..., ASDF is for system definition.
bms_ has quit [Quit: Leaving]
varjagg has joined #lisp
<logicmoo>
no trivial-dissasembly ?
<phoe>
uh
* logicmoo
joking
<phoe>
why?
<phoe>
...xD
<phoe>
(incf logicmoo)
fikka has quit [Ping timeout: 260 seconds]
KZiemian has joined #lisp
Ven`` has quit [Ping timeout: 265 seconds]
Jarwin has quit [Ping timeout: 264 seconds]
<KZiemian>
hey
<KZiemian>
I need to know standards of documention CL code and making doctstring
<KZiemian>
is Google Style Guide authoritative or should I look to other sources?
<logicmoo>
practically if there is a way to squeeze out FUNCTION-LAMBDA-EXPRESSIONs from function then ok they feel first class to me
fikka has joined #lisp
<logicmoo>
(irregardless of having differnt code per impl.. (that would only be whining))
<KZiemian>
phoe: hey
<KZiemian>
phoe: are you here?
EvW has quit [Ping timeout: 265 seconds]
fortitude_ has joined #lisp
<phoe>
KZiemian: sup
<phoe>
let's talk on Discord
<sigjuice>
KZiemian google can't tell you or me what to do :)
<KZiemian>
phoe: ok
<KZiemian>
sigjuice: but communiut can and I don't want to mess it up
damke has quit [Ping timeout: 264 seconds]
<phoe>
logicmoo: you still can't transmit compiled functions from one Lisp implementation to the other
<KZiemian>
sigjuice: in "Succesful Lisp" is nice line
fikka has quit [Ping timeout: 265 seconds]
<phoe>
if there is a way to squeeze out FUNCTION-DUMP and FUNCTION-UNDUMP from function then they ok they feel first class to me.
<KZiemian>
sigjuice: rule of thumb stay, that if you write code like these you should be shoot
<sigjuice>
KZiemian are you saying I will get shot if I don't obey google?
shifty has quit [Ping timeout: 276 seconds]
damke_ has joined #lisp
terpri has quit [Remote host closed the connection]
nowhereman_ has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
<KZiemian>
sigjuice: not Google
<KZiemian>
sigjuice: rather "obvious things" are dengerous to both of us
<pjb>
logicmoo: the definition of first-class doesn't involve function-lambda-expression.
<pjb>
This is why this function can return nil.
<logicmoo>
pjb: thus my gripe, perhaps there could be a use for trival-lambda-expressions
nowhereman_ has joined #lisp
<logicmoo>
trivial*
<logicmoo>
"Help! I am using trivial lambda expressions"
fikka has quit [Ping timeout: 240 seconds]
<pjb>
logicmoo: there should be no need, because if it is possible at all to obtain it, then function-lambda-expression should return it. Otherwise you can deem it a defect in your implementation and complain with the vendor.
KZiemian has quit [Ping timeout: 260 seconds]
<pjb>
Perhaps you mean trivial-lambda-list ?
fikka has joined #lisp
drcode has quit [Ping timeout: 276 seconds]
drcode has joined #lisp
jack_rabbit has quit [Quit: Leaving]
<logicmoo>
i think trivial-arguments would be trivial-lambda-lists so i guess that is covered
fikka has quit [Ping timeout: 240 seconds]
EvW1 has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
terpri has joined #lisp
random-nick has joined #lisp
Oladon has joined #lisp
frob has joined #lisp
frob has quit [Client Quit]
fikka has joined #lisp
openthesky has quit [Ping timeout: 252 seconds]
ykoda has quit [Ping timeout: 252 seconds]
scymtym has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 256 seconds]
fortitude has quit [Ping timeout: 256 seconds]
randomstrangerb has quit [Ping timeout: 268 seconds]
jack_rabbit has joined #lisp
randomstrangerb has joined #lisp
damke has joined #lisp
fikka has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
katco[m] has joined #lisp
sz0 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
eivarv has quit [Quit: Sleep]
eivarv has joined #lisp
fikka has joined #lisp
<peterpp>
is anyone here using manardb or something similar in production?