<aeth>
If you don't want duplicates and you want that enforced, you could use a hash-table or you could use bits in an integer (#b101001110 can be seen as a set if you write the right functions).
<equwal>
also: union intersection and friends.
<whartung>
you could simply add a member check before you add to the list.
<no-defun-allowed>
you could make a btree, i think there's a quicklisp package for it
<aeth>
whartung: The only way to be sure would be to not give the user access to the list at all because they could mutate it outside of the provided functions
<whartung>
well, of course
<figurelisp>
hash-tables, btree all that are way too ahead for me. I am just a beginner
<whartung>
well then don’t listen to us, go forth and “try before you buy” and find out.
<whartung>
we’ll over complicate everything
<whartung>
…and anything
<figurelisp>
:D ok
<no-defun-allowed>
btrees aren't too hard, especially if you give them to someone else to do the complicated parts
<dlowe>
figurelisp: you might be interested in #clnoobs
<figurelisp>
thanks dlowe
<equwal>
Ooooooh he just called you a n00b.
<figurelisp>
i am a noob
<jasom>
figurelisp: hash tables are in the standard, and are better for efficient operations on larger datasets; lists are just fine for small sets (e.g. less than 30 or so)
<figurelisp>
jasom: Thank you, I'll remember it :)
<no-defun-allowed>
iirc for sbcl lists and hashtables are equally fast at around 6 elements
<figurelisp>
but if whole program of lisp is list then why is that efficient?
<aeth>
For large data sets, hash tables are probably the best way that's built into CL
<dlowe>
equwal: being n00b is the first step to 1337ness
<aeth>
(e.g. union is x such that x is in A or x is in B, so you accomplish union by using logior)
nowhereman has joined #lisp
<figurelisp>
so a big lisp program is large dataset of list then why is that efficient?
nowhere_man has quit [Read error: Connection reset by peer]
<equwal>
Because you only have to go through the code a few times to compile it, O(n)
<aeth>
figurelisp: Lists are usually used for small things, prototypes, and macros.
<dlowe>
figurelisp: lisp can operate on many more things than lists. The thing about lisp is that the *code* is lists.
<PuercoPop>
no-defun-allowed: more like ~24 elements
<dlowe>
figurelisp: in most languages, the code is text
<PuercoPop>
Joe Marshal's blog has some benchmarks.
<no-defun-allowed>
really? i remember 6 for ccl and sbcl
<equwal>
figurelisp: In most languages, they convert to a lispy syntax called an "abstract syntax tree" anyway.
<no-defun-allowed>
clisp was more like 30 cause clisp is slow
<PuercoPop>
For 6 alists are faster
<PuercoPop>
And alists have the advantage that you sort them by MRU as you retrieve them
<aeth>
figurelisp: Most speed benchmarks are done with vectors of numbers and other numerical things. Those benchmarks for CL are probably written in SBCL with 1D single-float, double-float, or non-bignum intger arrays. In this case, SBCL is being used basically like a Fortran-with-macros.
<equwal>
aeth: what is an example of a set when using the bit-vector representation?
<aeth>
If you wanted to see if it held foo and bar, you'd represent foo as 10 and bar as 01 and do the union of the two (11) and test with that, so you need a way to map what you're really looking for to bits (or, more usefully, to a set where only one bit value is 1)
<equwal>
That is a great way to do it.
<aeth>
You'd probably do this by having a macro generate a function that uses CASE with a keyword as an input and a set holding only the item represented by that keyword as the return value. e.g. input :foobar and get #b1000 back
<aeth>
You'd want to use integers instead of bit vectors for small values. At some point bit-vectors would be more efficient. Maybe above a few hundred.
<pjb>
equwal: 00000000000000000000000000000000000000000000000000000000101111 is an integer. You want #*00000000000000000000000000000000000000000000000000000000101111
<aeth>
pjb: technically internally it would be #b00000000000000000000000000000000000000000000000000000000101111 or 47, but my print-boolean-set prints it without the #b
<pjb>
aeth: technically, internaly it would be very different from an integer, since it is mutable!
<aeth>
I think even using a few fixnums in parallel would be better than bit-vectors, so the point after which you'd want bit vectors would probably be several hundred values.
<aeth>
pjb: If you use integers you write them as pure functions
nowhereman has quit [Remote host closed the connection]
nowhereman has joined #lisp
<pjb>
figurelisp: lisp programs are not lists. Lisp programs are made of functions.
<pjb>
Like in any other programming language DUH!
<equwal>
pjb lisp programs are definitely lists in a big progn.
<pjb>
Nope.
<aeth>
equwal: Lisp source code is lists. They're compiled into something else.
Kundry_Wag has quit [Ping timeout: 260 seconds]
lumm has quit [Remote host closed the connection]
<aeth>
equwal: In most implementations you can see what they ultimately become with disassemble, e.g. (disassemble #'car)
<equwal>
Well obviously they are compiled into assembly.
<pjb>
Nope.
pierpal has joined #lisp
<pjb>
It's not obvious.
<aeth>
pjb: It's obvious once you run disassemble, if it's functional in your implementation
<aeth>
equwal: If Lisp programs were lists in a big progn at some point, then only the last list would do anything (progn executes the forms in order and returns the final element), e.g. (progn '(+ 1 2) '(+ 3 4) '(+ 5 6)) => (+ 5 6)
<figurelisp>
my lisp code is not a list?
<figurelisp>
I have read that lisp program are list
<figurelisp>
pjb:
<pjb>
figurelisp: you must distinguish the source from the actual program.
<figurelisp>
i don't understand
<equwal>
He is splitting hairs.
<equwal>
Your source code is most definitely a list.
<equwal>
Actually, lists.
<aeth>
not quite
<aeth>
Your source code is read into lists
<Bike>
well, generally it's text, and then it's read in as a bunch of lists, and then a box full of insufferable pedants compiles it into redstone blocks
al-damiri has quit [Quit: Connection closed for inactivity]
<Bike>
i thought the question was about what source code "is"
<pjb>
(nth-value 1 (get-macro-character #\()) --> NIL, so, not non-terminating!
<no-defun-allowed>
( tells the reader to do a thing, much like # or ; so probably
dddddd has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
<equwal>
figurelisp said "so a big lisp program is large dataset of list then why is that efficient?"
<equwal>
I have to wonder what exactly he meant by that. I assumed he meant to ask why it is efficient to compile code from lists.
<Bike>
so they did. that sounds pretty confused.
<pjb>
Who said it was efficient?
<Bike>
figurelisp
<equwal>
It is good enough for any compiler that uses ASTs.
<figurelisp>
someone said hash tables are more efficient than list. I read somewhere that my source code is considered as list in lisp hence the question
<Bike>
saying one is "more efficient than" the other is kind of wacky.
<Bike>
's like saying an orange is better than a sun gear
<figurelisp>
anyway what is a simple answer to "Is my program a list in lisp?"
<Bike>
"no"
<figurelisp>
is (defun add (x) (+ 2 3 x)) a list?
<equwal>
A better way to say it is "if you are searching through a list of size 'n', it is more efficient to use a hash table of size 'n' since they are O(n) and O(log n) respectively.
<Bike>
and probably better, "that's a weird thing to ask"
<Bike>
(listp '(defun add (x) (+ 2 3 x))) => T, at least
<no-defun-allowed>
if lisp programs were hash tables they wouldn't run faster
<equwal>
No, they wouldn't, since you would have to interate over them anyway, O(n) time.
<equwal>
They wouldn't even compile faster.
<Bike>
compiling in linear time would be a neat trick
<Bike>
think you can do that in forth sometimes
<equwal>
What pass of a compiler isn't O(n)?
<Bike>
couple analyses. ssa conversion off the top of my head.
EvW has quit [Ping timeout: 276 seconds]
<equwal>
Neat.
<equwal>
Compilation is fascinating.
sjl has joined #lisp
Kundry_Wag has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
scymtym has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
shka1 has joined #lisp
nicht has quit [Quit: Leaving]
slyrus_ has joined #lisp
Kundry_Wag has joined #lisp
EvW1 has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
<LdBeth>
good afternoon
<no-defun-allowed>
afternoon
gz has quit [Read error: Connection reset by peer]
gz has joined #lisp
swflint has quit [Ping timeout: 276 seconds]
skapata has quit [Remote host closed the connection]
swflint has joined #lisp
nanoz has quit [Ping timeout: 264 seconds]
eli_oat has quit [Ping timeout: 240 seconds]
pagnol has joined #lisp
fikka has joined #lisp
eli_oat has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
loli1 has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
igemnace has joined #lisp
nowhereman has quit [Disconnected by services]
nowhere_man has joined #lisp
orivej has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
Inline has quit [Remote host closed the connection]
on_ion has quit [Quit: WeeChat 1.9.1]
loli1 has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
fikka has quit [Ping timeout: 240 seconds]
eli_oat has quit [Ping timeout: 244 seconds]
eli_oat has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
sauvin has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
_paul0 has joined #lisp
_paul0 has quit [Client Quit]
paul0 has quit [Read error: Connection reset by peer]
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 244 seconds]
igemnace has quit [Remote host closed the connection]
igemnace has joined #lisp
igemnace has quit [Client Quit]
Kundry_Wag has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
vIkSiT has joined #lisp
orivej has joined #lisp
Jesin has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 256 seconds]
smasta has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 268 seconds]
ofi has joined #lisp
smasta has joined #lisp
vIkSiT has quit [Quit: This computer has gone to sleep]
flamebeard has joined #lisp
vIkSiT has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
MrSleepy has quit [Quit: Leaving]
fikka has joined #lisp
eli_oat1 has joined #lisp
eli_oat has quit [Ping timeout: 240 seconds]
eli_oat1 is now known as eli_oat
vIkSiT has quit [Quit: This computer has gone to sleep]
fikka has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
glamas__ has joined #lisp
glamas_ has quit [Read error: Connection reset by peer]
fikka has joined #lisp
smasta has quit [Ping timeout: 248 seconds]
eli_oat1 has joined #lisp
eli_oat has quit [Ping timeout: 268 seconds]
eli_oat1 is now known as eli_oat
Jesin has joined #lisp
smasta has joined #lisp
eli_oat has quit [Ping timeout: 256 seconds]
vlatkoB has joined #lisp
shka1 has quit [Ping timeout: 268 seconds]
Smokitch has joined #lisp
nowhereman_ has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
eli_oat has joined #lisp
atlan has joined #lisp
<atlan>
hi
Kundry_Wag has quit [Ping timeout: 268 seconds]
<aeth>
Are there any flaws with the CL type system?
eli_oat1 has joined #lisp
eli_oat has quit [Ping timeout: 248 seconds]
eli_oat1 is now known as eli_oat
pagnol has quit [Ping timeout: 265 seconds]
Jesin has quit [Quit: Leaving]
<no-defun-allowed>
well it'd be nice if it took type variables honestly
<no-defun-allowed>
the typical one in hasklel speak for map is `(a -> b) -> a -> b`
<no-defun-allowed>
no it's `(a -> b) -> [a] -> [b]`
<no-defun-allowed>
how does it work? idk
galiley has joined #lisp
hiroaki has joined #lisp
smurfrobot has quit [Remote host closed the connection]
HeyFlash has joined #lisp
tralala has joined #lisp
<aeth>
no-defun-allowed: I don't understand what you mean by "took type variables honestly"
<beach>
Hello atlan.
hiroaki has quit [Ping timeout: 248 seconds]
<beach>
no-defun-allowed: So you would like for Common Lisp to be statically typed rather than dynamically?
<beach>
no-defun-allowed: I.e. changing one of the absolutely most fundamental characteristics about Common Lisp? I think that would turn it into a completely different language.
gravicappa has joined #lisp
igemnace has joined #lisp
Kundry_Wag has joined #lisp
<aeth>
no-defun-allowed: CL is already potentially "gradually typed" (dynamically typed with optional static typing), but it's implementation-specific and the syntax is awkward (the syntax isn't an issue, though: write a macro). I think SBCL is the only implementation that does this (I wouldn't be surprised if CMUCL also does because SBCL is a CMUCL fork).
<aeth>
SBCL did this many years before it was cool to do so.
<aeth>
I just checked and CMUCL does not do anything with type declarations for function arguments, at least by default. CMUCL, ABCL, ECL, and CLISP all permit (defun foo (x) (declare (single-float x)) (+ x x)) (foo 1) and fail with a "not a number" error when trying to do * when given (foo "Hello") instead of failing with not a single-float at the start of the foo function
fikka has quit [Ping timeout: 256 seconds]
<aeth>
Interestingly, CCL now *does* respect type declarations, even with (optimize (safety 0)), making it more reliable than SBCL, which checks except when safety is 0.
angavrilov has joined #lisp
pdv has joined #lisp
<pdv>
Hi, I have five Boolean flags that I need easily set and reset. What data structure should I use? (I’m writing in emacs lisp)
smurfrobot has joined #lisp
fikka has joined #lisp
vlad_ has joined #lisp
newbie has quit [Read error: Connection reset by peer]
troydm has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
vlad_ is now known as DonVlad
smurfrobot has quit [Ping timeout: 248 seconds]
varjag has joined #lisp
araujo has joined #lisp
<LdBeth>
pdv: vector
fikka has joined #lisp
<pdv>
LdBeth: but it would be nice to name the flags, should I then create access functions myself?
<pdv>
Or are there good macros for that?
<LdBeth>
pdv: then use `cl-defstruct`
<pdv>
Ok so no plists? Or alists?
<LdBeth>
list is slow and less space effecient
<aeth>
There's many ways to do it with a boolean. e.g. You can just have a function consisting of an ecase assign meaning to the bits of an integer. (Then you wouldn't update the data structure itself, you'd *replace* the integer)
King-Calf has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
<pdv>
Ok thanks I’ll look into that as well.
King-Calf has joined #lisp
svillemot has joined #lisp
King-Calf1 has joined #lisp
<pdv>
Just for clarity I thought it would be nice to name them and use something like a struct. But then again maybe I just have a too much of a C mind set
<aeth>
You should probably use the struct way
smurfrobot has joined #lisp
nowhereman_ has quit [Ping timeout: 245 seconds]
<pdv>
How would you do it with the ecase way? Can you write an example?
King-Calf has quit [Ping timeout: 276 seconds]
nowhereman_ has joined #lisp
<aeth>
If you're really thinking like C, you would make your flags #b1, #b10, #b100, etc and use the logic operations on them like (logior #b00010 #b00001) to union two of them.
smurfrobot has quit [Ping timeout: 248 seconds]
<pdv>
Maybe I should not think too much in C :)
<aeth>
If you were working with a global variable it'd go like this: (setf *flag* (logior *flag* #b00001)) ; adds the value represented by #b00001
<pdv>
Ah right
<aeth>
The ecase would just name those 5 sets.
<pdv>
I’m curious
<LdBeth>
Emacs Lisp has bool-vector but cl-defstruct doesn't support that
<aeth>
MoziM: cffi:foreign-pointer, if that's what you mean
robotoad has quit [Quit: robotoad]
<aeth>
e.g. (cffi:make-pointer 0)
<_death>
better to just (defconst foo #b00001) etc.. another representation is a list with the set flags represented as symbols
<aeth>
_death: Ime, you need it all
<aeth>
You need the constant, you need the functions that go both ways, and you need more than that, too
<aeth>
If you want to make sure you can update it for new changes, you can generate it all in one big macro. But for 5 values, it's probably not a big deal
<LdBeth>
bool-array just do that for you
dddddd has joined #lisp
<aeth>
LdBeth: This is the fastest solution, not the easiest. There are definitely 10 ways to do this.
<LdBeth>
bool-array does exact the same thing internally
<aeth>
It does? This is why you ask in #emacs and not in #lisp
makomo_ has joined #lisp
<pdv>
LdBeth: Thanks, ill check that too
<_death>
if you want to set multiple flags, or toggle flags, bool-array can be cumbersome.. similarly in CL, bit-vector has its disadvantages
wildbartty has quit [Quit: Leaving]
wildbartty has joined #lisp
<aeth>
Oh, I wasn't talking about a bit-vector. I was talking about an integer. Those are the two ways to do it, each with advantages and disadvantages.
<_death>
yes.. the integer is what I usually prefer
<aeth>
I prefer the integer approach because you can write pure functions more easily.
<aeth>
It looks like bool-vector is just the emacs lisp name for bit-vector
<LdBeth>
no, bool-vector is a tuple of length and a integer
<aeth>
well that's just plain confusing then
<aeth>
Why is the length necessary? In CL, it's not
<_death>
well, it also takes booleans rather than (integer 0 1)
<aeth>
When I work with bit flags I just work with sets, not t & nil or 1 & 0.
<aeth>
represent :foo with #b00001, not the index 0
<_death>
LdBeth: this is one the issues of bit vectors.. that you need to allocate them, whereas the integer will usually be a fixnum
<beach>
Still remaining for the layout: 1) position data so that it never overlaps with long control arcs and 2) give more vertical space above an instruction with many predecessors.
fourier has joined #lisp
<aeth>
_death: Well, the set functions are all very trivial. I just use them to reduce the chance of error. 'logior' doesn't really express the intent well.
smurfrobot has joined #lisp
galiley has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 260 seconds]
<_death>
aeth: interesting.. to me intent is clear with LOGIOR
<_death>
it's weird that you have set-member-p which turns to indices
<no-defun-allowed>
dynamic typing should be default of course
<no-defun-allowed>
but when you do type declarations (and inference) it might be clever to say "the same type as the input FOO" or something
<_death>
aeth: I'd usually work in terms of LOGTEST or LOGALL (user-defined, substitute universal quantifier for LOGTEST's existential one)
rozenglass has quit [Remote host closed the connection]
atlan1 has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<aeth>
_death: I don't use the one that works with indices anywhere, I guess I added it for completeness.
atlan has quit [Ping timeout: 244 seconds]
shrdlu68 has joined #lisp
<no-defun-allowed>
i'm not saying lisp should be static, but when we want static it should be clever
<pjb>
Still use both defstrut and vector!
<pjb>
(defstruct (flags (:type vector) (:conc-name f-)) a b c d e) (fill (make-flags) t) --> [t t t t t]
<pjb>
(fill (make-flags) t :start 1 :end 3) #| --> #(nil t t nil nil) |#
<pjb>
I mean: (fill (make-flags) t :start 1 :end 3) -> [nil t t nil nil]
BitPuffin has joined #lisp
<_death>
again, if it's a set of flags what's the point of concerning yourself with indices (and therefore order)
<_death>
if efficiency is not a concern, (union '(green tasty) '(poisonous)) is nice
shrdlu68 has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
<pjb>
It all depends on the meaning of "easily".
<pjb>
Why people never say what they want to optimize?
shrdlu68 has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
<aeth>
_death: Oh, I generate my sets with macros so you cannot rely on the indices (e.g. 2) or directly using literal value (e.g. #b100)
<aeth>
That's an internal implementation detail that the user shouldn't see
<pjb>
speed of debugging the code? This is where you will spend most of the time.
<pdv>
Execution
EvW has quit [Client Quit]
<pjb>
there's no difference in the time required to access structure slots or vector slots.
<pdv>
Ok right
<pjb>
The best proof is this :type vector option of defstruct! It's the same thing!
<aeth>
pjb: Personally, I wrote my set implementation to be run millions of times a second at the core of the hot loop in my game engine.
EvW1 has joined #lisp
msb has quit [Ping timeout: 268 seconds]
<pdv>
Yes I want to do something similar
<pjb>
^ and yes, optimization is a global thing.
<pjb>
There's optimizing "speed" or anything in general. You have to consider your whole application.
shrdlu68 has quit [Ping timeout: 240 seconds]
<pdv>
Sure but if it’s in the inner loop...
shrdlu68 has joined #lisp
msb has joined #lisp
EvW1 has quit [Ping timeout: 245 seconds]
fourier has quit [Ping timeout: 260 seconds]
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
Kundry_Wag has joined #lisp
orivej has joined #lisp
reu has quit [Ping timeout: 245 seconds]
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
smurfrobot has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
shrdlu68 has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
shrdlu68 has quit [Ping timeout: 264 seconds]
argoneus has quit [Quit: No Ping reply in 210 seconds.]
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
argoneus has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
glamas_ has joined #lisp
shrdlu68 has joined #lisp
fikka has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
glamas__ has quit [Ping timeout: 260 seconds]
JuanDaugherty has quit [Quit: Exeunt]
fikka has quit [Ping timeout: 248 seconds]
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
atlan has joined #lisp
atlan1 has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
kajo has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
kajo has joined #lisp
vlatkoB_ has joined #lisp
vlatkoB has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 245 seconds]
shrdlu68 has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
vap1 has joined #lisp
vaporatorius has joined #lisp
vaporatorius has joined #lisp
random-nick has quit [Read error: error:1408F10B:SSL routines:ssl3_get_record:wrong version number]
random-nick has joined #lisp
glamas_ has quit [Quit: Leaving]
atlan1 has joined #lisp
makomo has joined #lisp
vaporatorius__ has quit [Ping timeout: 240 seconds]
shrdlu68 has quit [Ping timeout: 240 seconds]
atlan has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
DonVlad has joined #lisp
Kundry_Wag has joined #lisp
smasta has quit [Ping timeout: 276 seconds]
shrdlu68 has quit [Ping timeout: 240 seconds]
m00natic has joined #lisp
shrdlu68 has joined #lisp
fikka has joined #lisp
smasta has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
atlan has joined #lisp
atlan1 has quit [Ping timeout: 265 seconds]
EvW has joined #lisp
shrdlu68 has quit [Client Quit]
vap1 has quit [Quit: Leaving]
hiroaki has joined #lisp
<no-defun-allowed>
Yeah Lisp loses its magic statically typed so don't do that. We should definitely work on inference for mathcentric sections of our programs though.
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
pfdietz_ has quit []
fikka has quit [Ping timeout: 256 seconds]
smasta has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
smurfrobot has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
smurfrobot has quit [Ping timeout: 244 seconds]
kajo has quit [Ping timeout: 260 seconds]
kajo has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Kundry_Wag has joined #lisp
kajo has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Remote host closed the connection]
kajo has joined #lisp
Kundry_Wag has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<dim>
pdv: a very efficient way to optimize something that's in the inner loop is to fnid a way to *not* do it in the inner loop at all, you can't beat that
saki has joined #lisp
Bike_ has joined #lisp
MoziM has quit [Quit: WeeChat 2.2]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
test1600 has joined #lisp
fikka has joined #lisp
maximjaffe has joined #lisp
LiamH has joined #lisp
zfree has joined #lisp
Arcaelyx has quit [Max SendQ exceeded]
charh has quit [Ping timeout: 245 seconds]
EvW1 has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
mindCrime has joined #lisp
fikka has joined #lisp
nowhereman_ is now known as nowhere_man
Arcaelyx has joined #lisp
maximjaffe has quit [Quit: Leaving]
quipa has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
smurfrobot has joined #lisp
quipa is now known as maximjaffe_
EvW1 has quit [Ping timeout: 255 seconds]
maximjaffe_ is now known as quipa_
quipa_ is now known as maximjaffe
Denommus has joined #lisp
Kevslinger has joined #lisp
Bronsa has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
argoneus has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
argoneus has joined #lisp
<pdv>
dim: True!
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
Denommus has quit [Remote host closed the connection]
nirved has joined #lisp
zfree has quit [Quit: zfree]
mkolenda has joined #lisp
<dlowe>
I'm not convinced lisp would lose its magic with static typing.
<dlowe>
Bad static types, sure.
<dlowe>
But there are expressive type systems that can act as structural elements instead of just restrictions.
<shka>
well, there is shen, so you can check
Kundry_Wag has joined #lisp
klltkr_ has quit [Ping timeout: 260 seconds]
<pjb>
dlowe: this is not a discussion for #lisp, but for #lisp-implementers
<pjb>
Nothing prevents a compiler to do static typing. As long as it preserves the semantics specified in clhs.
fikka has quit [Ping timeout: 256 seconds]
maximjaffe has quit [Quit: Leaving]
maximjaffe has joined #lisp
eminhi has joined #lisp
maximjaffe has quit [Remote host closed the connection]
maximjaffe has joined #lisp
quipa has joined #lisp
maximjaffe has quit [Client Quit]
quipa has quit [Remote host closed the connection]
maximjaffe has joined #lisp
sauvin has quit [Ping timeout: 256 seconds]
asdf123 has joined #lisp
tralala has quit [Ping timeout: 265 seconds]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
fikka has joined #lisp
<LdBeth>
Seems CFFI puts quite a lot overhead on calling external C funcs
<Bike_>
over implementation ffis, or just at all?
kuwze has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
sauvin has joined #lisp
JuanDaugherty has joined #lisp
<pjb>
LdBeth: it's not CFFI, it's FFI.
<pjb>
CFFI works mostly at compilation-time.
fikka has quit [Ping timeout: 256 seconds]
<pjb>
My advice: don't use FFI, just write it in lisp!
Kundry_Wag has quit [Ping timeout: 240 seconds]
test1600 has quit [Ping timeout: 244 seconds]
optikalmouse has joined #lisp
sailor_cat has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
reu has joined #lisp
X-Scale has quit [Ping timeout: 244 seconds]
sjl_ has joined #lisp
<beach>
I agree with that advice.
[X-Scale] has joined #lisp
<shka>
yeah rewritte tensorflow in lisp
fikka has quit [Ping timeout: 260 seconds]
<shka>
and then rewritte webkit in lisp
<_death>
right.. I'm waiting for Lisp version of, say, OpenCV... my advice, use FFI but come up with an interface that makes it look like Lisp
<shka>
sometimes there is no alternative
saki has quit [Remote host closed the connection]
<beach>
I think that is part of the problem. Many people are waiting for others to do it, rather than doing it.
<shka>
not that many
<_death>
well, people already wrote OpenCV and I'm successfully using it from Lisp..
<shka>
CL community is not exactly huge
<shka>
anyway
Denommus has joined #lisp
<dlowe>
some people want to solve the problem of not enough lisp code, and some people want to solve an actual problem
<jackdaniel>
not that reinventing every needed piece of software in loved language is the only reasonable approach
<shka>
can someone please explain me what is the difference between supplying default arg for slot in class over providing :initform?
<jackdaniel>
shka: sure, if you inherit from foo, which has slot bar with initarg :bar, you may initialize it with your own from the inheriting class
smurfrobot has quit [Remote host closed the connection]
Arcaelyx has quit [Ping timeout: 256 seconds]
smasta has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
Arcaelyx has joined #lisp
flamebeard has quit []
saki has quit [Ping timeout: 244 seconds]
saki has joined #lisp
[X-Scale] has quit [Ping timeout: 256 seconds]
phoe has quit [Remote host closed the connection]
asarch has joined #lisp
<pjb>
If you have to use foreign code, isolate it in separate processes. This is why unix processes were invented.
Ven`` has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
nsrahmad has joined #lisp
fikka has joined #lisp
X-Scale has joined #lisp
MoziM has quit [Ping timeout: 268 seconds]
<_death>
may make sense, but aside from IPC overhead that means writing more of the software in a non-lisp
Arcaelyx has quit [Remote host closed the connection]
moei has quit [Quit: Leaving...]
kuwze has quit [Quit: Page closed]
smasta has joined #lisp
shka1 has joined #lisp
zxcvz has joined #lisp
optikalmouse has joined #lisp
biopandemic has joined #lisp
luisoliv has joined #lisp
<luisoliv>
<+SP9002_@efnet> so, he wants the win. so we're just gonna get lunch or something, then hes gonna push me to the ground and tap my ass with his foot so he can claim he "kicked my ass" tbh im going along with it becase I dont wanna lose any teeth
<luisoliv>
With our IRC ad service you can reach a global audience of entrepreneurs and fentanyl addicts with extraordinary engagement rates! https://williampitcock.com/
<luisoliv>
I thought you guys might be interested in this blog by freenode staff member Bryan 'kloeri' Ostergaard https://bryanostergaard.com/
<luisoliv>
or maybe this blog by freenode staff member Matthew 'mst' Trout https://MattSTrout.com/
luisoliv has quit [Killed (Sigyn (Spam is off topic on freenode.))]
shka1 has quit [Ping timeout: 240 seconds]
optikalmouse has left #lisp [#lisp]
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
WhoTookMyName has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
hiroaki has quit [Ping timeout: 240 seconds]
equwal has quit [Ping timeout: 256 seconds]
sawdey2131718 has joined #lisp
sawdey2131718 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
eminhi has quit [Remote host closed the connection]
fourier has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Tionis18 has joined #lisp
Tionis18 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
information2718 has joined #lisp
information2718 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
brendyn has quit [Ping timeout: 268 seconds]
saki has quit [Read error: Connection reset by peer]
charh has quit [Ping timeout: 264 seconds]
HeyFlash has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
VampiricPadraig1 has joined #lisp
<VampiricPadraig1>
<+SP9002_@efnet> so, he wants the win. so we're just gonna get lunch or something, then hes gonna push me to the ground and tap my ass with his foot so he can claim he "kicked my ass" tbh im going along with it becase I dont wanna lose any teeth
<VampiricPadraig1>
With our IRC ad service you can reach a global audience of entrepreneurs and fentanyl addicts with extraordinary engagement rates! https://williampitcock.com/
<VampiricPadraig1>
I thought you guys might be interested in this blog by freenode staff member Bryan 'kloeri' Ostergaard https://bryanostergaard.com/
<VampiricPadraig1>
or maybe this blog by freenode staff member Matthew 'mst' Trout https://MattSTrout.com/
VampiricPadraig1 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
WhoTookMyName has quit [Ping timeout: 260 seconds]
WhoTookMyName has joined #lisp
WhoTookMyName has left #lisp [#lisp]
saki has joined #lisp
rumbler31 has joined #lisp
asarch has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 248 seconds]
rumbler31 has quit [Ping timeout: 244 seconds]
Hink22 has joined #lisp
MoziM has joined #lisp
Hink22 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
skapata has joined #lisp
Kundry_Wag has joined #lisp
kajo has quit [Ping timeout: 240 seconds]
nsrahmad has quit [Quit: Leaving]
fikka has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
eli_oat has quit [Remote host closed the connection]
atlan has quit [Quit: Leaving.]
eli_oat has joined #lisp
Fare has joined #lisp
rozenglass has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
Olipro15 has joined #lisp
<Olipro15>
<+SP9002_@efnet> so, he wants the win. so we're just gonna get lunch or something, then hes gonna push me to the ground and tap my ass with his foot so he can claim he "kicked my ass" tbh im going along with it becase I dont wanna lose any teeth
Olipro15 has quit [Killed (Sigyn (Spam is off topic on freenode.))]
cage_ has quit [Remote host closed the connection]
cage_ has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
edgar-rft has joined #lisp
MoziM has quit [Ping timeout: 244 seconds]
MoziM has joined #lisp
m00natic has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
moei has joined #lisp
edgar-rft has quit [Remote host closed the connection]
orivej has joined #lisp
saki has quit [Ping timeout: 244 seconds]
graphene has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
slyrus_ has quit [Ping timeout: 264 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
equwal has joined #lisp
pjb has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
sauvin has quit [Remote host closed the connection]
josemanuel has joined #lisp
Fare has joined #lisp
charh has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Fare has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
<p_l>
jfc wtf happened?
graphene has quit [Remote host closed the connection]
<Bike_>
what?
<p_l>
just looked through that spam
Fare has joined #lisp
<Bike_>
whati heard is that some guy got banned and decided a slander campaign across multiple networks was the way to go
emacsomancer has joined #lisp
graphene has joined #lisp
<p_l>
that I knew, but I see they expanded the operation
<Bike_>
oh, it's been here since like, last week
<Bike_>
jackd put on +r so it was less obvious
<p_l>
Bike_: the links to fake blogs, yes, the rest wasn't
<Bike_>
oh, the quote is new, yeah.
<p_l>
tbqh, I don't really understand those people
random-nick has quit [Read error: Connection reset by peer]
MoziM has quit [Ping timeout: 244 seconds]
equwal has quit [Ping timeout: 240 seconds]
MoziM has joined #lisp
<Bike_>
who does?
fikka has quit [Ping timeout: 255 seconds]
eli_oat has quit [Ping timeout: 260 seconds]
edgar-rft has joined #lisp
graphene has quit [Remote host closed the connection]
Orion3k has quit [Ping timeout: 240 seconds]
<jackdaniel>
petty feelings are quite common; most people get over it as silly thing though
graphene has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
azrazalea has quit [Ping timeout: 240 seconds]
igemnace has quit [Quit: WeeChat 2.2]
azrazalea has joined #lisp
<p_l>
there's the Greater Internet Fuckwad Theory
graphene has quit [Remote host closed the connection]
sh1r0 has joined #lisp
Kundry_Wag has joined #lisp
graphene has joined #lisp
Orion3k has joined #lisp
<Demosthenex>
eternal september.
equwal has joined #lisp
King-Calf1 has quit [Quit: Leaving.]
random-nick has joined #lisp
Fare has quit [Ping timeout: 255 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
klltkr has joined #lisp
Khisanth has quit [Ping timeout: 248 seconds]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
Khisanth has joined #lisp
theBlackDragon has quit [Ping timeout: 265 seconds]
gravicappa has quit [Ping timeout: 245 seconds]
richardjdare has joined #lisp
zfree has joined #lisp
sh1r0 has quit []
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
makomo has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
fourier has quit [Ping timeout: 240 seconds]
pierpa has joined #lisp
<aeth>
Let's create a new Internet just for Mezzano users. Then we can avoid the problems that come from the eternal September until it gets posted to HN.
fikka has joined #lisp
Fare has joined #lisp
terpri has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
<dlowe>
The first step to creating the perfect communications network is to cut the entire world off.
<dlowe>
because man, who wants to talk to those people
smasta has quit [Ping timeout: 240 seconds]
<whartung>
I hate talking to people.
gabiruh has quit [Ping timeout: 264 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
skapata has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
tripty has quit [Ping timeout: 240 seconds]
zxcvz has quit [Quit: zxcvz]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
hiroaki has joined #lisp
sh1r0 has joined #lisp
trittweiler has quit [Ping timeout: 248 seconds]
dented42 has joined #lisp
DonVlad has quit [Remote host closed the connection]
Smokitch has quit []
Kundry_Wag has quit [Ping timeout: 244 seconds]
rumbler31 has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rumbler31 has quit [Ping timeout: 240 seconds]
kajo has joined #lisp
sh1r0 has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
<richardjdare>
dumb question: how do I make a cffi:defcstruct with a function pointer in it?
<richardjdare>
Is it just (cffi:defcstruct foo (:pointer myfptr)) or is there more to it?
<Bike_>
i believe cffi still ignores types of pointers
<Bike_>
which is to say, that's it
<richardjdare>
Thanks
light2yellow has quit [Quit: bye cruel world]
BitPuffin has quit [Remote host closed the connection]
sh1r0 has joined #lisp
angavrilov has quit [Remote host closed the connection]
LiamH has quit [Quit: Leaving.]
kenster has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
cage_ has quit [Quit: Leaving]
equwal has quit [Ping timeout: 240 seconds]
Bike_ has quit [Ping timeout: 252 seconds]
richardjdare has quit [Quit: Leaving]
mindCrime has quit [Ping timeout: 256 seconds]
nanoz has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
hiroaki has quit [Ping timeout: 240 seconds]
nanoz has quit [Ping timeout: 240 seconds]
tripty has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
Orion3k has quit [Ping timeout: 268 seconds]
josemanuel has quit [Quit: leaving]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Josh_2 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
nanoz has joined #lisp
JuanDaugherty has joined #lisp
smasta has joined #lisp
dented42 has joined #lisp
Orion3k has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
pierpal has quit [Ping timeout: 256 seconds]
sh1r0 has quit [Ping timeout: 256 seconds]
Copenhagen_Bram has joined #lisp
Kundry_Wag has joined #lisp
sjl_ has quit [Quit: WeeChat 2.2-dev]
random-nick has quit [Ping timeout: 240 seconds]
Fare has quit [Ping timeout: 260 seconds]
Arcaelyx has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
X-Scale has quit [Ping timeout: 240 seconds]
robotoad has quit [Quit: robotoad]
rumbler31 has joined #lisp
fikka has joined #lisp
smasta has quit [Ping timeout: 244 seconds]
Denommus has quit [Remote host closed the connection]