MerlinTheWizard has quit [Ping timeout: 244 seconds]
montxero has quit [Remote host closed the connection]
shifty has joined #lisp
Oladon has quit [Quit: Leaving.]
MerlinTheWizard has joined #lisp
Bike has quit [Quit: Lost terminal]
Oladon has joined #lisp
wxie has joined #lisp
nwoob has joined #lisp
<nwoob>
I'm trying to become good at programming. So i picked up common lisp, what other things should I take in parallel to improve myself. Please guide me
<nwoob>
just give me some guidance
lxbarbosa has quit [Ping timeout: 265 seconds]
vlatkoB has joined #lisp
<aeth>
nwoob: what are you interested in?
<aeth>
There isn't one common piece of advice here. Some people love web stuff because they can get instant results. Some people love game stuff because they think it's fun. Other people wouldn't want to touch either.
<aeth>
You just have to do something entertaining enough to keep doing it.
<aeth>
This is subjective.
<aeth>
You should probably juggle several projects simultaneously so you never get stuck, though.
<nwoob>
I generally want to become good in computer science. Should I learn basics of language and move to algorithms aeth
<aeth>
If you want to learn programming languages, you should probably start with a simple esolang.
<aeth>
Literally everyone has written a Brainfuck compiler or interpreter at some point. It's designed to be very easy to implement (e.g. each command is one character).
<aeth>
(Not a very useful language to use, though, but other people have written programs that can be used as test programs.)
<aeth>
In Lisp, you can use eval/apply to write a simple interpreter without having to worry about parsing a new syntax.
<aeth>
So that's an alternative you can do.
<aeth>
There are lots of toy Lisps.
<nwoob>
I want to stick to CL for language, I have some exp in javascript. I'm not completely new to programming. I lack logic
<beach>
nwoob: I recommend reading up on abstract data types and then implementing them in Common Lisp.
<nwoob>
cool will do that beach
<beach>
Abstract data types are totally essential in computer science, and they will make a huge difference on the performance of your code.
Bourne has quit [Remote host closed the connection]
<beach>
nwoob: But be careful, books (even my famous authors) sometimes contain sub-optimal or even incorrect algorithms for such data types.
<beach>
nwoob: So when you have a design, don't hesitate to show it here.
<nwoob>
definitely, I seek advice from you guys
<beach>
nwoob: Now, learning Common Lisp is a big project in itself. In particular, learning to use generic functions and standard classes is going to take you some time.
<aeth>
nwoob: Sorry, I didn't mean not using CL, I meant that one of the projects you could do is something like this: (defun eval* (form) (case (car form) (list ...
<aeth>
i.e. a toy Lisp interpreter written in CL
<nwoob>
i'll try that aeth once I get enough knowledge
<beach>
nwoob: Implementing abstract data types will exercise your knowledge in modularity as well. It will teach you how to separate interface and implementation.
<aeth>
no-defun-allowed: Well, no, because what you should do is this (and I don't see why people say that it's hard!): (defun eval* (form) (eval form)) (eval* '(list 1 2 3)) => (1 2 3)
<no-defun-allowed>
Sure.
<aeth>
but, yeah, hash table environments or something like that could work
<beach>
aeth: You need the environment if you want to call your evaluator inside a function, which typically has an augmented environment that your need to create yourself.
<aeth>
beach: good point
<no-defun-allowed>
You also need to be able to create environments that can be extended without changing the first, so a hash table won't do (unless you get cheeky and say that (gethash #:some-random-key environment) is the parent).
<beach>
Exactly.
<beach>
A hash table will work only for the global environment.
MerlinTheWizard has quit [Ping timeout: 240 seconds]
<beach>
This is very standard evaluator design.
<beach>
Lisp in Small Pieces will tell you all about it.
<aeth>
no-defun-allowed: you're right that it would have to be a chain of hash tables with some special symbol used to refer to the parent
<aeth>
(or putting the hash table in an object with the parent as the other slot)
<no-defun-allowed>
One of my pet peeves with interpreter tutorials is that they basically assume that single environment model for the first (few) prototypes.
gravicappa has joined #lisp
<beach>
no-defun-allowed: What do you mean by an "environment model"?
<no-defun-allowed>
(Not Lisp in Small Pieces or anything reputable though, the blog stuff you would find on someones-name.github.io and that kind of thing.)
<aeth>
oh, and as hinted at in #lispcafe you can also just stick with dynamic variables, too
<aeth>
I think the dynamic variables most naively would just be lists-as-stacks inside the one-hash-table-environment model?
<aeth>
push when there's a new binding, pop when you return from where it was bound
<beach>
No need to pop. Just do non-destructive environment updates.
<aeth>
ah
<no-defun-allowed>
I meant that the environment would just be one map of names to values, and that there would be no way to extend the environment without modifying the original.
<beach>
no-defun-allowed: Ah, OK. I see.
nwoob_ has joined #lisp
nullheroes has joined #lisp
<no-defun-allowed>
This probably is because whoever writes these things introduces the implemented language along with the interpreter, not before it, which I personally think isn't great.
nwoob has quit [Ping timeout: 260 seconds]
<beach>
I see. I must admit that I don't pay much attention to the blog stuff. In fact, whenever someone here announces the intention to write a "toy Lisp interpreter" I go "*sigh* another slow and incorrect implementation of Lisp".
<aeth>
beach: but 5 failed and possibly incomplete toy Lisp interpreters is one of the routes an implementor can take to getting the knowledge required to being a serious implementor
<no-defun-allowed>
Then they are able to skimp out on writing a proper environment for a while, but I just wonder why you would lead someone to write something that they will later find out is incorrect.
<no-defun-allowed>
beach: I can't disagree, but sometimes I get really bored and take a look.
<aeth>
no-defun-allowed: they're probably trying to replicate the process of actually writing such project by oneself, which does lead to several dead-ends
<beach>
Maybe. I never felt the desire. I mean, I implemented a Lisp interpreter once, but it was not a toy. It was a necessity for my work at the time. After that, I have concentrated on compilers, which require some more knowledge.
<aeth>
well, imo there are many routes to the same thing
<aeth>
but I've personally preferred to compile to CL (or to the string representation of some other language) rather than to interpret, which is why I made some basic errors in describing environments
<aeth>
When you compile to CL, you can just use lambdas
<no-defun-allowed>
aeth: Then it interleaves language and implementation design, which are separate exercises. If one implements a "real" language standard, they don't get to do the former, and it's also a little dishonest to just throw in what was easy to add to your implementation into the language.
<beach>
I found John Allen's book immensely useful, and a great inspiration.
<no-defun-allowed>
But again, just a pet peeve. All I needed to say was "aeth: That should be (defun evaluate (form environment) ...)"
nmg has joined #lisp
<aeth>
no-defun-allowed: lambdas are often a good enough way to represent lexical scope in general... at least if it is a Lisp-1 or a language that is conceptually the same thing (and programming languages most are)... the difficulty/complexity comes with the global environment, especially a mutable global environment with something like a REPL
<aeth>
s/most are/mostly are/
<aeth>
and since symbols are namespaced, you don't get the issue that #lisp discussed recently about LET not perfectly mapping to LAMBDA because of things like &rest, e.g. this is fine if you're in a package that doesn't (:use #:cl) directly: ((cl:lambda (x y &rest z) (cl:values x y &rest z)) 1 2 3 4)
<aeth>
interestingly, SBCL gives a style warning: "suspicious variable &REST in lambda list: (X Y &REST Z)."
mixfix41 has joined #lisp
<aeth>
The main complicating factor is that the generated symbol names probably won't interop well with Common Lisp because CL by default upcases. If your target language is CamelCase there's no way around this, but if it is kebab-case or snake_case you could just invert case (and if snake_case, turn _ into - for the internal representation)
whythat has joined #lisp
<aeth>
but any string can name a symbol, so I think you can compile any language to CL, although obviously not every one will be friendly enough to be able to use cl:lambda
whythat has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
rpg has joined #lisp
wxie has joined #lisp
ralt has joined #lisp
MerlinTheWizard has joined #lisp
_whitelogger has joined #lisp
nwoob_ has quit [Quit: Lost terminal]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
hugh has joined #lisp
pve has joined #lisp
sdumi has quit [Ping timeout: 258 seconds]
sdumi has joined #lisp
red-dot has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
roelj has quit [Remote host closed the connection]
hugh has quit [Quit: hugh]
hugh_marera has joined #lisp
igemnace has joined #lisp
heisig has joined #lisp
MerlinTheWizard has quit [Ping timeout: 260 seconds]
duncan_ has joined #lisp
<phoe>
morniiing
sdumi has quit [Ping timeout: 272 seconds]
hugh_marera has quit [Remote host closed the connection]
sdumi has joined #lisp
<no-defun-allowed>
Hello phoe
Fare has quit [Remote host closed the connection]
<beach>
Hey phoe.
Patzy has joined #lisp
<selwyn>
good morning
rgherdt has joined #lisp
Patzy has quit [Client Quit]
fourier has joined #lisp
Patzy has joined #lisp
<beach>
Hey selwyn.
shka_ has joined #lisp
gko has quit [Ping timeout: 272 seconds]
fourier has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
fourier has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
decent-username has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
ljavorsk has joined #lisp
sdumi has quit [Ping timeout: 272 seconds]
dale has joined #lisp
ljavorsk has quit [Ping timeout: 258 seconds]
<pve>
hi
<pve>
I'm writing a smalltalk-like mini-language, where I translate calls to "super" into (call-next-method ...).
ralt has quit [Quit: Connection closed for inactivity]
<phoe>
pve: okay
<pve>
Given how call-next-method works, if we're defining a method "foo", then it only makes sense to call "super foo" within the method definition (compared to say, "super bar" which wouldn't make sense).
<pve>
There are two ways to define new methods, either using the languages own syntax or using a define-method macro.
<pve>
It's in the define-method macro that I've hit a problem.
<pve>
I would like define-method to be able to communicate the name of the "current method" to any super calls inside the method body so that an error might be signalled at macroexpansion time if an invalid call to super is made.
<pve>
Currently I just setf a dynamic variable while expanding define-method, but that seems hacky. Is there a cleaner mechanism for this, or would I need to walk the code of the body looking for these super calls?
<phoe>
sounds like a case that a dynamic variable might solve.
<pve>
yes
<pve>
I guess it's not really an issue, but I assume it's not thread-safe?
jeosol has quit [Remote host closed the connection]
<phoe>
if each thread has its own dynamic bindings then there's no chance for collisions
<phoe>
don't treat the variable as a global that you set, treat the variable as a dynavar that you rebind
void_pointer has joined #lisp
<pve>
I just don't know how to bind the variable so that macros expanding inside the body of the method are able to see it
<phoe>
ooh, you want a macroexpansion-time error
<phoe>
you could use the symbol-macrolet hack for that
<pve>
I would like a macroexpansion-time error, although I could fallback on a runtime error
<pve>
hmm
void_pointer has quit [Client Quit]
Inline has joined #lisp
<pve>
So I would symbol-macrolet the symbol super into something..
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<phoe>
pve: the basic technique is: use a magic global variable, symbol-macrolet it in the lexical environment of the outer macro, and then macroexpand-1 it in the inner macro while passing the environment variable
<phoe>
this allows macros to communicate at macroexpansion-time in lexical scope
<phoe>
s/in the lexical environment/in the expansion/
fourier has quit [Ping timeout: 240 seconds]
<pve>
I've never done that, but it sounds promising. I will need to ponder this for a while.
<pve>
Thank you for your help
<phoe>
Bike posted a snippet yesterday that shows how to achieve compiler-macrolet that way
<MichaelRaskin>
Disappointment: in my paper I complained we don't have a good name for the scope of such trick, and this post also does not try to name it
<pve>
That's very clever, it may be just what I need to make this work.
<phoe>
it's called better-compiler-let
grumble has quit [Quit: The bacteria inside Neil Armstrong were the first non-human life to land on the moon. And Neil Armstrong was their space suit.]
grumble has joined #lisp
pjb has quit [Ping timeout: 260 seconds]
rogersm has joined #lisp
ralt has joined #lisp
sdumi has joined #lisp
<pve>
phoe: yess, it works
<pve>
I will admit, it would have taken me a loong time to come up with that on my own
<phoe>
I wouldn't have figured it out on my own
<phoe>
unless I maybe studied the way of the &environment real hard
<MichaelRaskin>
Yes, studying the macro expansion does lead to writing about this, can confirm
<MichaelRaskin>
And otherwise it is easy just not to remember local macros exist
turona has quit [Quit: ...]
<eta>
how do I call a subprocess on SBCL and write binary data to its stdin?
<phoe>
eta: sounds like a use case for UIOP:LAUNCH-PROGRAM and/or UIOP:RUN-PROGRAM
sdumi has quit [Read error: Connection reset by peer]
cpt_nemo has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
cpt_nemo has joined #lisp
<eta>
phoe: those don't allow me to supply binary data
<eta>
and in fact, it seems like SBCL always will give you character streams, which sucks
<eta>
(looking at how SB-EXT:RUN-PROGRAM is implemented)
<pjb>
(define-method foo (…) (list (send-message super foo) (send-message super bar) (send-message other foo) (send-message other bar) ))
<pve>
pjb: yes, I think that could work too
akoana has quit [Quit: leaving]
random-nick has joined #lisp
karlosz has quit [Quit: karlosz]
wxie has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
Inline has quit [Remote host closed the connection]
_whitelogger has joined #lisp
fourier has quit [Ping timeout: 260 seconds]
SGASAU has joined #lisp
Inline has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
dhandar has joined #lisp
rpg has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU` has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
Lord_of_Life_ has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
SGASAU` has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
SGASAU` has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
dhandar has quit [Ping timeout: 245 seconds]
bendersteed has quit [Quit: bye]
sfa has joined #lisp
whythat has joined #lisp
gko has joined #lisp
sfa has quit [Quit: leaving]
ljavorsk has joined #lisp
ChoHag has quit [Ping timeout: 244 seconds]
wxie has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
Fare has joined #lisp
dhandar has joined #lisp
jonatack has quit [Ping timeout: 272 seconds]
ChoHag has joined #lisp
Bike has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
McParen has joined #lisp
sdumi has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
EvW1 has joined #lisp
<scymtym>
eta: in SBCL, a process stream created with :input :stream is bivalent: (let* ((p (sb-ext:run-program "xxd" '() :input :stream :output *standard-output* :search t :wait nil)) (s (sb-ext:process-input p))) (write-sequence (vector 1 2 3 ) s) (close s) (sb-ext:process-wait p))
dhandar has quit [Remote host closed the connection]
joshcom has joined #lisp
joshcom has left #lisp [#lisp]
kpoeck has joined #lisp
dhandar has joined #lisp
ChoHag has quit [Ping timeout: 260 seconds]
ChoHag has joined #lisp
<eta>
scymtym: ah I see, thank you! I guess UIOP:RUN-PROGRAM is doing something wrong then, since I was calling it with :input <octet stream>
<Fare>
uiop:run-program may well have bugs, and some of its behavior is not portable.
hylisper has joined #lisp
<eta>
Fare: (isn't the entire point of UIOP to be portable?)
<Fare>
eta: inasmuch as possible, it is.
<Fare>
eta: improvements welcome.
<eta>
Fare: fair enough, thanks for the heads up :)
davehall has joined #lisp
davehall has left #lisp [#lisp]
EvW1 has quit [Ping timeout: 260 seconds]
dhandar has quit [Remote host closed the connection]
rogersm has quit [Ping timeout: 240 seconds]
elflng has quit [Quit: Lost terminal]
dale has quit [Quit: My computer has gone to sleep]
jonatack has joined #lisp
fourier has joined #lisp
SGASAU` has quit [Remote host closed the connection]
jayspeer has joined #lisp
elflng has joined #lisp
ljavorsk has quit [Ping timeout: 260 seconds]
SGASAU` has joined #lisp
ayuce has joined #lisp
jrx has joined #lisp
ljavorsk has joined #lisp
shifty has joined #lisp
nmg has quit [Ping timeout: 260 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
whythat has quit [Ping timeout: 240 seconds]
jrx has quit [Quit: ERC (IRC client for Emacs 26.3)]
whythat has joined #lisp
lxbarbosa has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
shangul has joined #lisp
turona has quit [Quit: ...]
wxie has quit [Ping timeout: 265 seconds]
theBlackDragon has quit [Read error: Connection reset by peer]
ljavorsk has quit [Ping timeout: 260 seconds]
theBlackDragon has joined #lisp
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
whythat has joined #lisp
Oladon has joined #lisp
theBlackDragon has quit [Remote host closed the connection]
rogersm has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
stoneglass has joined #lisp
theBlackDragon has joined #lisp
turona has joined #lisp
stoneglass has quit [Client Quit]
whythat has joined #lisp
ArthurStrong has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
stoneglass has joined #lisp
MerlinTheWizard has joined #lisp
mathrick has quit [Ping timeout: 240 seconds]
bitmapper has joined #lisp
<bitmapper>
i keep wondering why there isn't a version of format for symbols
renzhi_ has joined #lisp
<beach>
What?
<Bike>
alexandria has format-symbol.
<bitmapper>
oh!
q3d has joined #lisp
<phoe>
was about to suggest that
<bitmapper>
i was writing this
<bitmapper>
(defun concsym (form &rest args)
<bitmapper>
(intern (string-upcase (apply #'format nil form args))))
<bitmapper>
which is kinda usage specific due to the upcase
<phoe>
format-symbol also allows one to explicitly specify package.
<phoe>
bitmapper: you can provide string designators to format-symbol, meaning that symbols are allowed
<beach>
bitmapper: It is highly unusual to want to use INTERN in application code.
<beach>
bitmapper: You are just hiding a dictionary abstract data type, so you might as well implement it with a hash table. That way you can associate any information with the "symbols".
<bitmapper>
beach: the symbols are associated with a variable containing the register number
<beach>
So you do SYMBOL-VALUE to get the register number?
<phoe>
beach: the hash table can be keyed with symbols instead of strings though; no difference there except for hash table test
<Bike>
jmercouris: just remember the basic idea that (expt a (log b a)) = b
<bitmapper>
actually for my usage i might want to use make-symbol
<beach>
phoe: But INTERN does a hash table lookup with a string.
<phoe>
make-symbol generates homeless fresh symbols; that's bad since you won't be able to easily reference them
<bitmapper>
phoe: i know
<bitmapper>
it's kinda weird coming back to CL after writing shen for so long
<phoe>
beach: yes; so for me doesn't seem to matter much in the end, since we look up by strings anyway
<beach>
Right.
<beach>
bitmapper: Though, why do you have strings in the first place if you are using READ to read your instructions?
<phoe>
I mean, that's equivalent, so one might key a hash table via symbols in some package as well as with strings
whythat has joined #lisp
<beach>
I have no problem with symbols.
<bitmapper>
beach: wdym
<phoe>
beach: I suppose his code is like (defmacro define-instruction mov ...) and from MOV he wants to generate MOVI, MOVR, MOVSOMETHINGELSE and so on
<bitmapper>
yep
<bitmapper>
the immediate and non immediate versions of each
<bitmapper>
which only differ slightly
<phoe>
so he doesn't really operate on strings per se; if he uses alexandria:format-symbol he'll abstract the strings away completely except for the format control
<beach>
Yeah, OK, that's not too bad. I thought you used INTERN every time you read an instruction in the assembly code.
<phoe>
if he uses alexandria:symbolicate, he'll even skip the format control
<phoe>
like (alexandria:symbolicate :mov :i) ;=> MOVI
<bitmapper>
oh neat
KDr23 has joined #lisp
dorketch_ has joined #lisp
dorketch_ has quit [Client Quit]
KDr22 has quit [Ping timeout: 256 seconds]
gravicappa has quit [Ping timeout: 265 seconds]
Inline has quit [Ping timeout: 272 seconds]
red-dot has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
Nilby has joined #lisp
q3d has quit [Ping timeout: 245 seconds]
dorketch has quit [Quit: WeeChat 2.7]
ArthurStrong has quit [Ping timeout: 265 seconds]
ArthurStrong has joined #lisp
sdumi has quit [Ping timeout: 240 seconds]
renzhi_ has quit [Ping timeout: 260 seconds]
fourier has quit [Ping timeout: 244 seconds]
efm has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
rogersm has quit [Ping timeout: 240 seconds]
whythat has joined #lisp
Lycurgus has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
refpga has joined #lisp
<ChoHag>
How can I use a pointer as a cstruct when using cffi?
<ChoHag>
A library has returned a buffer and I want to write in it at varying offset.
<ChoHag>
I can find documentation about allocation and conversion, but not (the equivalent of) casting.
rogersm has joined #lisp
<Bike>
you want to cast a pointer to a struct?
MerlinTheWizard has quit [Ping timeout: 240 seconds]
<ChoHag>
I have that bit, it's the casting I need.
<Bike>
as far as i know cffi kind of ignores the types of pointers anyway?
<phoe>
you no longer need to cast in CFFI world
<Bike>
like i thought it just has one pointer type, basically.
<ChoHag>
Something like with-foreign-object, but with the allocation having already happened.
<phoe>
with the allocation... huh?
<Bike>
okay, so you see foreign-slot-pointer?
<phoe>
in CFFI, you allocate memory yourself
<Bike>
i think you just want to use foreign-slot-pointer and then dereference the result.
<Bike>
oh, i guess that's what foreign-slot-value does.
<ChoHag>
phoe: Unfortunately opengl has allocated it for me.
<Bike>
so use foreign-slot-value. right? it takes a pointer to a struct and a slot name. that's what you have.
<ChoHag>
That looks like it might work.
<Bike>
or with-foreign-slots for the higher level version.
<Nilby>
just use with-foreign-slots and give it your pointer
<ChoHag>
hmm
userself has joined #lisp
ralt has joined #lisp
whythat has joined #lisp
Lycurgus has quit [Remote host closed the connection]
gravicappa has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
gko has quit [Ping timeout: 265 seconds]
SGASAU` has quit [Remote host closed the connection]
SGASAU has joined #lisp
KDr23 has quit [Ping timeout: 264 seconds]
MerlinTheWizard has joined #lisp
<ChoHag>
Can I do something like scheme's (define (foo) (define (bar) ...) (bar)) without putting the inner bar in lisp's global namespace or subsequent warnings about redefinition?
<sjl>
ChoHag: yes, with (flet ...) or (labels ...)
renzhi_ has joined #lisp
wsinatra has joined #lisp
whythat has joined #lisp
<ChoHag>
labels is like flet*?
<sjl>
yes
<sjl>
well, depending on what you mean by *. it allows the functions you define with it to reference each other, where flet does not
<heisig>
I think ChoHag means whether flet is to labels as let is to let*. In that case the answer is that labels is even more powerful, because every function therein can call every other one.
rgherdt has quit [Ping timeout: 244 seconds]
<Shinmera>
including itself.
<ChoHag>
Right. When are the new symbols created in the symbol table.
<sjl>
(which is slightly different than let vs let*: in let*, later bindings can "see" earlier ones, but not later ones. in labels, all the bindings are visibile in all the bodies)
fourier has joined #lisp
whythat has quit [Ping timeout: 240 seconds]
nullman has quit [Quit: leaving]
<sjl>
The symbols are interned into the symbol table at read time, but that's probably a red herring. The symbols you use in flet or labels are only given to the compiler so it knows what blocks of code you're referring to -- by the time the code runs the connection between a particular block of code and the symbol you happened to use to name it might be gone.
<sjl>
flet and labels don't change anything about a symbol, like (defun) would set the symbol-function. the symbols are just names used during compilation.
Jesin has quit [Quit: Leaving]
ayuce has quit [Ping timeout: 256 seconds]
wsinatra has quit [Ping timeout: 260 seconds]
wsinatra has joined #lisp
rgherdt has joined #lisp
Jesin has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
Inline has joined #lisp
wsinatra has quit [Ping timeout: 260 seconds]
whythat has joined #lisp
shangul has quit [Quit: Leaving]
wsinatra has joined #lisp
<pjb>
sjl: there are no symbol tables in common lisp.
<pjb>
there are packages…
<sjl>
s/symbol table/package/
whythat has quit [Ping timeout: 240 seconds]
<pjb>
ChoHag: so yes, symbols are interned in package when they are read (and the syntax doesn't prevent them to be interned at all cf. #:foo). But this should not matter, because they can also be created by macros (and interned or not), to be used in expanded forms.
Fare has quit [Ping timeout: 260 seconds]
ArthurStrong has quit [Ping timeout: 260 seconds]
ArthurStrong has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 272 seconds]
Inline has joined #lisp
Jeanne-Kamikaze has joined #lisp
<markasoftware>
are symbols converted to variable values at evalutaion time? And if so, how does the evaluator know which symbols are quoted and which aren't?
<phoe>
markasoftware: do you know the rules of evaluation in Common Lisp?
<phoe>
the evaluator knows which symbols are quoted because, well, they're quoted
<phoe>
let's go for example for (let ((x 'world)) (format t "HELLO ~A" x))
hylisper has quit [Remote host closed the connection]
<phoe>
we go from outside in; first, we have a LET form, which is a special form
<phoe>
inside the variable binding, X is not evaluated; however, 'WORLD is evaluated to produce a value
<phoe>
'WORLD, or (QUOTE WORLD), produces the symbol WORLD when evaluated
<phoe>
so the value of X is now the symbol WORLD
<markasoftware>
quote is a macro, right?
<phoe>
nope, it's a special form
<markasoftware>
ah
<markasoftware>
so the result of a macroexpand can include quotes?
<phoe>
yes! and it often does
<markasoftware>
aha
<phoe>
a QUOTE form is just another Lisp form
<markasoftware>
that must be the magic compiler sauce
<phoe>
it's the magic sauce that fuels the code-is-data-is-code part of Lisp
shifty has quit [Ping timeout: 264 seconds]
<phoe>
other languages have picked up the idea of quoting, quasiquoting, and unquoting things from Lip
<phoe>
Lisp*
<markasoftware>
thank you!
<phoe>
I'll skip evaluating that FORMAT call by hand, since you seem to be satisfied now
<markasoftware>
well the format is a macro that looks at the string during compile time, right?
<phoe>
macro?
<phoe>
no! it's a function
<markasoftware>
well is the formatting string not compiled?
<phoe>
what do you mean, compiled
<phoe>
it's a string
<phoe>
it can be supplied dynamically at runtime
motersen has joined #lisp
<markasoftware>
well you have to do some parsing on the string, if you were doing format in a fast loop you wouldn't want to evaluate it over and over again
<markasoftware>
or maybe i'm mixing this up with rust
<phoe>
FORMAT itself is a function
<phoe>
whatever the compiler does to make it fast is the magic of the compiler
<phoe>
we don't need to care about it if we write standard Common Lisp though
<markasoftware>
sounds good
<markasoftware>
thanks again!
<Grue`>
at least sbcl does check format strings for syntax errors at compile time
<phoe>
yep, but again, that's implementation magic
<Nilby>
Quote seems like the simplest magic: "(quote thing)" => thing , but a plain symbol "symbol" => [the value of symbol looked up in the current environment or the exapansion of a symbol macro... etc], seems more magic.
<jackdaniel>
format is a language on its own terms with crazy syntax
jeosol has joined #lisp
<Grue`>
markasoftware: there's a FORMATTER macro which converts a format string into a function that can be called on format arguments to avoid re-parsing format string every time. in practice if the format string is constant, it will be pre-parsed at compile time by most implementations
<phoe>
jackdaniel: I still don't understand what is wrong about "~:[{~;[~]~:{~S~:[->~S~;~*~]~:^ ~}~:[~; ~]~{~S->~^ ~}~:[~; ~]~[~*~;->~S~;->~*~]~:[}~;]~]"
<jmercouris>
that's with a couple of wikipedia articles, no stopword removal
<jmercouris>
also only a couple of paragraphs from each article
<jmercouris>
also no stemming
refpga has quit [Ping timeout: 256 seconds]
refpga has joined #lisp
rpg has joined #lisp
frgo has quit [Remote host closed the connection]
bars0 has quit [Quit: leaving]
oldtopman has quit [Quit: *poof*]
frgo has joined #lisp
<jmercouris>
it says delete-if is like remove-if but it MAY modify the sequence
<jmercouris>
how do we know when it will and it will not modify the sequence?
<phoe>
don't use DELETE on data you're not allowed to modify
gxt has quit [Ping timeout: 240 seconds]
<jmercouris>
what if i specifically want to modify the sequence
nullman has joined #lisp
<phoe>
if you want to return a new sequence without mutating the old one, use REMOVE
<jmercouris>
i'm saying, what if i want to mutate the old one
<phoe>
if you are allowed to mutate the sequence in question, use DELETE and remember to use the return value
<jmercouris>
so it will just do it for performance
<Odin->
Yes.
<jmercouris>
you cannot force it to modify
<jmercouris>
OK
<jmercouris>
that's always annoyed me
<Odin->
The destructive ones are allowed to do _anything_ to the sequence.
<jmercouris>
alea iacta est
<Odin->
With a couple of exceptions.
<Odin->
Don't remember which ones.
<Odin->
I think the logic behind that is "what if someone discovers a better way to optimise this operation?"
refpga has quit [Ping timeout: 264 seconds]
ljavorsk has joined #lisp
gxt has joined #lisp
refpga has joined #lisp
stepnem_ has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
<Bike>
jmercouris: in some case the sequence may not be modifiable in the right way. for example a simple-vector cannot be shrunk without implementation hacks.
<jmercouris>
Bike: yeah, I meant where legal
<jmercouris>
OK, so I have this problem: I have a list of stop words, and a list of tokens
<jmercouris>
how to iterate through tokens and remove if in list of stop words
Fare has joined #lisp
<Bike>
"modify the sequence if it's a list or an adjustable array or an array with a fill pointer" is kind of messy
<Bike>
i would use remote/delete-if for that
<Bike>
remove
<jmercouris>
list a: (list "I" "am" "the" "forbidden" "potato") list b: "(list "forbidden")
<jmercouris>
therefore remove "forbidden" from list a
<sjl>
set-difference if you don't care about performance, or convert the stop words into a hash table and use remove-if or delete-if if you do
<jmercouris>
no better way than that? it seems very expensive
<sjl>
well, I gues set-different wouldn't work
<jmercouris>
set difference would not work
<sjl>
if you had duplicates in the sentence
<sjl>
so yeah, remove-if with a hash table
McParen has left #lisp [#lisp]
<Bike>
i'm not sure how you would do it less expensively.
<jmercouris>
of course you must look at every element in list a
<jmercouris>
I am thinking about the lookup time of list b
<Bike>
as sjl said, you can use gethash if that's a concern.
<jmercouris>
i could avoid that by turning it into a hash as suggested by steve
<jmercouris>
yes
<Bike>
so pass delete-if a predicate like (lambda (x) (gethash x my-hash-table)).
<jmercouris>
i guess that will have to be so
<jmercouris>
I'll have to make a hash table...
<jmercouris>
is there a (make-hash-table) where I can set initial contents or something?
<Bike>
fraid not
<jmercouris>
how do you usually handle that then?
<Bike>
(loop with ht = (make-hash-table :test #'equal) for stop in stop-words do (setf (gethash stop ht) t) finally (return ht))
<Bike>
maybe you could use perfect hashing instead of a regular hash table.
<pjb>
jmercouris: depends on the implementation. Don't assume it'll be slow.
<jmercouris>
Bike: what is perfect hashing?
red-dot has joined #lisp
<sjl>
Huh, interesting. I didn't realize set-difference will work on arbitrary lists despite its name
<Bike>
hm, actually i'm not sure how that works with misses
<pjb>
sjl: well, define "work". It work as a set operation!!!
<Bike>
jmercouris: it means designing a hash function that works perfectly on a fixed set so that there are no collisions.
<jmercouris>
they are not true set operations in CL
<Bike>
you could also use something like string-case that's used to compare against a fixed set of strings that are known at compile time, if that's how your problem works.
<jmercouris>
they stop words are known at compile time
<sjl>
pjb: I assumed set-difference would be allowed to assume its inputs were sets, and so something like (set-difference '(a a b) '(a)) might return (a b), if it realizes it's see every element in list-2 and returns early
<sjl>
but no, the spec always refers to the as lists
<Bike>
hmmmm does string case have the option of multiple strings per clause
<Bike>
apparently not. that's unfortunate.
<Nilby>
What perfect hashing library is recommended?
<Bike>
i've never actually used perfect hashing
<sjl>
e.g. like UNION says > If either list-1 or list-2 has duplicate entries within it, the redundant entries might or might not appear in the result.
<jmercouris>
i think the hash is the best solution here
<_death>
a regex could work, as "a|b|c|..." could be quite efficient
<Bike>
oh yeah, that would probably work well
<Bike>
and not require you to write more code, that's always a plus
jeosol has joined #lisp
<jmercouris>
i live for cloc
<jmercouris>
just kidding
<jmercouris>
actually you know what it cannot be known at compile time
<jmercouris>
I was just assuming the english language
<jmercouris>
so the hash will have to be it unfortunately
akoana has joined #lisp
<jmercouris>
now I have to make yet another data structure that can be customized...
<Bike>
you could compile the predicate at runtime
<Bike>
like create-scanner in cl-ppcre, if you go the regex route
<jmercouris>
yeah
<pjb>
sjl: the problem is rather that it assumes multisets: (set-difference '(a b b) '(a)) #| --> (b b) |# instead of (b) of a set.
<pjb>
sjl: also, order is not preserved.
<Grue`>
how big is the "list of stop words"? hash table might be inefficient if it's like 10 words
<jmercouris>
its 500 entries
<sjl>
Right. I assumed from the name it would assume sets, but clearly it doesn't according to the spec. So it's fine to use with multisets.
<Bike>
if you think about this enough you will note that this is one of those problems that seems like it should be solved but actually has so many moving parts that you could write a dissertation on it
<jmercouris>
i never assumed it was easy :-)
<jmercouris>
that is why I asked about it
<Bike>
mhm.
<jmercouris>
of course the "solution" to me is trivial
<jmercouris>
i could have worked with lists or a hash table just fine
<sjl>
But yeah, you probably don't want to use set-difference if you want to preserve the order of the non-stopwords in the result.
<Grue`>
you can also have a sorted array and do binary search in it
<sjl>
I'd use the simple hash table approach, and revisit it if profiling ever identifies it as a problem later.
<jmercouris>
yeah that's what i am doing
<jmercouris>
just making an object to wrap around it
<jmercouris>
I have to say common lisp has really changed my programming style, i used to be really heavy into procedural, then into object oriented, then into functional, and now i don't even know what i would say i do
<jmercouris>
i guess i use whatever makes sense for whatever subset of the problem