<aeth>
I fail to really see the difference between come from and goto in most languages. It looks like INTERCAL's come from uses line numbers (a feature of the language?) so "come from 230" will be a complete surprise if you're reading line 230. But most gotos use labels, so come-from in a language like CL would be the same way. So you'd (come-from label) instead of (go label) and you'd basically just trade which line has the label and which has t
<aeth>
(unless you have a confusing way of permitting multiple come-froms from the same label, but that seems adding to the basic come from)
<aeth>
s/that seems/that seems like/
<LdBeth>
Yes, literate programming is pretty much the same thing
<oni-on-ion>
aeth, can i (defun ()) something as well as execute it? like in JS we can do (function n(arg) {})(arg)
<oni-on-ion>
apparently webasm has built in flow control stuff and avoids goto
asarch has joined #lisp
<mange>
oni-on-ion: Does n really escape that? I don't think that defines n in the wider scope.
<oni-on-ion>
mange: not sure. but i am hoping defun could =)
<no-defun-allowed>
(progn (defun foo ...) (foo ...)) could work
<no-defun-allowed>
but tbh that's disgusting
<aeth>
oni-on-ion: this seems to work. (funcall (defun foo (x) x) 42)
<oni-on-ion>
ah nice !
<oni-on-ion>
ty ty =)
<no-defun-allowed>
oh yeah, defun returns the symbol that names the function
<aeth>
oni-on-ion: defun returns the function name, so it would be just like (funcall 'foo 42)
<aeth>
oni-on-ion: avoiding goto would be a problem for implementing a Lisp in wasm, then
<aeth>
oni-on-ion: every macro that has to do with iteration (e.g. DO, LOOP) in CL is typically ultimately just a macro over GO contained within the scope of a TAGBODY
<aeth>
Often they use DO as an intermediate target, though.
<no-defun-allowed>
if wasm's supposed to compile to SSA, maybe looking at how llvm compilers handle for-loops and the like could help
<oni-on-ion>
wasm is getting a bunch more stuff i think because its not quite ready for super high level langs
<oni-on-ion>
it only supports 4 types, 32 and 64bit ints and floats =)
<oni-on-ion>
and cool, didnt know about defun, thats great =)
<no-defun-allowed>
what the fuck, 4 types?
<aeth>
oni-on-ion: it looks ugly, and it will warn you if you run it more than once (e.g. redefining it)
<p_l>
SSA and CPS are equivalent, and CPS had been a long time target for lisp compilers :)
<no-defun-allowed>
how do you intend on doing anything in wasm?
<no-defun-allowed>
oni-on-ion: yeah don't do that defun trick, just use flet or a lambda
<aeth>
It technically works, that's all
<p_l>
no-defun-allowed: interestingly enough, DEC Alpha was fastest processor on market while supporting only 32-bit-extended-to-64, 64bit ints, and few types of floats (of modern importance being only ieee 32 and 64 bit ones)
<oni-on-ion>
mhm =) not necessarily need the defun trick, but writing prototyping code, it helps to have the options. i almost needed it for how i was testing something out
<p_l>
the only issue it had was I/O due to lack of byte-sized accesses, which was worked around by intermediate chip... and which in WASM is done by exposing calls to JavaScript (which has a very limited primitive type system as well)
<aeth>
"has a very limited primitive type system as well" that's an understatement
<no-defun-allowed>
well yes today's cpus only handle ints and sometimes floats
pjb has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
javascript has a type system?
<aeth>
Isn't JS just number, boolean, string, and object?
<no-defun-allowed>
1 + [] = "1"
<aeth>
(I'm not sure if objects and arrays are distinct)
<p_l>
aeth: and outside of boolean, number and characters can be generalized to float64 and int32, while objects are memory accesses
<aeth>
It looks like JS also has a null
<no-defun-allowed>
yeah arrays are pretty much special objects last time i checked
<p_l>
no-defun-allowed: today's cpus have a wide variety of different types, even if ultimately they are put in rather limited forms. Legacy of CISC :)
<no-defun-allowed>
types such as: byte, int, bigger int, bigger bigger int
<oni-on-ion>
aeth is your engine going to support switch or steam or anything
nisstyre is now known as `nisstyre
<p_l>
a variety of ints, packed int vectors, variable-sized arrays, floats, packed float vectors, packed character vectors, encryption primitives, and include instructions which are general-purpose primitives for building things like XML processing engines
<p_l>
SSE 4.2 is pretty wild at times
<aeth>
oni-on-ion: Supporting a console would require (1) porting SBCL, (2) replacing everything that touches SDL, (3) replacing everything that touches OpenGL. The Switch has the added challenge of not being x86-64, so it might also require improving SBCL's code generation on AMD64.
<aeth>
oni-on-ion: Supporting Steam requires wrapping one foreign library.
<p_l>
(SPARC is downright pedestrian, being a pretty honest RISC design with addition of supporting custom type systems that use tagged values)
<aeth>
s/AMD64/ARM64/
<aeth>
wrong acronym XD
<aeth>
That shows you how much I think of other architectures.
SenasOzys has joined #lisp
<aeth>
p_l: I think RISC V is similar there.
SenasOzys has quit [Remote host closed the connection]
<p_l>
with RISC-V add every bit of kitchen sink that was discussed at cpu design course
<aeth>
as long as it's RISC
<oni-on-ion>
aeth: hmmmmm. javascript then =)
<p_l>
but keep the base essentially a reiteration of MIPS because that's what the faculty taught ;)
SenasOzys has joined #lisp
<p_l>
which is probably why it's the only new design since 1990s to use Cray-style vector unit
<aeth>
oni-on-ion: Supporting JavaScript and probably even WASM requires writing my own Common Lisp implementation and trying to even get half the speed of what SBCL can get while working on a much higher level target.
<aeth>
It would also require replacing SDL and OpenGL (but with WebGL instead of a proprietary API). So it would probably actually be harder.
<oni-on-ion>
hmmmm.
<aeth>
(Neither ParenScript nor JSCL are complete and the incomplete parts are exactly the parts you'd want for a high-performance CL application.)
<oni-on-ion>
parenscript seems ok, how come it is not "complete"?
<oni-on-ion>
i've used it a bunch, and for a half-4drl
<aeth>
oni-on-ion: iirc ParenScript is explicitly a subset and JSCL is j ust very incomplete.
<oni-on-ion>
well yes. parenscript is not meant to be a full blown CL. just a translation to JS being as close to CL as possible under that
<aeth>
oni-on-ion: But you don't even want a complete, conforming CL implementation. CLISP is one such implementation and it's still entirely unsuitable for the kind of program that my game engine is.
<oni-on-ion>
not like say ClojureScript
<aeth>
You want something that goes beyond the minimum required by the standard.
<oni-on-ion>
huh?
Fare has joined #lisp
<aeth>
If you're writing a game, you want type declarations and other optional places where types show up to (1) be respected and (2) actually optimize what you're writing. The only place where SBCL fails here is not respecting :type in defclass at default optimization levels because SBCL primarily uses types for performance, not reliability.
rumbler31 has joined #lisp
<aeth>
(:type in defclass wouldn't really improve performance
<aeth>
)
<aeth>
oni-on-ion: the only things that implementations are required to respect are CHECK-TYPE and (maybe, I'm not sure) TYPEP in an ASSERT... and they don't have to optimize based on that CHECK-TYPE, either.
rumbler31 has quit [Ping timeout: 252 seconds]
Balooga_ has quit [Quit: Balooga_]
Balooga_ has joined #lisp
zmt00 has quit [Quit: Leaving]
marvin2 has quit [Ping timeout: 252 seconds]
`nisstyre is now known as nisstyre
Roy_Fokker has quit [Read error: Connection reset by peer]
Balooga_ has quit [Quit: Balooga_]
dale has quit [Quit: dale]
robotoad has quit [Quit: robotoad]
rtypo has quit [Ping timeout: 244 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
dddddd has quit [Remote host closed the connection]
robotoad has joined #lisp
lavaflow has quit [Read error: No route to host]
adam4567 has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
lavaflow has joined #lisp
<oni-on-ion>
aeth: hmm, alright. thanks for explaining that
orivej has quit [Ping timeout: 252 seconds]
dale has joined #lisp
Balooga_ has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
gector has quit [Read error: Connection reset by peer]
gector has joined #lisp
robotoad_ has joined #lisp
robotoad has quit [Ping timeout: 252 seconds]
<beach>
Good morning everyone!
<Balooga_>
Hi beach
<no-defun-allowed>
Morning beach
pjb has joined #lisp
<Blackbeard>
hi
lavaflow_ has joined #lisp
lavaflow has quit [Ping timeout: 260 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 252 seconds]
lnostdal has quit [Quit: rebooting .. brb!]
megalography has left #lisp [#lisp]
lnostdal has joined #lisp
anewuser has quit [Quit: anewuser]
pjb has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
oni-on-ion has quit [Read error: No route to host]
oni-on-ion has joined #lisp
Balooga_ has quit [Quit: Balooga_]
PO_away has quit [Quit: Leaving]
steiner has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<LdBeth>
hi
shifty has quit [Ping timeout: 260 seconds]
<LdBeth>
how is #1=(1 . #1#)
<LdBeth>
this kind of reader macro implemented?
<oni-on-ion>
~
* |3b|
would guess something like keeping a hash table of locations that need updated after whole thing is READ while READing it, then going back and updating once the actual value is available
<LdBeth>
ok, i can find ccl's impl
<LdBeth>
I found it comfusing because (get-dispatch-macro-character #\# #\1) returns nil
<White_Flame>
if you think about it, the only way to cons up a recursive list is to mutate one of the cells to hook it back
<|3b|>
it is #=
<|3b|>
1 is a parameter to the #= dispatching reader macro
<White_Flame>
ie, you can't make a looped list with only pure functional cons calls
<|3b|>
(users who want to introspect the env during macros etc, or cleavir-based implementations trying to use the declarations to modify codegen)
<beach>
|3b|: Good question.
dale has quit [Quit: dale]
<|3b|>
beach: also, if i want to have a set of functions that are compiled specially (foreign functions with different calling convention in this case), what's the best way to specify that in cleavir? best i've come up with so far is compiler macro that turns the call into a special form that knows about the extra details
<beach>
|3b|: I think the idea is that the acceptable declaration can be customized. But Common Lisp also allows declarations that are only valid in some implementations, provided that there is a DECLARATION declaration.
<beach>
It should be possible to customize the way function calls are compiled.
<beach>
Pretty much every compilation function is a generic function, so it can be customized.
<beach>
If I have missed this particular one, that could be corrected.
<|3b|>
yeah, just not obvious which ones to customize :)
<beach>
Let me look...
<|3b|>
possibly i just needed to cut it off higher in class hierarchy and not try to inherit from existing similar classes as much
<|3b|>
and if not clear, this is selected per function. one calling convention for FFI, and another for 'normal' functions
<|3b|>
the FFI calls need to do compile-time dispatching on name and argument type/counts, while
<|3b|>
while 'normal' functions act like CL
<beach>
The technique is as follows. Your environment must return a different INFO class for that type of function you want. Then you need to define a method on CONVERT-CST that specializes on that class.
<|3b|>
ideally transparent to user, since the differences are all internal (compile vs runtime dispatch, and hidden arguments)
<|3b|>
ok, i probably need to upgrade my sicl then, since i think i grabbed it right before you added the CST stuff :)
<beach>
I see. Well, there should be something similar in Generate-AST.
<beach>
That part hasn't changed.
<|3b|>
yeah, most of what i could find was either not exported or overwrote my changes
<beach>
It is called CONVERT-FORM in the Generate-AST system.
<|3b|>
so i'll update and try again before wasting your time debugging outdated code :)
<|3b|>
right
<beach>
The same action is required.
<beach>
You need to return a custom INFO object from the environment, and you need to add a method on CONVERT-FORM or CONVERT-CST.
<|3b|>
i think my custom info was getting converted to a global-function-info somewhere in the middle
<|3b|>
but possibly deriving it from global-function-info was a mistake?
<|3b|>
s/converted/replaced/
<beach>
Maybe so.
<beach>
What is the representation of your environment?
* |3b|
's env is a subclass of sicl-simple-environment:simple-environment
<|3b|>
with a method on cleavir-env:function-info to return the info for the FFI stuff
<beach>
Great! That should not hard then.
<beach>
OK, that sounds right.
<|3b|>
(and stubs for whatever other methods it complained about when i tried to compile something)
<beach>
Looks like you are on the right track.
<|3b|>
alternately, can i modify how it generates code to look up the function?
Kundry_Wag has joined #lisp
<beach>
That doesn't sound right.
<|3b|>
possibly i could just have it return a special thing instead of generating a temp and looking up the function, and the code generator for funcall could just look for that thing
<beach>
You can try that.
<beach>
I haven't given it much thought.
* |3b|
will think some more and look at code
<beach>
What is it that you are working on?
* |3b|
wants a CL-like language that generates dalvik bytecode (possibly eventually a full CL, but that is relatively low priority for now)
<beach>
Wow, ambitious.
<|3b|>
and also learning cleavir to see how well it would apply to my existing compilers with similar goals (cl-like compiler to GLSL, cl-like compiler to spir-v, etc :)
Kundry_Wag has quit [Ping timeout: 252 seconds]
<beach>
Very nice.
<|3b|>
well, the amount of ambition varies with the '-like' part :)
<|3b|>
which is one reason for full-cl being low priority, to minimize that amount
<beach>
I understand.
<|3b|>
full CL would probably wait until it could be a SICL backend if ever
<beach>
Yeah, that might be best.
<|3b|>
but to be minimally useful, it doesn't need to be able to do too much beyond define a subclass of a java API class with a few simple methods, so it could handle events from UI
<oni-on-ion>
"full" CL...
* |3b|
already wrote a dalvik asm/disasm and some of the file format tools last time i wanted a dalvik compiler, and just mostly finished parsing the API definitions so i should be able to define subclasses and methods, and call methods
<|3b|>
now just need to write the compiler part :p
<beach>
"just"! Heh.
<|3b|>
:)
<|3b|>
compiler is relatively easy if it doesn't have to be fast and nice to use :)
<|3b|>
(especially when you already wrote a big chunk of it)
<|3b|>
and type inference is a big part of both of those, and cleavir has half of that too
<beach>
True.
pjb has quit [Ping timeout: 252 seconds]
<beach>
I think it would be great to have another client. More problems will be exposed and fixed. More contributions might happen.
<|3b|>
yeah, hopefully i'll actually finish the dalvik compiler this time :)
<|3b|>
oni-on-ion: "full" CL as in things like multiple values, conditions, automatic bignums (and ratios + complex types), clos, etc
<beach>
Right. Good luck!
<oni-on-ion>
i wonder if there is or could be a mini/half CL
<|3b|>
though this one will probably be closer to CL than the glsl/spirv compiler, just due to a more general-purpose target, so might support bignums, multiple values and conditions earlier
* |3b|
more or less tries for that, but usually not 100%
<aeth>
oh, cool, I am going to write a subset of CL that can handle +, -, /, and * then
<|3b|>
like my glsl compiler has types defconstant, which doesn't match CL... would have to do separate defconstant + declaim to get a subset
<|3b|>
*typed defconstant
<oni-on-ion>
interestnig
<|3b|>
aeth: make sure to specify the numeric types properly (or implement full CL numeric tower) :p
<|3b|>
i guess you could just say a conforming program can't have numeric overflow in your subset
<aeth>
|3b|: typed defconstant seems pretty easy to resolve: just rename it and make it macroexpand-1 into defconstant + declaim
<|3b|>
not really something that needs resolved, just an example of how i don't try to make a 100% subset :)
<|3b|>
and to be a subset, i think that macro would need to be in the user code rather than the implementation code
<aeth>
|3b|: I think it would have to be in another package than CL
Oladon has quit [Quit: Leaving.]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<|3b|>
aeth: "any valid program in that language has equivalent semantics and will run directly (with no extralingual pre-processing, and no special compatibility packages) in any conforming implementation of the full language"
<|3b|>
so if the language specifies non-CL packages, it isn't a CL subset
shka_ has joined #lisp
* |3b|
supposes i could define it as requiring 'conforming programs' to also be 'conforming CL programs with same semantics', and just anything that uses the stuff that differs is non-conforming :p
<|3b|>
though 'conforming programs' in that case would be prtty small set, you could do simple math on floats, not sure how much else :p
<aeth>
I don't think it's useful to write conforming CL on the GPU, anyway. The semantics are too different.
<aeth>
I would actually intentionally name certain things differently (e.g. a different name for defun) so people don't confuse the two
housel has quit [Read error: Connection reset by peer]
<oni-on-ion>
julia does the GPU automatigally
graphene has quit [Remote host closed the connection]
<oni-on-ion>
kind of scary how it parallelizes and vectorises stuff. but its not CL.
<aeth>
oni-on-ion: stuff like that seems like it would be more useful as a CL library on top of a distinct GPU shader language rather than as a feature of a GPU CL
graphene has joined #lisp
<beach>
|3b|: I am sorry that I am not extremely helpful right now. Monday mornings are chaotic here under normal circumstances. And now we have house guests as well, so I am even busier than usual.
<aeth>
oni-on-ion: the latter couldn't be 100% GPU so now you'd have a very unpredictable program where you're always asking: "Is this going to be on the CPU or the GPU?"
housel has joined #lisp
<aeth>
I personally think that predictable behavior is more important than performance.
Fare has quit [Ping timeout: 260 seconds]
<|3b|>
beach: no problem, you've given me enough to think about/investigate for now :)
<beach>
Oh, good.
<beach>
Keep me informed about how it goes.
<oni-on-ion>
aeth: not sure of the difference but i think i understand
<|3b|>
oni-on-ion: for the specific case of glsl, the execution model is different enough from CL that i wouldn't want much more than i have (something that looks like CL but focused on that specific usage style
<oni-on-ion>
ahhh yeah, ok i see ^_^
<|3b|>
for general GPGPU, you would probably still at least want a specialized library that generated GPU code rather than trying to translate arbitrary CL code
* |3b|
thinks *lisp and cmlisp would translate well to GPU for example
<aeth>
oni-on-ion: I mean this. If MAP could be single-threaded, multi-threaded, or on the GPU depending on various characteristics (like the input, which function is being used, whether or not the function is pure, etc.) then I wouldn't know what's going on at all.
<|3b|>
^
<oni-on-ion>
aeth: ahh. it would be practical to be able to decide.
<aeth>
oni-on-ion: But it's easy to write PMAP or GPU-MAP on top of CL.
<|3b|>
also moderately expensive to send things to/from GPU, so ideally you'd decide in advance that you were doing a bunch of GPU work with particular data
<aeth>
(Well, GPU-MAP would be fairly tricky, but I'd rather have it as a library than as part of the language as part of MAP.)
<|3b|>
so something like "add 10 million floats to these other 10 million floats" is fast on GPU, but if you add "copy these 20 million floats to gpu" and "copy these 20 million floats from gpu", it would have been faster to just add them on cpu
<|3b|>
(actually i guess you only need to copy 10M back, but doesn't change the conclusion)
<aeth>
yeah, it's not a decision I'd want a compiler to make
<|3b|>
well, sort of depends on language
<aeth>
sounds a lot easier to solve for one program than for all programs
<|3b|>
CL is specified in a way where it would be hard to extract good candidates
<|3b|>
but array languages might be good candidates for automatic translation
lemonpepper24 has quit [Ping timeout: 245 seconds]
<aeth>
|3b|: I don't know. Is it possible to extend the type of a function to do things like mark functions as pure? (Or do some other declare of pure.)
<aeth>
Then a function defined in the same file or defined locally (as a lambda or with flet or with labels) or defined with sb-ext:*derive-function-types* set to T (or equivalents in other implementations if they exist, possibly CMUCL has one) could have at least more guarantees about its behavior
<aeth>
(Oh, also defined in the CL package, which has a lock.)
<|3b|>
yeah, not impossible, especially for fairly narrow subsets
smokeink has quit [Remote host closed the connection]
<jackdaniel>
ecl has "pure" proclamations (it has also "side-effect free" proclamataion, what is slightly else)
<jackdaniel>
s/else/different/
<|3b|>
i think sbcl has some similar things
<aeth>
Would be nice to have a portability library here and to fill in the gaps where they exist (at least supporting SBCL, CCL, and ECL)
<|3b|>
(probably most compilers that want to optimize at all, so you can decide if you can completely skip calls if result isn't used, or rearrange them, or whatever)
smokeink has joined #lisp
<|3b|>
though as usual possibility of redefinition complicates things in CL :)
<aeth>
|3b|: hence my qualifications of sb-ext:*derive-function-types* or defined locally to the function or defined in the same file (or compilation-unit) or defined in the locked CL package
<|3b|>
right
<aeth>
Would be nice if every implementation had something like sb-ext:*derive-function-types* so you could just turn on the super optimizations super type derivations super static checking when you're done developing
<|3b|>
yeah, that's another reason for not doing full CL for dalvik to start with, easier to get small binaries :)
<aeth>
(The alternative is to put everything in one file but that breaks people's assumptions with using functions in macros because they don't put eval-when around literally everything)
<aeth>
(Also it's a bit surprising that C-c C-c could break your program because the compiler assumes C-c C-k)
Inline has quit [Quit: Leaving]
<no-defun-allowed>
do you think anyone would complain if i added that to cl-vep's package.lisp?
<aeth>
no-defun-allowed: It's possible there's a way for you to set it to T, have ASDF compile your files, and then restore it to the original value. I don't know ASDF that well.
<no-defun-allowed>
i'm already messing with the GC to make it more agressive
<aeth>
oh sorry it would be #+sbcl (setf sb-ext:*derive-function-types* T)
<aeth>
anyway, that's a build step
<aeth>
(There are probably some other things that are useful for final builds of a program, in various implementations)
frodef has joined #lisp
<no-defun-allowed>
hey frodef
<no-defun-allowed>
didn't seem to do much, probably since i've annotated functions myself to hell
<no-defun-allowed>
#+sbcl (setf (sb-ext:bytes-consed-between-gcs) (expt 2 26)) stays though
doubledup has quit [Read error: Connection reset by peer]
doubledup has joined #lisp
<|3b|>
~v@t ?
<|3b|>
v as parameter to a format directive means get the value from one of the arguments
<LdBeth>
Thanks
<LdBeth>
FORMAT iso complex.
<|3b|>
and still run into too many things it can't do :)(
<|3b|>
(at least without using the "just call an arbitrary function" feature
umpc has quit [Ping timeout: 245 seconds]
mason has quit [Ping timeout: 245 seconds]
<isoraqathedh>
The "call an arbitrary function" thing is awful to use as well.
mason has joined #lisp
<|3b|>
yeah, which is why i didn't count it
umpc has joined #lisp
<isoraqathedh>
You get exactly 1 argument, it must be package qualified (unless it's in cl-user, but you don't put things there anyway).
<isoraqathedh>
I don't remember if it can take extra format arguments in the format string.
<isoraqathedh>
Wasn't there someone who wrote a replacement package for format? If I remember right there was an attempt but the format string format is used in multiple places it ended up going nowhere.
<|3b|>
it passes stream, argument to print, flags for : and @ modifiers, and any prefix arguments from format string
smokeink has joined #lisp
pjb has joined #lisp
angavrilov has joined #lisp
shifty has joined #lisp
<trittweiler>
It's not so bad. I have a define-format-function which puts the symbols into an FMT package, so you use ~/FMT:IPV4/ for example
<LdBeth>
format can take a function instead of string spec
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
<no-defun-allowed>
if format did s-expressions that'd be nice
<|3b|>
you mean for specifying how to print?
asarch has quit [Quit: Leaving]
<LdBeth>
I think it's mainly for perfomance
<LdBeth>
or backward compatibility, since the original XP used a read macro to compile format spec
<LdBeth>
the later is now defined as FORMATTER function
schweers has joined #lisp
shrdlu68 has joined #lisp
varjag has joined #lisp
<no-defun-allowed>
yes, an s-expression dsl would be better for printing
<|3b|>
beach: i think my problem when i originally tried to make my own function info type is that i need a method on cleavir-env::make-info (which isn't exported) for it. otherwise it gets copied to a new global-function-info if i subclass that
smokeink has quit [Remote host closed the connection]
pjb has quit [Ping timeout: 252 seconds]
smokeink has joined #lisp
paule32 has joined #lisp
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
smokeink has quit [Remote host closed the connection]
gpiero has quit [Remote host closed the connection]
smokeink has joined #lisp
smokeink has quit [Remote host closed the connection]
mange has quit [Remote host closed the connection]
ggole has joined #lisp
frgo has joined #lisp
ealfonso has quit [Ping timeout: 244 seconds]
frgo has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
<xificurC>
a pretty large set of tools. Wondering if it is widely used
<no-defun-allowed>
there is quite a lot to work with
<no-defun-allowed>
my blur function takes 3 seconds to do one frame :/
<no-defun-allowed>
actually, it might be encoding/decoding overhead
<xificurC>
can't find ytools on quicklisp, so probably not
<no-defun-allowed>
1.8 seconds of blurring \:
<no-defun-allowed>
i have an idea to fix that actually
<beach>
|3b|: If you think something should be exported, then you could send me a PR for it.
<no-defun-allowed>
the blur at (x, y) is pretty much the blur at (x-1, y) minus everything at the very left column
<beach>
|3b|: I am not surprised that there are things that ought to be exported, but arten't.
<no-defun-allowed>
hey beach
<beach>
Hello no-defun-allowed.
<beach>
"aren't"
<|3b|>
beach: yeah, that would require me to know what i'm doing first though, so might take a bit :)
<beach>
Take your time.
* |3b|
is starting to think i should just treat them as special forms instead (at the ast/IR level, not language level) :p
<beach>
Why do you think that?
<beach>
Once the AST is generated, it will be a "call" AST, so you would have to do some searching and transformation of the AST I would think.
<no-defun-allowed>
right now the complexity is around O(ns), where n is pixel count and s is blur size
<|3b|>
for one thing, make-info passes special-operator-info through unmodified, so saves me a method :)
<beach>
Heh, OK.
<|3b|>
but also when i did write the method, seems like most of the things it changes on global-function-info don't really apply to the ffi calls at this point anyway
<|3b|>
they are always open coded, so inline isn't really applicable, not sure dynamic extent applies, etc
<|3b|>
not sure if compiler macros will be valid or not
<|3b|>
type declarations maybe, but possibly not in the same way
<beach>
OK, sounds like you need to contemplate it some more.
<|3b|>
yeah
<|3b|>
at least getting closer i think :)
<beach>
Good.
<beach>
Don't hesitate to run your ideas by me.
<beach>
I am a little distracted at the moment, but I'll do my best.
* |3b|
is always distracted :p
* edgar-rft
distracts you all
<no-defun-allowed>
aaaaa another distraction!
xrash has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
i have an idea for speeding up box blur which requires a diagram, can i link one here please?
<|3b|>
actually maybe not that, since you use format
<|3b|>
yeah, turning off *print-pretty* might do it
umpc has quit [Ping timeout: 260 seconds]
graphene has quit [Remote host closed the connection]
umpc has joined #lisp
graphene has joined #lisp
heisig has joined #lisp
mason has joined #lisp
<no-defun-allowed>
i'm annoyed all these loop clauses are all off by one from a haiku
<no-defun-allowed>
for this-x of-type single-float, from left-x to right-x, summing this-x
charh has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
and it wasn't the correct code anyways
charh has joined #lisp
anewuser has joined #lisp
nostoi has joined #lisp
Cymew has joined #lisp
nostoi has quit [Quit: Verlassend]
moei has joined #lisp
DataLinkDroid has joined #lisp
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp
earl-ducaine has quit [Remote host closed the connection]
pjb has joined #lisp
schweers has quit [Remote host closed the connection]
makomo has joined #lisp
housel has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
<makomo>
morning
<shka_>
good morning
<russellw>
morning!
scymtym has quit [Remote host closed the connection]
pjb has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
morning
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
milanj has joined #lisp
frgo has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
koenig has quit [Read error: Connection reset by peer]
gravicappa has joined #lisp
koenig has joined #lisp
orivej has joined #lisp
<no-defun-allowed>
Implementing fast box blur can happen some other time, I've got other things to do.
<no-defun-allowed>
Right now my "feedback" value overflows so I think balancing increments (+right) and decrements (-left) isn't working.
<beach>
Shouldn't you take the (possibly weighted) average of the three?
djh has joined #lisp
<no-defun-allowed>
Yes, that's the naive approach.
<no-defun-allowed>
The optimal approach as far as I know is to start at the left with all pixels considered, then move right subtracting leftmost pixels and adding rightmost pixels.
<no-defun-allowed>
I uploaded a diagram of this earlier.
<Shinmera>
no-defun-allowed: a box blur is a linearly separable convolution kernel, so you can do a horizontal and then a vertical pass. Then for dealing with edge conditions, pad your image on each side by the blur size so you don't need to check for overruns aside from the standard image bounds.
<no-defun-allowed>
The reason I think it's overflowing is because my edge logic isn't working correctly. It's literally an edge case.
<no-defun-allowed>
<no-defun-allowed "I uploaded a diagram of this ear"> Shinmera: I have written a box blur to that method but it's very slow
<no-defun-allowed>
What the hell? I never clicked on that.
<Shinmera>
generally, look into convolution kernels and how those are done fast
<no-defun-allowed>
It takes 1.5 seconds on a 1080x720 picture with a 20px radius.
<Shinmera>
if you can implement that generically you can have tons of neat effects fer free
<no-defun-allowed>
I have a method for doing it fast but I can't quite get it working.
<no-defun-allowed>
My method doesn't require extension though, it looks at the range [max(left, 0), min(right, width-1)] and uses that size to divide.
makomo has quit [Ping timeout: 272 seconds]
SenasOzys has quit [Ping timeout: 240 seconds]
<|3b|>
is the wrong version at least faster? :)
<no-defun-allowed>
Yes, it's much faster
<no-defun-allowed>
I only used that method horizontally and it's gone from 1.5 to 1.0 seconds.
<no-defun-allowed>
(now it errors with a description of where the overflow happened for testing so no, not really :)
frgo has quit [Remote host closed the connection]
dddddd has joined #lisp
frgo has joined #lisp
makomo has joined #lisp
SenasOzys has joined #lisp
frgo has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
Goodnight everyone!
<pfdietz>
Woo, a segfault in clisp. Is that still being maintained?
<Shinmera>
yes, but slowly
<Shinmera>
mailing list still gets responses at least
graphene has quit [Remote host closed the connection]
<jackdaniel>
pfdietz: do you have version from git or the latest release?
<jackdaniel>
the latter is quite dated
graphene has joined #lisp
<pfdietz>
Welcome to GNU CLISP 2.49.60+ (2017-06-25) <http://clisp.org/>
<pfdietz>
So, latest release?
<pfdietz>
Or whatever ubuntu 18.04 installs.
<pfdietz>
I'll build from git before I report anything.
pjb has joined #lisp
paule32 has joined #lisp
<pfdietz>
Where is the "official" git repo for clisp?
Kundry_Wag has quit [Remote host closed the connection]
scymtym has joined #lisp
regreg has joined #lisp
steiner has joined #lisp
frgo has joined #lisp
schweers has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
anewuser has joined #lisp
cl-arthur has joined #lisp
Guest5800_ has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
Josh_2 has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
Achylles has joined #lisp
jkordani has joined #lisp
<shka_>
hello
<warweasle>
hi
cage_ has joined #lisp
<Achylles>
how do I get the motivation to learn lisp. I have tried about 2 or 3 times, but then I loose motivation. Learning how to program alone is really hard...
<Josh_2>
First language?
<jackdaniel>
Achylles: most rewarding way to learn a language is trying to contribute to open source projects along a way
<jackdaniel>
there are many easy tasks out there, solving them impove your language knowledge and lets you move to more ambitious tasks
<jackdaniel>
*and* you have a motivation to learn, how to solve such task
<Achylles>
I have read books on Python, C, C++, (some java, but hate this), prolog, ruby, scala, bashscript and others. I am not a programmer, but I think I have the theory in my mind: variables, constants, strings, functions, etc...
<dlowe>
maybe you don't like programming?
<jackdaniel>
contributing to foss projects is all about practice. just jump in
pjb has joined #lisp
<schweers>
Achylles: my remark is slightly off-topic, because it’s about elisp, not Common Lisp, but ... Emacs actually did it for me. It enables you to solve very small problems, which are still rewarding.
<beach>
Achylles: As it turns out, programming is only slightly about getting the logic right, and mostly about communicating your intent to other people reading the code.
<Achylles>
Sorry, I thought the channel was about lisp
heisig has quit [Ping timeout: 264 seconds]
<beach>
Achylles: About Common Lisp.
<Josh_2>
^
<Achylles>
Anyways, I also try to learn it in emacs...
<beach>
Achylles: I am with dlowe. Perhaps that kind of activity is not something you would like to do.
<Achylles>
jackdaniel, links to foss projects?
<Achylles>
beach, I am sure I like it, but the point for me is loneliness
<beach>
Achylles: Then you need to hang out here more.
<beach>
Achylles: And go to ELS once a year.
<Josh_2>
does text really cure loneliness?
<Josh_2>
bit offtopic
<Achylles>
I have learned a lot by myself. I would say most computing stuff...
<jackdaniel>
you may check out other sharplispers projects, all are desperate for contributors ;-)
gravicappa has quit [Ping timeout: 260 seconds]
<Achylles>
Josh_2, ok I will be quiet if it is off-topic. Thx anyway...
<beach>
Achylles: That doesn't ring true to me. Given that programming is about communication, you have very likely missed the most important aspect of it.
<Josh_2>
wat no you are not off-topic
<Josh_2>
I was being off-topic
<beach>
Achylles: I suggest you expose your code here or on #clschool for people to comment on.
<beach>
Achylles: Then you will start learning the communication and maintenance aspect of programming.
SenasOzys has quit [Ping timeout: 252 seconds]
<Achylles>
beach, thx. I did not know about that channel :)
SenasOzys has joined #lisp
<scymtym>
jackdaniel: i'm not sure i agree regarding sharplispers projects. in my opinion, what they could use more of are experienced maintainers focusing on a single or at most a few projects - not more contributors if that means more pull requests
<jackdaniel>
still using semaphores seems like an easy task for gaining experience
Fare has joined #lisp
<jackdaniel>
maybe word "desperate" was inadequate
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
kajo has joined #lisp
pierpal has quit [Ping timeout: 260 seconds]
<beach>
scymtym: How do you pronounce your nick?
rumbler31 has joined #lisp
<scymtym>
beach: i don't. i spell it out
<Josh_2>
simtim
<Josh_2>
that's what my head says
<beach>
scymtym: I see. I wanted to know whether to pronounce the `c'.
<scymtym>
beach: i wouldn't know, i never put any thought into that question. it's just a word that randomly came up in my mind around 20 years ago. it has good uniqueness so i stuck with it
rumbler31 has quit [Ping timeout: 252 seconds]
SenasOzys has quit [Ping timeout: 252 seconds]
housel has joined #lisp
SenasOzys has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
asarch has joined #lisp
<shka_>
i have data structure releated question
pjb has quit [Remote host closed the connection]
<shka_>
is it ok to ask here or should i move to the lispcafe?
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
pjb has joined #lisp
frgo has quit [Read error: Connection reset by peer]
<Bike>
it might be alright
<shka_>
ok
<shka_>
i want to make sparse vector
<shka_>
that is: one that can handle large portion of it's content being null
<shka_>
my idea is to basicly take rrb type vector structure, and install bitmask at each node to store information about emptyness of subtree
<shka_>
how does it sound?
Inline has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
<Bike>
i'd just use a hash table.s impler, you know
<Bike>
could write out the api and then compare performance between them
esrse has joined #lisp
anewuser has quit [Quit: anewuser]
papachan has joined #lisp
SenasOzys has quit [Ping timeout: 252 seconds]
whartung has joined #lisp
<shka_>
Bike: that is actually decent idea, but I would also keep it immutable
<shka_>
i need this because it makes error safety far easier
<shka_>
namely i want it to implement data frame
<shka_>
plenty of data sets has HUGE chunks of NULL cells
<shka_>
... but i actually already have immutable hash table
<shka_>
hmmm
<shka_>
i should think about it
SenasOzys has joined #lisp
schweers has quit [Ping timeout: 260 seconds]
frgo has joined #lisp
frgo has quit [Ping timeout: 272 seconds]
<cage_>
jackdaniel, please can you give some more explanation about the issue on log4cl? I mean, only revert changes on watcher.lisp is needed?
<Blackbeard>
I could do stumpwm::cancel-timer
<Blackbeard>
but I don't know what is the name of it to kill it
<jackdaniel>
cage_: not exactly (though close). In the meantime bordeaux-threads gained semaphore implementation. so it would be reverting to using semaphores, but semaphores provided by bt (not by bt-semaphore)
<jackdaniel>
after that testing on sbcl, ccl and ecl should follow
random-nick has joined #lisp
<cage_>
i have changed all "bt-sem:" to "bt:" and removed all the #(+|-)ecl reader macros, i have tested only on sbcl
<shka_>
pjb: it does not sound like i want it, but it seems to be cool in it's own rights!
edgar-rft has quit [Remote host closed the connection]
<pjb>
Yes.
<pjb>
Depends on what you need the sparse vector for.
<pjb>
Oh, and SDR are vectors of bits actually, so…
<shka_>
well, this sounds like something that can be used as neural network input
<shka_>
but anyway
<shka_>
i simply want R style data frame, i want to have batch operations to modify it, and i don't want to wreck it when a condition is signalled
<Bike>
i've only worked with sparse tensors in matlab, and there i think it's just a linked list
<shka_>
so instread i want to perform graceful rollback
<shka_>
Bike: i think that those are CSRs
<shka_>
anyway, i think that masked rrb vector should work in this context fine
<shka_>
at least on paper it looks like efficient approach
<shka_>
i will read about SDR though
mathrick_ has joined #lisp
nowhereman_ has quit [Ping timeout: 252 seconds]
mathrick has quit [Ping timeout: 240 seconds]
Fare has joined #lisp
<shka_>
SDR sounds like something akin to datasketches
<oni-on-ion>
shka_: i heard a lot of R peeps using dataframes have migrated to julia
<shka_>
no wonder
<shka_>
;-)
<shka_>
but i like CL
frgo has joined #lisp
<oni-on-ion>
i love CL too. but ... this new girl ... >_<
<pfdietz>
That meme
<shka_>
well, some moved to python
<shka_>
anyway i hate python, R is limiting and julia is too young
<shka_>
CL rocks
<aeth>
I guess people who chase the trendiest langauges usually switch every 5 years or so. (Or they're replaced by people who do.)
Fare has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
<aeth>
Compile-to-JS is the worst for this. Remember CoffeeScript? Only 6 years or so past peak hype and now "no one" uses it. If you're writing something that takes years to write, you'd have an unpopular language by the time you finished if you picked compile-to-JS.
Fare has joined #lisp
<oni-on-ion>
julia isnt too young =) its about 10 years old now. and its 1.0 - lots of happy python/matlab/R users gone to it
<oni-on-ion>
and *awesome* libraries.
<shka_>
aeth: remember dart? :D
<oni-on-ion>
hey i seen a lisp-in-dart yesterday
<shka_>
oni-on-ion: well, still not lisp is enough
<aeth>
shka_: Almost mentioned it too, but I didn't want to turn this channel into a language graveyard. :-)
<aeth>
oni-on-ion: first time I've seen Dart mentioned in like 2-3 years, and even then it was unpopular
<aeth>
s/even then/even back then/
<oni-on-ion>
shka_: what do you mean? people telling me julia is lisp but m-expression
<pjb>
oni-on-ion: they are missing the s-exps.
<oni-on-ion>
it was google tho eh?
charh has quit [Remote host closed the connection]
<oni-on-ion>
also um. i learned yesterday that Google, is using, Swift, for Tensorflow. ?!?
<oni-on-ion>
pjb: m-exps.
<aeth>
oni-on-ion: I'm not sure language creation time matters with this, though. If Common Lisp became the #4 most popular language tomorrow, the clock would be ticking, and in 5 years it'd have no more than 1/3 the users, probably. Because the people who make a language very popular move around unless they have no choice (e.g. JS, C, Java, etc.)
<oni-on-ion>
its amazing to see julia is actually super performant without going through any low level hoops. those guys have really nailed the low level and high level thing; also david a. moon is contributing to it (the lisp guy.)
<aeth>
oni-on-ion: In a sense, CL already had a few hype phases, and we're just the leftovers from that, with a few people added every now and then from reading the old literature from that hype phase.
rumbler31 has quit [Remote host closed the connection]
<pjb>
aeth: it's quite different. CL was standardized in the heart of the AI winter. That calmed quite an amount of hype.
<pjb>
aeth: then, it was at a time when getting a computer able to run it would cost an arm, of a year of salary…
<oni-on-ion>
aeth: creation time?? oh, i was answering someone saying julia is still too young. but about CL, its still tied to an image, so nope
<pjb>
aeth: imagine, you create Python, and to run it, you have to buy a $100,000 computer.
<oni-on-ion>
aeth: also true about the hype. however i do see many new articles as well
<pjb>
whatever the hype, the popularity wouldn't meet it.
<oni-on-ion>
pjb: wasn't prolog sort of sibling with lisp? but over in europe/asia ?
<pjb>
Now, of course, I exagerate a little, because MacLisp ran on Macintosh 512 or SE. But it was better to have maxed out the RAM (which costed the other arm).
<pjb>
oni-on-ion: prolog was invented in Marseilles in France. It's very different, it was a new kind of programming language: purely declarative.
<aeth>
pjb: I thought CL was standardized *after* its peak? At least the 1994 standard.
<pjb>
aeth: the AI winter was long. :-)
<aeth>
pjb: At least AI is perfectly fine now and not overpromising.
<pjb>
LOL
<oni-on-ion>
prolog is french?!?!? =D i always wanted to make a chart or graph showing all the country/language of origin for proglangs.
esrse has quit [Ping timeout: 252 seconds]
<russellw>
so do you count Ada as American or French?
<aeth>
If prolog is french then how come it's not prologue?
paule32 has quit [Ping timeout: 252 seconds]
<oni-on-ion>
aeth =) the first link in google is a dictionary entry for exactly that
Guest5800_ has quit [Quit: Connection closed for inactivity]
<jkordani>
it is said that in the few years of its use, it saved more money than darpa had put in AI research since it had started doing so
kajo has joined #lisp
Cymew has joined #lisp
<jkordani>
the paper of it's development outlines an agile approach although I hate using that word
nirved has quit [Ping timeout: 240 seconds]
charh has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
equwal has quit [Ping timeout: 246 seconds]
Sauvin has quit [Read error: Connection reset by peer]
rozenglass has joined #lisp
Achylles has quit [Quit: Leaving]
Achylles has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
lumm has quit [Quit: lumm]
lumm has joined #lisp
razzy has quit [Remote host closed the connection]
warweasle has quit [Quit: later]
Achylles_ has joined #lisp
Jesin has quit [Quit: Leaving]
orivej has joined #lisp
Bindler has joined #lisp
razzy has joined #lisp
Jesin has joined #lisp
<razzy>
aaaaah, dart :]
Bindler has quit [Ping timeout: 252 seconds]
anunnaki has quit [Ping timeout: 272 seconds]
anunnaki has joined #lisp
shrdlu68 has quit [Ping timeout: 252 seconds]
milanj has joined #lisp
razzy has quit [Read error: No route to host]
razzy has joined #lisp
astronavt has joined #lisp
terpri has quit [Ping timeout: 252 seconds]
<jasom>
oni-on-ion: It was ARPA that funded the PDP-10 with an entire address space of core memory for MIT though, I have no idea how much that cost, and I heard it was never that reliable.
<oni-on-ion>
APRA is like DARPA? that means it funded C as well then =)
<jasom>
oni-on-ion: Yeah, they left the "D" off so they could pretend it wasn't military, but at some point gave up pretending I think :P
<oni-on-ion>
ahh , heh =)
rumbler31 has joined #lisp
<jasom>
ah in 1973 they amended the charter to be "direct mil\itary application" only apparently
razzy has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
razzy has joined #lisp
Bindler has joined #lisp
rnmhdn has quit [Ping timeout: 244 seconds]
<oni-on-ion>
for the country!
<pjb>
Well, anyways, even if you do pure civilian research on pure private founds, as soon as the US government deems it good for national security, they've got the laws to take over all of it, and forbid you to ever talk about it.
<pjb>
So, in essence, all the activity in the US is directed directly toward military applications.
<razzy>
power hungry bastards :]
<pjb>
:-)
<pjb>
Worked for them so far.
<razzy>
and military is the worst way to get power
<pjb>
And they've got the contact with ET even.
<razzy>
how they are not seeing this?
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
<razzy>
pjb: how could you know?
<dlowe>
This is easily #lispcafe material
<pjb>
There are enough hints.
<pjb>
Yep.
<razzy>
dlowe: thx
<phoe>
Huh
<phoe>
I really like one particular feature of my PROTEST library
<phoe>
when I'm defining protocols, it doesn't allow me to define duplicate functions in dependent protocols
<phoe>
so it's a very good indicator when I should extract a particular function to a mixin
kajo has joined #lisp
dented42 has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
dented42 has quit [Client Quit]
regreg has quit [Ping timeout: 252 seconds]
<razzy>
hmm,.. are function declarations in every lisp global?
<phoe>
razzy: what do you mean, every lisp?
<phoe>
and no, (flet ((foo () 42)) #'foo) this isn't global
<Bike>
function declarations?
<jasom>
razzy: what do you mean by "function declarations"?
<Shinmera>
There's no declaration of functions, only definition.
<razzy>
are (defun minefunction) global? always?
<phoe>
well
<Shinmera>
They're in the global environment
<phoe>
it isn't global in some lisps, because they don't have the DEFUN operator
<Shinmera>
But there might be multiple such environments
<razzy>
most of you guessed what i meant
<phoe>
DEFUN is a Common Lisp thing.
<Bike>
defun is global
<phoe>
in Scheme, a toplevel DEFINE is global, too.
<phoe>
but nothing prevents you from defining local functions.
<Bike>
scheme also uses DEFINE in syntactic sugar for labels
<razzy>
i ask if there is a lisp, that have special local function definitons
<razzy>
like (let ) but for functions
<phoe>
all of them?
<Bike>
flet, labels
<phoe>
Common Lisp has FLET and LABELS, Schemes have similar mechanisms
<Bike>
or in scheme, just let
<phoe>
you can use let in Lisp, too, (let ((foo (lambda () 42))) (funcall foo))
<jackdaniel>
and letrec
<frodef>
is there a standard elisp function for moving a sexpr out of its enclosing sexpr?
<phoe>
frodef: out of? can you give me an example?
<frodef>
(foo (bar) zonk) => (bar) when point is at (bar)
<jasom>
razzy: defun is global, but the name for a function is a symbol; you could have a macro that does `(defun ,(gensym) ...) and you'd have a global function with a name that is unreachable
<phoe>
frodef: I'm using smartparens for that, it's sp-raise-sexp in it
<frodef>
phoe: there is a raise-sexp it seems..
<frodef>
phoe: looks perfect, thanks! :)
graphene has quit [Remote host closed the connection]
<phoe>
yay!
kmb has joined #lisp
graphene has joined #lisp
cage_ has quit [Quit: Leaving]
ggole has quit [Quit: ggole]
m3tti has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
Bindler has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
dented42 has joined #lisp
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
doubledup has quit [Quit: Leaving]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<razzy>
phoe: thx, did not occur to me i can have local functions :]
<pjb>
razzy: that's because you learned C, and not Pascal.
<razzy>
i meant, this option did not occur to me in common lisp. i always used defun
<razzy>
and did not have big enough project to justify local function calls
<aeth>
It's a style choice
<aeth>
Almost every local function can also be a global function that's not exported. The main difference is that you might need more arguments to the lambda-list in the latter because you can't rely on the outer function's scope, but that makes things more explicit.
<razzy>
i like least possible variables and function calls to be global :]
<aeth>
(I say "almost every" because if I speak in absolutes on IRC someone will find a counterexample. I think it's actually every)
m3tti has quit [Quit: Leaving]
m3tti has joined #lisp
<jasom>
definitely not every because closing over lexical variables is different from closing over dynamic variables in important ways, and non-top-level DEFUNs are odd.
<aeth>
(oh dynamic variables, I forgot about them)
<jasom>
the classic (defun accum (x) (lambda (y) (incf x y)))
rumbler31 has joined #lisp
<pfdietz>
Also, lexical things around defuns may not play nicely with threads, while dynamic variable bindings are (usually?) thread-local.
<aeth>
jasom: Depends on what you count as equivalent. Yes, you can no longer mutate x from within the flet function if you move it to outside, but you could have it return a value that is then set in the calling function. Since you have control over the API, whether or not that counts as equivalent is debatable.
aydio has joined #lisp
<aeth>
There might be some case where you have to express it as the flet closure, though.
<jasom>
there are APIs that cannot be easilly expressed without closures. It is possible they are all bad APIs though.
rumbler31 has quit [Ping timeout: 252 seconds]
Achylles_ has quit [Quit: Leaving]
aydio has quit [Client Quit]
<aeth>
jasom: I guess you could make an argument that explicitly creating those closures from an external defun and binding the returned lambdas could still be a better API than using FLET, though. Because you could use it from multiple functions.
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
<aeth>
(Still wouldn't quite be the same thing.)
Roy_Fokker has joined #lisp
cl-arthur has quit [Quit: Lost terminal]
<trittweiler>
I try to define functions locally that are very intrinsically coupled to the parent function. Top-level functions are coupled to an object or the package instead. Local functions are not directly invokable from the REPL, so that already draws a "natural" line. Ease of meaningful naming is another thing that's often difficult for local functions (it's usually a frob-foo, grovel-foo, or similar.)
scymtym has quit [Ping timeout: 260 seconds]
<pjb>
aeth: usually, local functions are closures. To have them global, you'd need to make them objects.
<jasom>
I used to prefer global functions just because slime/sbcl just handled them a lot better (v, what it looks like in backtrace &c.). The tooling has improved considerably since I made that decision though.
asarch has quit [Quit: Leaving]
<trittweiler>
if the closed-over variables are not modified in the local functions, they can be trivially lambda-lifted
dented42 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<Josh_2>
Is ABCL maintained?
<phoe>
yes
kmb has quit [Quit: kmb]
varjag has joined #lisp
<Josh_2>
ty
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
beaky has quit [Read error: Connection reset by peer]
SenasOzys has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
beaky has joined #lisp
Duns_Scrotus has quit [Ping timeout: 252 seconds]
fowlduck has quit [Ping timeout: 252 seconds]
SenasOzys has joined #lisp
Duns_Scrotus has joined #lisp
fowlduck has joined #lisp
<ober>
very shallow yes
rozenglass has quit [Ping timeout: 245 seconds]
cobax has quit [Ping timeout: 240 seconds]
angavrilov has quit [Remote host closed the connection]
terpri has joined #lisp
frodef has quit [Ping timeout: 252 seconds]
LiamH has quit [Quit: Leaving.]
jxy has quit [Remote host closed the connection]
Achylles has quit [Remote host closed the connection]
frodef has joined #lisp
terpri has quit [Ping timeout: 252 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
trittweiler has quit [Ping timeout: 246 seconds]
trittweiler has joined #lisp
lumm has quit [Quit: lumm]
robotoad_ has quit [Quit: robotoad_]
astronavt_ has joined #lisp
astronavt has quit [Read error: Connection reset by peer]
astronavt__ has joined #lisp
astronavt_ has quit [Ping timeout: 272 seconds]
trittweiler has quit [Ping timeout: 272 seconds]
emerson has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Oladon has joined #lisp
m3tti has quit [Quit: Leaving]
Bike has quit [Ping timeout: 256 seconds]
cl-arthur has joined #lisp
Fare has quit [Ping timeout: 245 seconds]
jxy has joined #lisp
dented42 has joined #lisp
emerson has quit [Ping timeout: 630 seconds]
shifty has joined #lisp
rumbler31 has joined #lisp
jackdaniel has quit [Ping timeout: 272 seconds]
frodef has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Ping timeout: 244 seconds]
terpri has joined #lisp
Fare has joined #lisp
varjag has quit [Ping timeout: 252 seconds]
Fare has quit [Ping timeout: 245 seconds]
energizer_ has joined #lisp
justinmcp_ has joined #lisp
nefercheprure has joined #lisp
nonlinear has joined #lisp
tomaw- has joined #lisp
dvdmuckle_ has joined #lisp
TMA has quit [*.net *.split]
papachan has quit [*.net *.split]
lnostdal has quit [*.net *.split]
vibs29 has quit [*.net *.split]
energizer has quit [*.net *.split]
ebzzry has quit [*.net *.split]
NB0X has quit [*.net *.split]
_bryan has quit [*.net *.split]
PuercoPop has quit [*.net *.split]
justinmcp has quit [*.net *.split]
sigjuice has quit [*.net *.split]
alandipert has quit [*.net *.split]
fouric has quit [*.net *.split]
vxe has quit [*.net *.split]
flip214 has quit [*.net *.split]
mfiano has quit [*.net *.split]
dvdmuckle has quit [*.net *.split]
fredsir has quit [*.net *.split]
shenghi has quit [*.net *.split]
salva has quit [*.net *.split]
bmansurov has quit [*.net *.split]
tomaw has quit [*.net *.split]
dvdmuckle_ is now known as dvdmuckle
sigjuice has joined #lisp
alandipert has joined #lisp
emerson has joined #lisp
lnostdal has joined #lisp
bmansurov has joined #lisp
mfiano has joined #lisp
salva has joined #lisp
energizer_ is now known as energizer
shenghi has joined #lisp
Bike has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
lnostdal has quit [Read error: Connection reset by peer]