ebzzry has quit [Read error: Connection reset by peer]
ebzzry has joined #lisp
Mutex7 has quit [Quit: Leaving]
fourier has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
stacksmith has quit [Ping timeout: 265 seconds]
jlarocco has quit [Remote host closed the connection]
rippa has joined #lisp
pierpal has quit [Ping timeout: 248 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
schjetne has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
zxcvz has joined #lisp
t0adst00l has joined #lisp
energizer has quit [Disconnected by services]
energizer has joined #lisp
energizer has quit [Remote host closed the connection]
energizer has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
pierpal has joined #lisp
<beach>
scymtym: For Second Climacs, I want the reader to return parse-results, or as I call them in Second Climacs "wad"s. A wad is a nested data structure that contains source positions corresponding to the start and the end of the thing that was read, and also a list of children, which are also wads. And the children are represented as a list of wads in the order that they were read.
charh has quit [Quit: zZzZZz]
doanyway has quit [Remote host closed the connection]
angavrilov has joined #lisp
<beach>
Furthermore, non-expressions are included, so that there are comment wads, etc.
<beach>
I need to program Eclector to return wads.
<beach>
I have several options:
<beach>
1. Just do it.
<beach>
2. Add the possibility for Eclector to return wads, just the way it can now return CSTs.
wxie has joined #lisp
<beach>
The thing is complicated by the fact that in Second Climacs I ultimately want CSTs as well.
Arcaelyx has joined #lisp
johnvonneumann has joined #lisp
<beach>
So then, for solution 1 I can convert wads to CSTs. Just drop the non-expressions and apply a similar technique that Eclector itself uses to construct a CST from a bunch of children.
<beach>
With solution 2, there are two sub-options:
<beach>
2.1 Use solution 1, but include it in the Eclector repository.
<beach>
2.2 Use solution 2, and factor the code so that there is no duplication, i.e. build the CSTs from the wads.
<beach>
scymtym: Any suggestions?
rumbler31 has joined #lisp
<beach>
The thing is complicated by the fact that, for Second Climacs, I want to make the parser incremental. I guess I need to think about the interaction between the cache manager and the reader. It is entirely possible that it can not be turned incremental with solution 2.
wxie has quit [Read error: Connection reset by peer]
<phoe>
beach: for an incomplete expression, is it possible that you return a "special" wad at the end of each list of children that is used as a mark that this expression is incomplete?
<phoe>
I imagine that for an incomplete expression "(1 2 3" it could be a list resembling (#<WAD 1> #<WAD 2> #<WAD 3> #<EOF-WAD>) or something similar.
<beach>
I do that. It is called EOF-WAD.
<phoe>
If a list contains an EOF-WAD, then the expression is incomplete, but you can nonetheless return the parse result.
<phoe>
Hah!
<beach>
Yes, I do need to improve it so that there are several types of EOF-WADs
<phoe>
And if you can return a parse result, then you should be able to make your parser incremental nonetheless.
<beach>
One would be an incomplete list, one and incomplete token, etc.
<beach>
It's not clear...
<beach>
The wad-reader would need to be a generic function.
<beach>
That way, I can define and :AROUND method that consults the cache.
rumbler31 has quit [Ping timeout: 264 seconds]
<beach>
It would not call CALL-NEXT-METHOD if there is a wad in the cache.
<beach>
I guess it can work.
<phoe>
Oh, right.
schjetne has quit [Ping timeout: 264 seconds]
nika has joined #lisp
earl-ducaine has joined #lisp
<beach>
The reason I am asking all this is that such a wad reader could be useful in situations other than Second Climacs, and if so, it ought to be in a separate system.
<beach>
Anyway, time to go do something else.
<beach>
I'll read any remarks when I get back.
pierpal has quit [Read error: Connection reset by peer]
<flip214>
beach: for me "wad" is a datafile for Doom ;)
vap1 has quit [Quit: Leaving]
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
shka_ has joined #lisp
schjetne has joined #lisp
fisxoj has quit [Quit: fisxoj]
<beach>
I see. Well, PARSE-RESULT turned out to be too long, so I had to choose something shorter.
milanj_ has quit [Quit: This computer has gone to sleep]
Pixel_Outlaw has quit [Quit: Leaving]
thuffir has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
lnostdal has joined #lisp
FreeBirdLjj has joined #lisp
schjetne has quit [Ping timeout: 240 seconds]
ChrisOei has joined #lisp
lnostdal has quit [Ping timeout: 264 seconds]
DataLinkDroid has quit [Ping timeout: 240 seconds]
lnostdal has joined #lisp
rumbler31 has joined #lisp
DataLinkDroid has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
lnostdal has quit [Ping timeout: 268 seconds]
orivej has joined #lisp
milanj_ has joined #lisp
schjetne has joined #lisp
makomo has joined #lisp
raynold has quit [Quit: Connection closed for inactivity]
lnostdal has joined #lisp
ravi__ has joined #lisp
ravi has quit [Ping timeout: 264 seconds]
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
lnostdal has quit [Ping timeout: 260 seconds]
Fare has quit [Ping timeout: 248 seconds]
iqubic` has joined #lisp
iqubic` has left #lisp [#lisp]
schjetne has quit [Ping timeout: 240 seconds]
iqubic has quit [Ping timeout: 255 seconds]
lonjil has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
rumbler31 has joined #lisp
Xach has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
eschatologist has quit [Ping timeout: 276 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
schjetne has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
fikka has joined #lisp
pierpal has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<jmercouris>
anyone know where Shinmera has been? He's active on github but not on IRC
fikka has joined #lisp
<scymtym>
beach: i will have to think about this more, but i have an initial impression. i mentioned before that i would like to turn the eclector-concrete-syntax-tree code into two parts: 1) a protocol for constructing parse results 2) a client of that protocol that constructs CSTs. my impression is that such a protocol (modulo omissions that become apparent when it is used) would be sufficient for the three clients i am aware of: 1) the CST
<scymtym>
client 2) the second climacs client 3) my toy-lisp client
schjetne has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 240 seconds]
<pjb>
jmercouris: you mean, Shinmera has been programming, instead of chatting? Anathema!
igemnace has joined #lisp
svillemot has quit [Quit: Reboot]
ravi__ has joined #lisp
fikka has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi has quit [Ping timeout: 276 seconds]
ravi__ has quit [Max SendQ exceeded]
svillemot has joined #lisp
ravi__ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
markong has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
fikka has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
<jackdaniel>
jmercouris: he is on irc, ust gave up on #lisp (at least temporarily)
fikka has quit [Ping timeout: 264 seconds]
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
* edgar-rft
always thought that chatting is like literate programming
clintm has joined #lisp
Ven`` has joined #lisp
wxie has joined #lisp
Ven` has joined #lisp
fikka has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
schjetne has joined #lisp
Ven`` has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
milanj_ has quit [Ping timeout: 264 seconds]
schjetne has quit [Ping timeout: 240 seconds]
milanj has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 256 seconds]
Ven` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
wxie has quit [Read error: Connection reset by peer]
t0adst00l has quit [Ping timeout: 255 seconds]
wxie has joined #lisp
wxie has quit [Client Quit]
<beach>
scymtym: OK, sounds good. Let's discuss this at some point.
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 264 seconds]
alecigne has joined #lisp
alecigne has left #lisp [#lisp]
EvW1 has joined #lisp
schjetne has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
Satou has joined #lisp
rumbler31 has joined #lisp
jsjolen has joined #lisp
__rumbler31 has joined #lisp
makomo has joined #lisp
schjetne has quit [Ping timeout: 248 seconds]
__rumbler31 has quit [Ping timeout: 264 seconds]
lnostdal has joined #lisp
Bike has joined #lisp
zaquest has quit [Quit: Leaving]
jsjolen has quit [Remote host closed the connection]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
dddddd has joined #lisp
pierpal has joined #lisp
ravi__ has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
jeosol has quit [Ping timeout: 260 seconds]
python476 has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
schjetne has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
random-nick has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
moei has quit [Quit: Leaving...]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Bronsa has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
Satou has quit [Quit: Cya soon guys!]
Josh_2 has joined #lisp
fikka has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
wigust- has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
CrazyEddy has joined #lisp
schjetne has quit [Ping timeout: 268 seconds]
wigust has quit [Ping timeout: 256 seconds]
asarch has joined #lisp
fikka has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
TCZ has joined #lisp
EvW1 has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
sjl has quit [Quit: WeeChat 1.9.1]
jmercouris has quit [Ping timeout: 264 seconds]
sjl has joined #lisp
jmercouris has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
schjetne has joined #lisp
TCZ has quit [Quit: Leaving]
fikka has joined #lisp
Fare has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Pixel_Outlaw has joined #lisp
ukari has joined #lisp
pillton has quit [Ping timeout: 240 seconds]
schjetne has quit [Ping timeout: 268 seconds]
Rawriful has joined #lisp
fikka has joined #lisp
Kevslinger has joined #lisp
<ukari>
is there any consensus or principle about function api design? There are two ways and which is better ? multiple returned values, or (list (cons :key1 xx) (cons :key2 xx) (cons: key3 xx))
<White_Flame>
multiple values are very common
himmAllRight has joined #lisp
<White_Flame>
now, if those keys are optional, then you might want to return that and descructure
fikka has quit [Ping timeout: 264 seconds]
charh has joined #lisp
<pfdietz>
I suggest a preference for :key arguments.
<phoe>
Ukari: it depends™
damke has joined #lisp
<phoe>
what is your function going to return?
<phoe>
I mean, what is its purpose?
<ukari>
I am used to use closure as a simple object system
<jackdaniel>
if function returns multiple values use multiple values, that way you don't cons unnecessarily
<Bike>
i wonder if implementations cons in (multiple-value-call (lambda (&key ...) ...) ...)
<jackdaniel>
you don't need the lambda there
<jackdaniel>
because you return the result of calling it (when you cal lthe function)
<jackdaniel>
just saying
<Bike>
what?
<jackdaniel>
also progn is implicit in defun
<Bike>
oh not me
<jackdaniel>
Ukari: ↑ (not Bike :)
<ukari>
what is calling it? the lambda it returned is what need to call
<Bike>
it's called immediately
<Bike>
so it's pointless
<jackdaniel>
(defun hash () ((lambda () 3))) is the same as (defun hash () 3)
<Xof>
speaking of consing
<Bike>
(defun hash () (let ((storage)) ...)) would work the same
<jackdaniel>
compiler may even strip the lambda
<Bike>
also, if you want an object i recommend actually construting an object
<Bike>
no need to be coy
<jackdaniel>
yup
CrazyEddy has quit [Remote host closed the connection]
<jackdaniel>
and an opinionated advice: use #'(lambda …) to return lambda
<ukari>
you are right
<jackdaniel>
though it is semantically the same (because lambda is a macro)
<Bike>
this isn't even more efficient, you cons up three closures, whereas you only need zero closures
<ukari>
I thought you were talking about lambdas in return
<jackdaniel>
well, in your situation (if you really need these lambdas inside), just do (defun hash () (let (storage) (values #'(…) #'(…) #'(…))))
<Xof>
I am having difficulty building an implementation of case using a jump table without consing at runtime (and, worse, doing O(n) initialization at runtime). I wonder if I'm missing something or if that is indeed the best I can do
fikka has joined #lisp
<Bike>
what do you have to cons at runtime?
<ukari>
in values #'(...)... way, if i want to call :set or :get, the code need to provide a exact position
<Xof>
Bike: closures
<Bike>
for what?
<Xof>
(let ((x 1)) (case y (:foo (1+ x)) (:bar (+ x 2))))
<jackdaniel>
Ukari: whenever you remember that first is init, second is set and third is get, or that you remember that there is assoc :init, assoc :set and assoc :get still makes you remember *things* as a programmer
<Xof>
if I rewrite that to (funcall (aref table (lookup y))) ; approximately
damke has quit [Ping timeout: 264 seconds]
<Xof>
then my table functions are in general closures
<Bike>
oh i thought you meant an actual jump table
<Xof>
(defun foo (x) (case y (:foo (1+ x)) (:bar (+ x 2))))
<Xof>
yeah, fair enough
<Bike>
which obviously you can't do without special support
<ukari>
jackdaniel, but if i need to add another :setFoo, i must add it to the last position or it will mess up the code before
<Xof>
ok, that's the "obviously" I was looking for, thanks
<jackdaniel>
Ukari: for me thsi programming style is unreadable anyway, when I want functions I define them with names and provide argument to them
<Bike>
i mean, an "actual" jump table is like having a GO special operator that evaluates its argument
<Bike>
but that doesn't exist in lisp
<Xof>
the good news is that means I can forget about my case-using-perfect-hashes, at least for now, and move on to find-restart-using-perfect-hashes
<Xof>
since restart-bind does O(n) initialization anyway
<Bike>
well you could still get implementation support and do it
<Bike>
i think phkuong played with computed goto in sbcl
<jackdaniel>
Ukari: eventually (if I really must) I can always define dynamic variable and create dynamic context for these functiosn with let, that way I have only one thing to carry in the application instead of n functions
<Xof>
it certainly sounds like the kind of thing he would have played with
fikka has quit [Ping timeout: 260 seconds]
<jackdaniel>
Ukari: I admit that these advices are very opinionated, but you have asked about opinions ;)
shka_ has quit [Quit: Konversation terminated!]
<ukari>
show me the example about `define dynamic variable and create dynamic context for these functiosn with let`, it sounds interesting
<phoe>
(let ((*some-sorta-thing* 42)) (foo))
Naergon has quit [Ping timeout: 268 seconds]
<phoe>
where (defun foo () (frobnicate *some-sorta-thing*))
<jackdaniel>
now (let ((*foo* nil)) (init) (ukari-set …) (ukari-get …))
<jackdaniel>
in body of this let form *foo* is bound to nil, outside this let form *foo* is not bound at all
ravi__ has joined #lisp
fikka has joined #lisp
ravi__ has quit [Max SendQ exceeded]
shka_ has joined #lisp
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
<ukari>
it seems not work well if I need two or more instance
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
<jackdaniel>
we could go on with improving your hack, but readable solution is to have argument to your set/get functions
fikka has quit [Ping timeout: 240 seconds]
pierpal has quit [Read error: Connection reset by peer]
<jackdaniel>
and as many variables as many instances you need (and work from there)
<pjb>
Ukari: I would distinguish inner-loop functions from public API functions. The later, notably if they're intended to be invoked from the REPL, as commands, can have all kinds of sophisticated argument parsing, including &key and others (eg. catching additionnal arguments or list of arguments after the last &key, which is not parsed by default). But for internal functions, it may be better to use more plain lambda-lists, with only
<jackdaniel>
having dynamic context, or even worse – floating anonymous functions, makes your program hard to analyze
<pjb>
Ukari: and for results, multiple-values are probably the fastest way to return multiple values, even if you put a lot of NILs there for optional results.
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
schjetne has joined #lisp
Oladon has joined #lisp
ravi__ has joined #lisp
damke_ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
<ukari>
pjb, thank you for advice
fikka has joined #lisp
ravi__ has joined #lisp
Nubi has joined #lisp
damke has quit [Ping timeout: 260 seconds]
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
DemolitionMan has joined #lisp
u0_a183 has joined #lisp
ravi__ has quit [Max SendQ exceeded]
fikka has quit [Ping timeout: 268 seconds]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
pierpal has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
Bronsa has quit [Ping timeout: 240 seconds]
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
fikka has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
ravi__ has quit [Max SendQ exceeded]
l2y has joined #lisp
ravi__ has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
ravi__ has quit [Max SendQ exceeded]
ravi__ has joined #lisp
light2yellow has quit [Ping timeout: 264 seconds]
schjetne has quit [Ping timeout: 248 seconds]
l2y has left #lisp [#lisp]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
asarch has quit [Remote host closed the connection]
grumble has quit [Read error: Connection reset by peer]
grumble has joined #lisp
schjetne has joined #lisp
raynold has joined #lisp
<ukari>
(iterate (for i in '(1 2 3 4)) (print i)), why this code tells 'The variable I is unbound'
cage_ has quit [Remote host closed the connection]
cage_ has joined #lisp
asarch has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
<foojin>
jackdaniel: In your answer to Ukari, what did you mean by "floating anonymous functions"?
mflem has joined #lisp
<phoe>
a (lambda (...) ...) somewhere in code
<phoe>
nothing worse in a stacktrace than a nameless lambda
<jackdaniel>
foojin: he had "function factory", so I assume he were going to use them
<jackdaniel>
exactly 3x number of instances of his "hash"
<ukari>
phoe, why, for efficiency or debug info?
<phoe>
Ukari: debuggability
<jackdaniel>
each of them was not named, and I assume he would want to store them *somewhere*
<phoe>
efficiency-wise there should be no difference
<jackdaniel>
so there is a lot of variables storing functions without a name
<jackdaniel>
generally I meant this
<ukari>
nameless lambda don't make global name confit but defun does, or it needs package name provided
<foojin>
jackdaniel: Ah, so it's just about passing them around so that it becomes difficult to know where did they come from.
<phoe>
Ukari: do you really need to generate code for each single hash element that you have?
<jackdaniel>
Ukari: I suspect you are a beginning CL programmer. I may be wrong, but if it is a case, you may learn a lot by following simple advices
<phoe>
and each single hash value is going to have a completely separate function that is going to be called?
<jackdaniel>
it is easier to maintain N variables with your "instances" and use directly gethash/setf gethash, then to maintain 3xN functions doing that for you
<jackdaniel>
if you have more complicated behavior, you maintain objects in variables and you specilize generic functions on their classes
<ukari>
maybe i could store nameless lambda in a static way and pass varibale into it, like (let ((set (lambda (store) (lambda () ...)))) (defun hash () (list (cons :set (funcall set store)))))
energizer has joined #lisp
<jackdaniel>
etc, that is something what people do, because it works and it provides easy structure of your program to follow
<jackdaniel>
but I think you are not interested in following this "nonsense", so I'm getting back to my Saturday ;-) see you \o
<phoe>
Ukari: grab a CLOS tutorial, read it and use it. You're going in a direction that is rarely used (because better mechanisms exist) and insanely hard to debug.
fourier has joined #lisp
<phoe>
Your "closures as a simple object system" slowly stops being simple.
damke_ has quit [Ping timeout: 265 seconds]
brendyn has quit [Ping timeout: 260 seconds]
damke_ has joined #lisp
cage_ has quit [Ping timeout: 248 seconds]
CrazyEddy has joined #lisp
<ukari>
i find a not-independent generator in this code, (iterate (for el in '(1 2 3 4)) (generate i from 1) (print (next i))). is there any standrad about independent generator?
frgo has joined #lisp
<ukari>
sth might works like (iterate (for i in generator) (print i))
<rme>
phoe: No, I haven't set up anything like that.
<phoe>
rme: please do! I believe I'm not the only person who'd want to chip in.
<rme>
Thank you, phoe. I know there are generous people out there like you, but I have some doubts about whether crowdfunding is suitable for sustaining funding for a software system like CCL.
fikka has joined #lisp
<Fare>
I have fond memories of working with CCL. A few issues, too, but overall minor. Not sure how things changed since Gary retired (how is he?)
<phoe>
rme: I honestly don't think it's going to sustain CCL but I nonetheless want to throw my two cents at it the moment I have a chance.
<phoe>
Other than hacking at it, that is.
<rme>
Fare: Gary sent me email the day before the ELS started to wish me luck on me talk.
<fourier>
that was extremely energetic and inspiring talk though
<rme>
He's mentioned to me before that he thinks about getting back on the net, but I don't know much more than that.
<phoe>
fourier: +1
<rme>
fourier: Thanks. I believe every word I said.
fikka has quit [Ping timeout: 256 seconds]
<Fare>
(I still believe ITA did the wrong call on dividing its attention between SBCL and CCL, but that is one of the least mistakes made there)
CrazyEddy has quit [Remote host closed the connection]
<Fare>
I miss working in Lisp --- and most importantly, with Lispers.
stnutt has quit [Ping timeout: 276 seconds]
<Fare>
Happily, I am working with a Lisper now, though not in Lisp.
fikka has joined #lisp
<mfiano>
Fare: What are you working in if not Gerbil?
stnutt has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
loginoob has joined #lisp
dddddd has quit [Remote host closed the connection]
CrazyEddy has joined #lisp
aindilis has joined #lisp
moei has joined #lisp
<Fare>
mfiano: at Legicash, we use OCaml.
<Fare>
other project (still ongoing, but I am less involved) is still in Gerbil Scheme.
stnutt has quit [Ping timeout: 276 seconds]
random-nick has quit [Read error: Connection reset by peer]
doanyway has joined #lisp
stnutt has joined #lisp
Oladon has quit [Quit: Leaving.]
fikka has joined #lisp
<fourier>
what is your opinion on ocaml ?
<Fare>
Well, I was raised on OCaml back at $almamater
schjetne has joined #lisp
nika has quit [Quit: Leaving...]
<Fare>
coming back to it, I find I enjoy having decent type inference to help me. The syntax is annoying. The build system story is in disarray though with a good solution in sight (jbuilder / dune); the metaprogramming story is well, quite unsatisfying though not quite as bad as Java.
<jmercouris>
Fare: I think you managed to find one of the only OCaml jobs in existence
<Fare>
I made it.
<Fare>
I'm the technical co-founder.
<jmercouris>
Ah, then you could have just as easily made it Lisp
<jmercouris>
what drove your decision?
<Fare>
No, we really needed types.
<jmercouris>
Do you care to elaborate?
<Fare>
working with cryptocurrencies, with our claim being that we use formal methods.
<jmercouris>
Ah, well
<Fare>
There is a Scheme backend to Coq, though.
<Fare>
So that's the fallback plan to me if OCaml gets too messy / stunted.
fikka has quit [Ping timeout: 260 seconds]
<Fare>
Types do help a lot with prototyping. And library support for pure functional programming.
<jmercouris>
Do they? I'm not so sure
<rme>
I've always sort of been interested in ML and OCaml, but I've never used either for anything real.
<jmercouris>
you are a much more experienced developer than me though, so maybe with time I'll achieve some level of enlightenment in this regard
<fourier>
why ocaml and not haskell ?
<Fare>
I do find that OCaml is a bit awkward in that anything serious requires using modules which require one more level of complexity compared to other things. I miss the seamless ad hoc polymorphism of Scala or Haskell.
<Fare>
The object system of OCaml is not very well integrated.
<Fare>
fourier, because we wanted to work with Tezos (shelved for now) which uses OCaml, and we still want to use with Coq, which has much better OCaml than Haskell support.
<fourier>
ah I see
<jmercouris>
Fare: so, what does yoru company do exactly?
<jmercouris>
are you at liberty to say?
<jmercouris>
s/yoru/your
<Fare>
Also, unless I had an expert Haskell partner, I wouldn't feel comfortable using Haskell. OCaml lets you easily escape to plain old imperative style, so I know I can fallback to the bad old ways if needed.
<jmercouris>
imperative is the bad old ways? what are you some prolog master :D?
<Fare>
prolog is way too imperative for me. Did you mean Mercury?
<Fare>
(Does Mercury still exist?)
<jmercouris>
prolog is way too imperative, that's a statement I never thought I would hear :D
<jmercouris>
interesting business you have there
<jmercouris>
I take it you are funded because you have some advisors
LiamH has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
<Fare>
jmercouris, the two are not synonymous.
<Fare>
Although they are correlated.
<p_l>
Fare: Mercury still exists
<Fare>
yup, mercurylang.org
fikka has joined #lisp
<jmercouris>
sure, anyone that's serious about a business is usually using an advisor as an avenue to investment
<jmercouris>
at least serious about a "startup", whatever that means
<jmercouris>
Fare: how long do you anticipate until your product is operational?
<Fare>
about a year.
<Fare>
if fully funded
<Fare>
that would be beta net.
<jmercouris>
So what's the majority of that time?
<jmercouris>
what do you need the funding for?
<Fare>
building the software and proof infrastructure.
Kundry_Wag has joined #lisp
<jmercouris>
how many developers do you want to hire?
<jmercouris>
if you don't want to talk about it, feel free to stop me at any time
<jmercouris>
or if anyone is annoyed by this being off-topic as well...
<jackdaniel>
--> #lispcafe
<jmercouris>
I first looked for Fare's username in lispcafe
<jackdaniel>
ask him to join, maybe he is interested in non-lisp discussion ;-)
* Fare
joins #lispcafe
<loginoob>
I am a beginner, have only read 6 chapters of CL:a gentle introduction. Should i also learn to write tests to my programs or that should be learned later?
<Fare>
ocaml is just lisp with a bad syntax and a semi-usable type system.
<jmercouris>
loginoob: Tests aren't super critical, plus there is no "de-facto" testing framework in CL
<Fare>
actually, the original CAML was written in Lisp. LeLisp.
<jmercouris>
loginoob: something cool to do might be to write your own testing suite
<jackdaniel>
loginoob: desiging tests for your application is essential, but not so important for learning excercises
<jmercouris>
loginoob: there's a chapter about it in practical common lisp
<shrdlu68>
Ah, so :cl-user :uses :sb-ext, which is why I've always been able to call gc without the sb-ext: prefix.
<phoe>
shrdlu68: yes, the use list for CL-USER is implementation-defined.
<phoe>
on CCL, it also uses the :CCL package methinks, and so on.
asarch has quit [Remote host closed the connection]
asarch has joined #lisp
<pjb>
foojin: more precisely, it's because in (let ((x 42)) (cap2 x)) we want the x in (cap2 x) to refer to the x bound by let. but the macro cap2 could expand to (let ((x 33 #|for example|#)) '(list x)) #| --> (list 33) |# where is bound in the inner let. This is not inherently wrong. It's just a matter of specifications of the cap2 macro, and of general expectations ("style") in CL.
fikka has quit [Ping timeout: 264 seconds]
hjek has joined #lisp
<foojin>
phoe: The question was somewhat ambiguous, with dots instead of actual code, so I assumed there were no comma substitutions there. Otherwise that situation would surely be possible.
<pjb>
foojin: If you are defining a specific DSL, perhaps it's meaningful for the x in (cap2 x) to be refering something else than outside bindings. But if not in this case, it's generally expected that the in a form such as (let ((x 42)) (cap2 x)) the x in (cap2 x) be a lexical reference to the lexical binding.
hjek has quit [Client Quit]
<pjb>
It's often better to let the user specify the name of the inner variables, when he can also provide bodies or expressions refering them: (let ((x 42)) (cap2 (x) x)) would then read similarly to (let ((x 42)) (let ((x 33)) x)) and there would be no contraried expectation: it would be clear, lexically, that cap2 establishes a new binding for x.
<pjb>
And if the user wants to use the outer x, this allows him to write (let ((x 42)) (cap2 (y) (+ x y))).
puchacz has joined #lisp
<puchacz>
hi, how to read file to array of octets pls?
<pjb>
shrdlu68: I have this in my common.lisp rc file: (mapc (lambda (package) (unuse-package package "COMMON-LISP-USER")) (delete (find-package "COMMON-LISP") (copy-seq (package-use-list "COMMON-LISP-USER"))))
<puchacz>
phoe: thanks
<pjb>
shrdlu68: so my CL-USER is the same in all implementations, and I can write conforming code even in CL-USER.
<shrdlu68>
puchacz: Alexandria has a function for that.
<foojin>
pjb: I totally forgot about the "expectations" thing. It would indeed be quite strange for an inserted binding to get in the way (as shown in your first example).
<shrdlu68>
puchacz: Or just open the file with :elment-type (unsigned-byte 8)
<pjb>
foojin: this is why it's not wrong per-se. It all depends on the specification of the macro. For example, anaphoric macros establish an implicit binding to IT.
<shrdlu68>
phoe: Didn't see that :(
<phoe>
shrdlu68: <3
JuanDaugherty has joined #lisp
<puchacz>
shrdlu68: nah, I prefer to have it wrapped as a function
<pjb>
the type is evaluated, so it must be quoted: :elment-type '(unsigned-byte 8)
<shrdlu68>
Yep.
<pjb>
And since unsigned-byte is exported from CL, you cannot fbind it.
python47` has quit [Read error: Connection reset by peer]
janivaltteri has joined #lisp
<phoe>
wait, fbind?
<phoe>
you can put it in a flet
<pjb>
define a function or macro with the same name.
<phoe>
If an external symbol of the COMMON-LISP package is not defined as a standardized function, macro, or special operator, it is allowed to lexically bind it as a function (e.g., with flet), to declare the ftype of that binding, and (in implementations which provide the ability to do so) to trace that binding.
<shrdlu68>
pjb: That's cool.
<phoe>
The fact that the above is completely pointless is a different thing
<pjb>
phoe: Oh, right, in the exceptions.
<pjb>
That's funny.
<phoe>
pjb: I know, right?
<phoe>
But this is why we can (let ((function ...)) ...), too.
<pjb>
This is a strong exception for the implementations, because the default rule is that implementations can define functions for those symbols. But then they cannot use directly those functions in macroexpansions, because that could be wrapped in a flet/labels that would shadow them…
<phoe>
pjb: sure thing that they can define functions on them, BUT
<phoe>
these functions cannot be in form (defun unsigned-byte ...)
<pjb>
why not?
<phoe>
because with the symbol UNSIGNED-BYTE being exported, that would mean that the symbol UNSIGNED-BYTE is now globally fbound.
<phoe>
And it must NOT be globally fbound because there is no standard function CL:UNSIGNED-BYTE in the standard.
<pjb>
but 11.1.2.1.2 pt. 2 is generally explained saying that implementations may do just that.
fikka has joined #lisp
<varjag>
anyone here uses hyperspec-lookup with safari?
<pjb>
Notice that in the exception it's not said "if the exported symbol is fbound or not" but "if the expected symbol is DEFINED by the standard as a function."
<varjag>
browse-url doesn't seem to open file:// urls for me
<phoe>
Hmmm.
<varjag>
http works fine
<pjb>
varjag: I use Safari as navigator when working on MacOS.
<pjb>
file:// works too, such as file:///opt/local/share/doc/lisp/HyperSpec-7-0/HyperSpec/Body/m_ignore.htm
<varjag>
yeah they do work in broswer
<phoe>
pjb: I see.
<varjag>
but emacs' browse-url drops them shomehow
<pjb>
(after: sudo port install lisp-hyperspec)
<phoe>
It's nonetheless weird for me that the standard would permit a thing like #'UNSIGNED-BYTE.
<phoe>
Since that's obviously non-portable code.
<pjb>
phoe: not really. This allows implementations to use functions to represent things such as types.
<pjb>
Perhaps we should be happy that no implementation use such trick.
<phoe>
pjb: sure, but that's non-portable.
<varjag>
so M-x hyperspec-lookup works for me if i set the root to a web adress, but not with the local hyperspec repo
<pjb>
It's hidden, it's an implementation detaila.
<phoe>
Well. As long as it's inside the implementation, I don't care.
<phoe>
But if it leaks outwards, it's just weird to me.
<pjb>
varjag: works for me. You'll have to debug it.
<pjb>
phoe: Yes.
<phoe>
The standard lists all symbols that are exported from the CL package.
<phoe>
I wonder if it has any constrains about whether some of these symbols must/must not be bound/fbound/macrobound.
fikka has quit [Ping timeout: 264 seconds]
<phoe>
I mean, if the list of all fbound external CL symbols is not permitted to be extended by the implementation above the bare minimum.
<phoe>
That's an interesting thing to check... tomorrow.
* phoe
exhausts his heap, game over.
<pjb>
Good night. (you may have some surprise checking that).
schjetne has quit [Ping timeout: 268 seconds]
slyrus1 has joined #lisp
fikka has joined #lisp
slyrus1 has quit [Quit: slyrus1]
fikka has quit [Ping timeout: 264 seconds]
pillton has joined #lisp
asarch has quit [Quit: Leaving]
CrazyEddy has joined #lisp
trocado has quit [Ping timeout: 248 seconds]
Kundry_W_ has quit [Remote host closed the connection]
kotrcka has joined #lisp
puchacz has quit [Quit: Konversation terminated!]
shrdlu68 has left #lisp [#lisp]
puchacz has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 268 seconds]
schjetne has joined #lisp
brendyn has joined #lisp
zachk has joined #lisp
<ebrasca>
Can I get negative number in 2's complement and in binary?
earl-ducaine has quit [Remote host closed the connection]
<ukari>
is (defstruct ship ..) must use a 'make-ship' to make a instance? Is there anything like (make-instance 'ship ) also works ?
lnostdal has quit [Ping timeout: 260 seconds]
<Josh_2>
Hmm I wonder when Fare is gonna come back, there is some questionable English on his site
slyrus1 has joined #lisp
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
fikka has joined #lisp
Quetzal2 has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
<nirved>
ebrasca: use ldb
<White_Flame>
or logand
LiamH has quit [Quit: Leaving.]
<White_Flame>
Ukari: there's an option to defstruct as to what to name the constructor
damke has quit [Ping timeout: 264 seconds]
<White_Flame>
so you can dispatch through your own tools if you want
fikka has quit [Ping timeout: 264 seconds]
Murii has quit [Ping timeout: 240 seconds]
logc has joined #lisp
<pjb>
ebrasca: it's not clear what you're asking.
<pjb>
ebrasca: the answer is definitely: YES. But we don't know what you want.
<ebrasca>
I like to have binary of negative number.