<nij->
beach it's easier to read and argue about the code
<beach>
You can use THE for the return values inside the function. But why?
<beach>
nij-: But it is also very risky.
<beach>
nij-: Because a declaration is a promise to the compiler. So if someone then breaks that promise, a disaster can happen.
<nij->
Someone shouldn't break that promise to start with then..
<nij->
and shouldn't the compiler catch it at compile time?
<beach>
Oh wow. So your programmers don't make mistakes?
<beach>
Since Common Lisp is a dynamically typed language, the compiler can't catch it.
<beach>
(DEFUN F (X) (DECLARE (TYPE INTEGER X)) (+ X 234)) then (F (READ)) for instance.
splatt990 has joined #commonlisp
<nij->
In this example, an error is thrown with a clear message that the input to F should be an integer.
<beach>
Here, if you supply (say) ABC (a symbol) to READ, it is entirely possible that you don't get an error but the wrong answer.
<nij->
?!
<nij->
How could it be possible to not get an error?
<beach>
First, errors are not "thrown". They are "signaled". Second, since, as I said, a declaration is a promise to the compiler, and the consequences are undefined if the promise is broken, the compiler can assume it is an integer and do the wrong thing.
<nij->
Unless the compiler is set with safety 3 before compilation?
<beach>
Do you have a phrase from the standard that says that?
<bike>
sbcl makes type declarations into assertion as a matter of policy, but that's not standard, it's sbcl
<bike>
and even on sbcl it doesn't work with all types
<beach>
bike: Thank you!
<bike>
types are also not sufficient to describe more complex conditions on inputs or outputs, like e.g. conditions that relate arguments
<nij->
:(
<hayley>
It would be nice to have some kind of concise description of a function, even if unchecked. I modified SLIME to print the inferred types of a function as part of the lambda list.
<bike>
that's neat.
<beach>
nij-: I recommend you use things like CHECK-TYPE and ASSERT instead. Same message to the person reading the code, but always safe.
<nij->
lesson learnt: use declare only to help compiler optimize?
<hayley>
Of course we have documentation strings (of varying quality), but something like "(svref v i), precondition (and (>= i 0) (< i (length v)))" could be interesting. Though SVREF itself is uninteresting.
<beach>
nij-: That's when I use it, which is (almost) never, since I don't need the compiler to optimize.
<nij->
Thanks for the tip!!!!
<beach>
Pleasure.
<bike>
racket has contracts for input/output specifications, and they can get pretty involved. no idea how that manifests in the IDE though.
<beach>
hayley: That sounds like a good idea for a new IDE.
<NotThatRPG>
hayley: Is your SLIME patch available somewhere? That sounds neat.
<nij->
beach: check-type is nice, but it doesn't give concise signature for functions..
<nij->
Any other thoughts that help with this?
<NotThatRPG>
nij-: You mean because it can bind the checked variable to a value of arbitrary type? That's always seemed weird to me...
<nij->
hayley How do you specify the signature of your functions?
<hayley>
DrRacket shows the contracts in the corner.
<nij->
NotThatRPG ?
<beach>
nij-: You use the types of the arguments as argument names.
<NotThatRPG>
I forget where I saw this, but I'm pretty sure that I've seen a library that adds contracts to CL.
son0p has joined #commonlisp
<NotThatRPG>
nij-: I have seen odd things happen in the SBCL type inference when check-type is present. I was assuming it's because if the check fails, the user can provide a substitute value (and I don't think there's any requirement on the type of that value).
<hayley>
I declared types for one-more-re-nightmare. At least I'm certain of return types, having fuzzed probably hundreds of thousands of REs by now. Though declaring types for the arguments is unsound, and maybe I shouldn't do that.
<beach>
nij-: (defun foo (armadillos people) ...) means that it takes a list of armadillos and a list of people.
<NotThatRPG>
I'm doing less CHECK-TYPEs and more optimizing of SAFETY...
<hayley>
There is one ambiguity, in that the "regular expression" argument (common to many functions) should be a "regular expression designator".
NotThatRPG is now known as NotThatRPG_away
<nij->
hmmmm...
<nij->
Maybe I need a new macro instead of defun,
<nij->
in which I can automatically write check-types for inputs and outputs,
<hayley>
I also have a compiler macro which infers the right type when a dependent type would be necessary.
<nij->
I also need a subclass typed-functions of functions, which are just functions with a signature slot.
<beach>
nij-: It is often not necessary. As soon as anything wrong is done to an argument, an error will be signaled.
<nij->
beach It is nice if I can inspect the signature of the function at runtime.
<hayley>
Correction - I don't, but the compiler macro and inlining expose enough information for SBCL to work it out.
molson has joined #commonlisp
<beach>
nij-: If after I typed the DEFUN FOO above in SBCL, I type "(FOO", I get the signature in the minibuffer.
<nij->
The signature only shows the symbol-name of the inputs..
<nij->
I'd like to have types too, and also that for outputs.
* beach
doesn't understand this obsession with types as defined by statically typed languages.
<nij->
Just a naive guess: Work on a large projects where a lot of people can touch the codebase.. and maybe you'll know?!
<beach>
nij-: I am not sure what it is you want. First you claimed that it was for the benefit of people reading your code. But then when I gave you CHECK-TYPE and ASSERT and a way to name your arguments and your functions, that's not enough apparently.
tyson2`` has quit [Remote host closed the connection]
<nij->
For example, what function is not a funcallable standard object?
<beach>
nij-: It is pretty much the definition of FUNCTION to be funcallable.
<nij->
hmm
<beach>
nij-: I suspect that most Common Lisp implementations don't use FUNCALLABLE-STANDARD-OBJECT for the ordinary standard functions, since the code was written before FUNCALLABLE-STANDARD-OBJECT was in the standard.
<nij->
I will just use FUNCTION then.
<beach>
You can't if you want to add the additional information you wanted.
<nij->
Question: If I have a class A, a subclass B (A with an extra slot), and an object a of class A. How do I derive an object b which is just the object a with the slot value being NIL?
migap_ has quit [Ping timeout: 255 seconds]
<beach>
So this is another question about copying? The answer is that there is no general way to do that, because it is not clear how deep the copy needs to be. If you derive (say) a student from (say) a person, do they share the same spouse?
migap_ has joined #commonlisp
<beach>
But if you just want to turn your A object into a B, then use CHANGE-CLASS.
<beach>
Otherwise, you need to write your own function to do that.
occ has quit [Ping timeout: 260 seconds]
<nij->
Oh, here I only need copying of object.
<nij->
so the copied thing would eq to the original ones
<beach>
But, but, the standard doesn't take into account your particular needs, so there is no standard function that does exactly what you want in this situation.
<beach>
Instead, the standard gives you the tools to do what you want in each situation.
<beach>
In general, it makes absolutely no sense to copy objects.
<beach>
What does it mean for (say) an information system to contain two copies of a particular person, or two copies of a bank account, or an organization?
<nij->
So here's my motivation: I want to define the subclass typed-function of the class function, and I want to create such objects easily.
notzmv has joined #commonlisp
<nij->
I want to make use of (defun..) and (lambda)..
<beach>
You can't subclass FUNCTION.
<nij->
The problem is that they defined original functions (i.e. objects in the superclass).
<nij->
I just want to find a way to supplement signatures for them.
<nij->
beach: no? (defclass typed-function (function) ((signature))) worked for me..
<contrapunctus>
nij-: you sure you aren't looking for something like defstar or Coalton? 🤔
<nij->
Coalton is a sublang which seems to be too overkilling to me.. I don't want to interop when unnecesary.
<beach>
nij-: Again, the Common Lisp language is not defined by what works in some particular implementation.
<nij->
I am looking at defstar now.
<nij->
beach I see.. functions are standard objects in CLHS?!
<beach>
No.
<beach>
FUNCTION is a system class.
<nij->
Too sad. No way to subclass a system class in CLHS?
<edwlan[m]>
You could make your own funcallable-standard-class
masinter has joined #commonlisp
<edwlan[m]>
I see that already came up :)
habamax has joined #commonlisp
<beach>
nij-: I am going to give up on this topic. Sorry.
<nij->
Thanks for your help, beach!
<beach>
Sure.
<edwlan[m]>
The advice to use coalton is what I would give too
<edwlan[m]>
There isn't any "interop" pain to speak of
<edwlan[m]>
Because coalton functions are lisp functions
<nij->
edwlan[m] Thanks for sharing that! I will take a closer look then!
<nij->
Do you know how it is implemented? Does it "subclass" funcallable objects like I was trying?
<edwlan[m]>
No, you write your statically typed code in a specific way and its checked
<edwlan[m]>
Most of the implementations I’ve used provide some way to access this information which you could use in the implementation-specific parts of slime
<edwlan[m]>
in sbcl, it's (sb-introspect:function-type 'foo)
<nij->
Nothing was wrong - I was just struggling with extending objects..
<beach>
nij-: Why do you need to extend an object? You just define your function to be an instance of the subclass right away.
<beach>
nij-: You can't turn a standard function into one of your subclass instances, but you can certainly define a DEFUN-like macro that creates instances of your subclass.
<beach>
If I want an instance of STUDENT, I don't start by creating a PERSON and then attempt to turn that PERSON into a STUDENT. I instantiate STUDENT right away.
nij- has quit [Ping timeout: 260 seconds]
nij- has joined #commonlisp
<nij->
beach I'd like to make use of DEFUN as much as possible.
<nij->
Maybe I shouldn't do that?
<aeth>
nothing's wrong with writing your own DEFUN-like macro
nij- has quit [Ping timeout: 255 seconds]
nij- has joined #commonlisp
nij- has quit [Ping timeout: 240 seconds]
occ has joined #commonlisp
<beach>
minion: memo for nij-: You can't have both. DEFUN creates an instance FUNCTION which is a system class, so you can't subclass it, nor can you turn an instance into an instance of some other class. So if you want something else, you need to create instances of FUNCALLABLE-STANDARD-OBJECT.
<minion>
Remembered. I'll tell nij- when he/she/it next speaks.
pjb has joined #commonlisp
rtoy has joined #commonlisp
rgherdt has joined #commonlisp
White_Flame has quit [Remote host closed the connection]
ronald has quit [Read error: Connection reset by peer]
White_Flame has joined #commonlisp
<beach>
Also, for what it's worth, I made a decision that, in SICL, all standard functions, and functions defined by DEFUN are instances of (a subclass of) FUNCALLABLE-STANDARD-OBJECT.
<beach>
I could do that because SICL didn't start out as a pre-CLOS Common Lisp implementation.
<jackdaniel>
is there a fundamental reason why pre-clos implementations could not retrofit a function from built-in-class to funcallable-standard-object if there was a need for that? (in other words, couldn't you do that now even if sicl had started as a pre-clos common lisp implementation)?
ecraven- is now known as ecraven
<beach>
I am sure it could be done. I suppose the difficulty would depend on how much of the code would be affected, which in turn depends on the modularity.
<jackdaniel>
I see
<beach>
There is also the eternal question of bootstrapping.
<beach>
FUNCALLABLE-STANDARD-OBJECT requires CLOS, and if you need CLOS before you can create your first function, then you have to bootstrap in a particular way.
<beach>
Though perhaps you could wing it with the functions in the beginning.
<jackdaniel>
thinking right now from the perspective of knowing how ecl works - structures that are needed for clos are available from get go (i.e ecl_instance), the necessary information is added later as per requested by clos
<beach>
I see. That might work then.
<jackdaniel>
that means that objects may already be created with such structure even before clos is bootstrapped, without much issue
<beach>
Yes, I understand. That qualifies as "wining it" in my previous uttering.
<beach>
winging it.
<beach>
*sigh*
<beach>
It might in fact be more difficult to do in a Common Lisp implementation written mostly in Common Lisp, than in one that is written partly in something like C.
<jackdaniel>
and, if you think about it, everything in cl is of some class, so some variation of such technique is inevitable if the implementation does not have clos from the beginning
attila_lendvai has joined #commonlisp
<beach>
Maybe so. I see the SICL bootstrapping technique as doing it a bit differently. It uses the host CLOS in the initial phase.
<beach>
But that's just a matter of point of view.
<jackdaniel>
sure, I was just curious whether there is something I'm missing (vide "fundamental reason" question)
<beach>
I don't think so.
<beach>
And, certainly, it can be very handy to have all functions instances of FUNCALLABLE-STANDARD-OBJECT. You could then do things like what nij- wants. :)
<jackdaniel>
I'm missing the purpose they have in mind (subclassing funcallable-standard-object is the most obvious thing to do)
<jackdaniel>
as you have pointed out yourself earlier
<beach>
Yeah, I gave up trying to understand.
igemnace has joined #commonlisp
mingus has joined #commonlisp
jamesmar1inez has quit [Server closed connection]
jamesmartinez has joined #commonlisp
kopiyka__ has quit [Remote host closed the connection]
kopiyka has joined #commonlisp
buffet1 is now known as buffet
<jackdaniel>
(defclass program (pathname stream process funcallable-standard-object) ...) ; that'd be something I suppose
<jackdaniel>
(putting aside that it wouldn't be very useful, just fancy)
Josh_2 has joined #commonlisp
Cymew has joined #commonlisp
bilegeek has quit [Quit: Leaving]
mingus1 has joined #commonlisp
mingus has quit [Ping timeout: 255 seconds]
mingus1 is now known as mingus
<Josh_2>
GM :sunglasses: :trumpet:
rgherdt has quit [Ping timeout: 240 seconds]
kagevf has quit [Ping timeout: 240 seconds]
kagevf has joined #commonlisp
rgherdt has joined #commonlisp
LW has joined #commonlisp
nij- has joined #commonlisp
edgar-rft has joined #commonlisp
nij- has quit [Ping timeout: 255 seconds]
jmiven_ is now known as jmiven
Krystof has joined #commonlisp
<Josh_2>
and i @preserved-rebuild and it reverted back to 4.4.4
<Josh_2>
wtf
gilberth has joined #commonlisp
czy has joined #commonlisp
habamax has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2)]
chomwitt has joined #commonlisp
LW has quit [Quit: WeeChat 3.8]
ec_ has quit [Ping timeout: 240 seconds]
<chomwitt>
Hi . I dont understand the logic of (cons (cons 'foo nil) (cons 'zoo nil)) giving the list ((FOO) ZOO) and not a cons cell with each of it's two parts pointing to a list.
ec_ has joined #commonlisp
<jackdaniel>
a proper list is a cons of a list and nil
<jackdaniel>
so ((foo) zoo) is (cons (cons 'foo nil) (cons 'zoo nil))
<beach>
chomwitt: It *is* a CONS cell with each of its two parts being a list.
<jackdaniel>
or (list (list foo) zoo)
<beach>
chomwitt: Try taking the CDR of that result: (cdr (cons (cons 'foo nil) (cons 'zoo nil))) and you an see that the CDR is a list.
euandreh has quit [Ping timeout: 260 seconds]
<beach>
chomwitt: It could have been printed ((FOO) . (ZOO)), but the printer prints that as ((FOO) ZOO).
<chomwitt>
beach, ((FOO) . (ZOO)) is what i would expect having read so far a couple of intro docs
euandreh has joined #commonlisp
<beach>
chomwitt: Then you are not expecting what the Common Lisp printer does and is supposed to do.
<jackdaniel>
,(quote ((foo) . (zoo)))
<ixelp>
(quote ((foo) . (zoo))) => ((FOO) ZOO)
<chomwitt>
is it ok to post a link to an image hosting website (with javascript) with a cons diagram of my understanding ?
<beach>
chomwitt: The printer chooses to print as list notation whenever possible, and resorts to dotted notation only when necessary.
<jackdaniel>
I think that your understanding is correct, it is a matter of how the repl prints such cons
<jackdaniel>
i.e (1 2 3 . nil) will be printed as (1 2 3), and ((foo) . (zoo)) is ((foo) zoo . nil) and that is ((foo) zoo)
<jackdaniel>
that's just a matter of notation, not that these structures are different
<chomwitt>
i need some minutes to wrap my mind around your explanations and do some repl testing.
<Josh_2>
ah rip just realized I wrote in the wrong chat earlier
<Josh_2>
sorry about that
alcor has joined #commonlisp
<ogamita>
chomwitt: you may try: (com.informatimago.common-lisp.picture.cons-to-ascii:print-conses (cons (cons 'foo nil) (cons 'zoo nil))) and (com.informatimago.common-lisp.picture.cons-to-ascii:draw-list (cons (cons 'foo nil) (cons 'zoo nil)))
<ogamita>
chomwitt: notably the second one should show clearly how the 3 conses created make a list of 2 elements, the first one being a list of 1 element.
<ogamita>
chomwitt: also, I'd adivse you to configure another font, more readable and perhaps bigger, so you may identify me as ogamita, not oranela ;-)
<chomwitt>
i will try it.
nij- has quit [Ping timeout: 268 seconds]
kevingal has joined #commonlisp
azimut has joined #commonlisp
kevingal has quit [Ping timeout: 240 seconds]
mingus has quit [Ping timeout: 255 seconds]
Gleefre has quit [Remote host closed the connection]
mingus has joined #commonlisp
Gleefre has joined #commonlisp
kevingal has joined #commonlisp
Josh_2 has quit [Ping timeout: 268 seconds]
waleee has joined #commonlisp
pve has joined #commonlisp
Josh_2 has joined #commonlisp
mgl has joined #commonlisp
gascown has joined #commonlisp
Oddity has quit [Ping timeout: 240 seconds]
mgl has quit [Quit: Client closed]
attila_lendvai has quit [Ping timeout: 240 seconds]
<chomwitt>
That took me more that a few minutes. I think jackdaniel's ' it is a matter of how the repl prints such cons' is my 'mental anchor' now. And i see how a list is a chain of cons cells ending in a nil .And that presenting that as list string means that that last NIL of my example will be intepreted as the closing end rigth parentheses of the list. But if we dont give that semantics to what we see (mentally doing a traversal
<chomwitt>
towards the final nil) then we can say that we have a cons cell pointing pairwise in two lists. So interestingly it seems that the way we process the same underlyiyg byte-structure alters the semantics and the ((FOO) ZOO) represents the 'list'way of traversing-seeing the underlying data. Anq ( (FOO) . (ZOO) ) could be misleading since the closing ')' now dont have the semantins of the ending of a sequential traversal.
random-nick has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
mingus has quit [Ping timeout: 240 seconds]
green_ has quit [Ping timeout: 240 seconds]
habamax has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.2)]
mingus has joined #commonlisp
Everything has quit [Server closed connection]
Everything has joined #commonlisp
<pve>
hayley: Is my understanding correct that your slime hack displays types that have been declared with (declaim (ftype ...) ...)?
tyson2 has joined #commonlisp
Josh_2 has quit [Ping timeout: 246 seconds]
Sario has quit [Quit: WeeChat 3.0]
Sario has joined #commonlisp
pranavats has joined #commonlisp
green_ has joined #commonlisp
* chomwitt
is sorry about mispelling ogamita
therepl has joined #commonlisp
kevingal has quit [Ping timeout: 255 seconds]
herjazz has quit [Quit: leaving]
<therepl>
hello
<beach>
Hello therepl.
<beach>
chomwitt: If you are learning Common Lisp, I can recommend #clschool. This channels is not really for newbie questions, though they are tolerated to some extent, especially if things are otherwise quiet.
<beach>
therepl: Are you new here? I don't recognize your nick.
<beach>
Same with chomwitt actually.
<chomwitt>
beach, ok.
<therepl>
beach: probably. I have perhaps visited this channel before but only to lurk. I am a regular in #emacs though. do elisp programming for my Emacs. getting into common lisp now.
<beach>
therepl: I see.
<therepl>
my first question. i hope it is not too offtopic. what is a good language to implement your own lisp. I want to implement my own lisp to help myself learn programming language development.
<beach>
therepl: It depends on your goal. The best language for implementing Common Lisp is Common Lisp, since it's the best language for many things.
<beach>
therepl: But that's "best" in terms of software engineering.
<beach>
So perhaps you have other objectives.
<beach>
therepl: It also depends on whether you want a slow but simple implementation, or an optimizing compiler.
<beach>
Stuff like that.
<therepl>
yes, my objectives are to have as much less magic below me as possible. so I thought C to implement my first Lisp so I know where every piece of data goes. and there will be no garbage collection magic.
<therepl>
but I wanted to take some recommendations from this channel before I start my journey
<beach>
I didn't mean to suggest that you would use the host Common Lisp facilities in your target implementation. You would write your own garbage collector and code generator in Common Lisp with my suggestion.
<therepl>
I want a slow but simple implementation
<hayley>
There are...interesting contortions involved in implementing Lisp runtime stuff in C. (I got back to working on SBCL yesterday.)
ezakimak has quit [Server closed connection]
ezakimak has joined #commonlisp
<beach>
therepl: I recommend you watch my videos on "Creating a Common Lisp implementation". They will tell you all the problems with starting with a lower-level language like C.
<therepl>
beach: how does that work in practice? my implementation pre-allocates memory or something like that? is that possible in common lisp?
<hayley>
And by "programming language development" do you want to practice design, implementation, or both?
<beach>
No, the host Common Lisp implementation would not be present at run time in your target Common Lisp implementation. You just generate an executable that is independent of the host.
<therepl>
*no-defun-allowed*: implementation mostly, a little bit of design. I will keep my first implementation a toy lisp. not too many features. but i want to see the whole thing working end-to-end.
<therepl>
beach: I thought CL runtime is always present when a CL "app" runs. I thought that is one of the appeals of CL, that one can save the image, load the image, connect to a live running image, so on. Is there a way to run a CL app without the CL runtime?
<hayley>
My favourite co-author and I use an interpreter written in Common Lisp so that we can change the design quickly. For that purpose an implementation in a low-level language would slow us down with irrelevant details.
<beach>
therepl: If you generate an executable file with the bits in it that lack the host run-time then all you have is an OS executable.
<therepl>
found your video. the slides are latex + beamer?
<beach>
therepl: The Common Lisp application would be a compiler that runs in the host and spits out bits.
<beach>
Yes.
nij- has joined #commonlisp
<beach>
therepl: But the compiler would then also compile itself and add the bits of itself to that executable.
<nij->
defstar seems to be a wrapper that write (declare..) forms automatically. But as beach pointed out ~10 hours ago that is not really a safe way to do stuff.
<minion>
nij-, memo from beach: You can't have both. DEFUN creates an instance FUNCTION which is a system class, so you can't subclass it, nor can you turn an instance into an instance of some other class. So if you want something else, you need to create instances of FUNCALLABLE-STANDARD-OBJECT.
<nij->
Oh, I see. Thanks, minion beach.
<beach>
Pleasure.
<hayley>
We intend to write a metacircular implementation, once the design settles down, with an optimising compiler and an efficient garbage collector.
<nij->
Hmm.. is the function (lambda () ()) also of system class?
<therepl>
beach: thanks for all the info
<nij->
I wonder how I can define a funcallable standard object without using defun and lambda...
<beach>
therepl: Sure. Good luck. And feel free to ask more such questions.
<hayley>
therepl: You might enjoy the paper "Demystifying magic: high-level low-level programming" which outlines an interesting way to get the bits between one's feet, while remaining in a high level language.
<beach>
therepl: For your information, a lot of implementation discussion goes on in #sicl. SICL is a project to create modules to implement Common Lisp, and also a Common Lisp implementation written entirely in Common Lisp.
<beach>
nij-: Use MAKE-INSTANCE and SET-FUNCALLABLE-INSTANCE-FUNCTION (is that the name?)
<gilberth>
Are you sure it would always look just like that with every implementation? Is it specified that way?
<bike>
No, it's not
<mgl>
The 5 implementation I tried so far agree on this implementation detail.
<bike>
in practice i don't think anybody does any different, though
Enapiuz[m] has joined #commonlisp
<mgl>
bike: I'm adding a SETF locative to PAX.
surabax[m] has joined #commonlisp
therepl has joined #commonlisp
infra_red[m] has joined #commonlisp
<gilberth>
Yes, the seven I tried do as well.
<gilberth>
But it's yet another missing piece of CL in terms of introspection.
<beach>
Perhaps there is a compatibility library for it.
<beach>
If not, perhaps someone could create such a library.
<bike>
i don't think there's a library. setf expanders get a bit complicated, like sbcl has different kinds of expander for define-setf-expander, defsetf, and structure accessors last i checked
<mgl>
On the other hand, (fdefinition '(setf documentation))
<beach>
mgl: Why is that specific to generic functions?
<mgl>
I mean, FDEFINITION doesn't work with DEFSETF defined stuff.
<mgl>
(but it does for defgeneric (setf documentation))
<beach>
mgl: It doesn't have to be a generic function.
<mgl>
Ah, I see. Sorry. Yes.
azimut_ has joined #commonlisp
azimut has quit [Remote host closed the connection]
<ecraven>
is there a way to tell slime to put the output of one statement into a separate emacs buffer? like (with-output-to-emacs-buffer "foo" ...)?
msavoritias has joined #commonlisp
nij- has quit [Ping timeout: 240 seconds]
hayley has joined #commonlisp
hayley has quit [Changing host]
Fade has quit [Remote host closed the connection]
kevingal has joined #commonlisp
<Nilby>
I think the best language for implementing Lisp for deep understanding is PDP-10 macro assembly.
Fade has joined #commonlisp
nij- has joined #commonlisp
<Equill>
Not IBM 704?
<alcor>
IBM 5100 is the best, it even had an APL implementation
<Nilby>
PDP-10 is cleaner. IBM 704 has weird registers and strange formats which cloud the issues. They both have 36 bit words, which is nice.
<gilberth>
The IBM 704 has those forwarding pointers which make my brain hurt. When a word is read from memory and a certain bit is set in that word, it is taken as a pointer and followed. Does the PDP-10 also have this? In general, being somewhat interested into history of ISAs I wonder why they made it that way.
<ecraven>
yes
<ecraven>
the INDIRECT bit
<gilberth>
Ouch.
<ecraven>
to my understanding, there's no limit to the number of indirections it will follow
<ecraven>
if you're interested in pdp-10, there's #pdp-10, where many much more knowledgeable people than me hang out ;)
<Nilby>
I find the old Maclisp code quite interesting
<ecraven>
I've been looking at a lot of Zetalisp and Interlisp, it is interesting to see the differences and similarities
<ecraven>
I haven't gone back to Maclisp yet ;)
Fade is now known as Fade
<ecraven>
however, https://github.com/PDP-10/its makes it simple to run ITS, it includes emacs and maclisp, I believe
<ixelp>
GitHub - PDP-10/its: Incompatible Timesharing System
<Nilby>
just don't look at the old TECO emacs code 🤮
nij-_ has joined #commonlisp
<nij-_>
o/
azimut_ has quit [Remote host closed the connection]
<nij-_>
Oh nice I'm connecting via phone :)
azimut has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
nij-_ has quit [Remote host closed the connection]
nij-_ has joined #commonlisp
nij-_ has left #commonlisp [#commonlisp]
nij-_ has joined #commonlisp
nij-_ has left #commonlisp [#commonlisp]
nij-_ has joined #commonlisp
nij-_ has left #commonlisp [#commonlisp]
nij-_ has joined #commonlisp
nij-_ has left #commonlisp [#commonlisp]
nij- has quit [Quit: Using Circe, the loveliest of all IRC clients]
nij- has joined #commonlisp
rgherdt_ has joined #commonlisp
rgherdt has quit [Ping timeout: 240 seconds]
nij- has left #commonlisp [#commonlisp]
nij- has joined #commonlisp
<nij->
:)
Helmholtz1 has joined #commonlisp
<Helmholtz1>
How to write this function? `The function row will take a board and a row number and should return an array of the elements in that row.` e.g. : `(row #2A((1 2 3) (4 5 6) (7 8 9)) 1) ; => #(4 5 6)`
nij- has quit [Remote host closed the connection]
<Helmholtz1>
we can assume board is a 2d array.
<Helmholtz1>
(defun row (board row-num))
<beach>
(coerce 'vector (loop for i from 0 below (array-dimension board 1) collect (array board row-num i))) something like that.
<beach>
er, collect (aref board rown-num i) I mean
<Helmholtz1>
so this coerce solution is the idiomatic cl for this
<Helmholtz1>
?
<beach>
LOOP can not collect into a vector, so that's one solution.
<beach>
You can also create an explicit vector and fill it in.
<Helmholtz1>
yes that's what was my first idea but it seems very manual. In Matlab this would be easier (and I assume Julia too)
<beach>
Yeah, let's write a new version of the Common Lisp standard.
<Helmholtz1>
by the way, try this out in GPT...it can't solve it!
<Helmholtz1>
couldn't try it on GPT4 though...would have been a good test
<beach>
For the particular case of a row, you can also create a displaced array.
<beach>
But don't expect Common Lisp to have specialized operators for arrays like Matlab does, just like you wouldn't expect Matlab to have good facilities for (say) method combinations (just a guess, I don't know Matlab).
<beach>
But I am sure you can find a Common Lisp library that provides additional operators for arrays.
<ixelp>
iterate, the extensible iteration construct
Cymew has quit [Ping timeout: 255 seconds]
msavoritias has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
<therepl>
*no-defun-allowed*: thanks for the "demystifying magic" recommendation
<mgl>
For the record, using (NTH-VALUE 3 (GET-SETF-EXPANSION `(,SYMBOL))) to tell whether SYMBOL has a setf expansion doesn't work in general because GET-SETF-EXPANSION may fail due to either DEFINE-SETF-EXPANDER or the macro named by the value of SYMBOL failing (e.g. with an insufficient number of arguments).
<therepl>
beach: SICL sounds very intriguing. so I could replace my SBCL usage with SICL and portable code should still work fine?
<beach>
therepl: Ultimately, yes I hope so. But it is not finished.
<beach>
therepl: Consider it a project rather than an implementation for now.
<therepl>
ok. very interesting still
<beach>
therepl: We are working hard to define those modules that the specification mentions, so that they can be used by people like you, who are planning to write a new Common Lisp implementation.
<therepl>
awesome.
eddof13 has joined #commonlisp
anton_5[m] has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 255 seconds]
amb007 has joined #commonlisp
waleee has quit [Quit: WeeChat 3.8]
NotThatRPG has quit [Ping timeout: 240 seconds]
mgl has quit [Quit: Client closed]
attila_lendvai has joined #commonlisp
Inline has joined #commonlisp
mathrick has quit [Remote host closed the connection]
NotThatRPG has joined #commonlisp
overclucker has quit [Ping timeout: 268 seconds]
bjorkint0sh has quit [Remote host closed the connection]
chomwitt has quit [Remote host closed the connection]
bjorkint0sh has joined #commonlisp
overclucker has joined #commonlisp
overclucker_ has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
overclucker has quit [Ping timeout: 240 seconds]
overclucker has joined #commonlisp
overclucker_ has quit [Ping timeout: 268 seconds]
kevingal has quit [Ping timeout: 256 seconds]
zephyr has quit [Server closed connection]
mathrick has joined #commonlisp
zephyr has joined #commonlisp
kevingal has joined #commonlisp
mathrick has quit [Remote host closed the connection]
Helmholtz1 has quit [Ping timeout: 256 seconds]
rgherdt_ is now known as rgherdt
mathrick has joined #commonlisp
matt` has joined #commonlisp
jonatack has quit [Quit: WeeChat 3.8]
jrm has quit [Server closed connection]
jrm has joined #commonlisp
kevingal has quit [Ping timeout: 246 seconds]
nij- has joined #commonlisp
Oddity has joined #commonlisp
nij- has quit [Remote host closed the connection]
jonatack has joined #commonlisp
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
amb007 has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
dcb has joined #commonlisp
mathrick has quit [Ping timeout: 260 seconds]
mathrick has joined #commonlisp
NotThatRPG has joined #commonlisp
comborico1611 has joined #commonlisp
notzmv has quit [Read error: Connection reset by peer]
tyson2 has joined #commonlisp
<Gleefre>
jackdaniel: By the way, I caught phoe that day about PLN
tyson2 has quit [Remote host closed the connection]
<Gleefre>
He said he won't write it now, maybe later, so I though I will write something myself [and he said he'll take a look at it]
<Gleefre>
I wrote something, still waiting for the review :/ While at it I also started writing some tests, and I found a weird bug on ECL
<pjb>
That's a conformity bug. After deleting a package, we should not be able to find it. We may still have some reference to it, but not find-package, list-all-packages, etc.
<pjb>
Other packages may have a reference to the deleted package (package-use-list, etc).
<jackdaniel>
I can't put my finger on it, but common lisp packages always felt messy to me
<jackdaniel>
like a poster child of a module and a namespace
<pjb>
clhs delete-package is quite clear.
alcor has quit [Remote host closed the connection]
<Gleefre>
Well, hierarchial packages are messy, usual are much more clear IMHO
<Gleefre>
I guess it's time for sending a bug report... :/
<Gleefre>
(sent it)
<Gleefre>
Anyway, it is quite said bug
<Gleefre>
Can't find a workaround (I need a prefix for the package & nickname with dots and I need to delelete it and redefine...)
<Gleefre>
Ah, no, dots were easily removable
igemnace has quit [Remote host closed the connection]
NicknameJohn has quit [Ping timeout: 255 seconds]
Krystof has quit [Ping timeout: 248 seconds]
<_death>
you can try rename-package with new nicknames list
markb1 has quit [Ping timeout: 246 seconds]
makomo has joined #commonlisp
markb1 has joined #commonlisp
NicknameJohn has joined #commonlisp
<Gleefre>
_death: in this case rename-package fails to remove nicknames as well :(
cross has quit [Server closed connection]
cross has joined #commonlisp
<_death>
another bug to file
karlosz has joined #commonlisp
<Gleefre>
Uh, I won't file another one I guess. I'm pretty sure that's a bug in one place, and even if it isn't - I don't really use ACL, so it is not like I care...
attila_lendvai has quit [Ping timeout: 240 seconds]
pve has quit [Quit: leaving]
aeth has joined #commonlisp
waleee has joined #commonlisp
mgl has joined #commonlisp
rgherdt has left #commonlisp [Leaving]
<tevo>
How much work would it be to portably implement something resembling first-class environments?
<tevo>
I was thinking I could represent symbols as host Lisp's symbols, reimplement the package system, the reader and possibly the printer, and "pass-though" the rest of the CL package to the host implementation
<tevo>
My package system would deal with looking up packages in the appropriate environment, and everything else should fall in place
<tevo>
Would something like that work, or am I missing something?
occ has joined #commonlisp
green_ has quit [Ping timeout: 268 seconds]
occ has quit [Ping timeout: 240 seconds]
<pjb>
tevo: have a look at sicl ( join #sicl ) and see for yourself how much work it is. beach's been working on it for several years already!
<tevo>
SICL intends to implement much more than first-class environments though, no? I was thinking I could just delegate most of that to the host implementation
<tevo>
I'll take a better look at that paper, and maybe play around with SICL's implementation of environments, though
<tevo>
pjb: I see; I'll pop around by the weekend if I have anything to say
<tevo>
Thanks for the pointers, by the way
aeth has joined #commonlisp
tyson2 has joined #commonlisp
habamax has joined #commonlisp
ds9soft has joined #commonlisp
aeth has quit [Ping timeout: 260 seconds]
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
green_ has joined #commonlisp
LW_ has quit [Ping timeout: 260 seconds]
LW_ has joined #commonlisp
<bike>
tevo: some parts of first class environments aren't part of the standard, e.g. there's no standard way to check if a symbol is proclaimed special. first class environments do let you get at this information, so you'd need some kindn of portability interface at least.
<bike>
if you mean implementing your own environments, independent of the implementation, that exists as Clostrum
NotThatRPG has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 246 seconds]
amb007 has joined #commonlisp
occ has quit [Ping timeout: 240 seconds]
ds9soft has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
LW_ has quit [Quit: WeeChat 3.8]
bike has quit [Ping timeout: 240 seconds]
mgl has quit [Quit: Client closed]
Demosthenex has quit [Server closed connection]
Demosthenex has joined #commonlisp
NicknameJohn has quit [Read error: Connection reset by peer]
green_ has quit [Remote host closed the connection]
green_ has joined #commonlisp
Gleefre has quit [Ping timeout: 245 seconds]
BierLiebHaber has quit [Ping timeout: 246 seconds]