<no-defun-allowed>
The CLHS is proprietary, so it cannot.
fragamus has quit [Ping timeout: 240 seconds]
<seok>
Oh.
wxie has quit [Ping timeout: 245 seconds]
kajo has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
You are allowed to download it, maybe you aren't allowed to redistribute it unless some specific rules are met, it's probably not compatible with the other licenses of Portacle components, but IANAL and neither is anyone working on Portacle.
jonatack has quit [Quit: jonatack]
toorevitimirp has quit [Ping timeout: 276 seconds]
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
__jrjsmrtn__ has joined #lisp
amerlyq has joined #lisp
toorevitimirp has joined #lisp
nullman has quit [Ping timeout: 244 seconds]
nullman has joined #lisp
astronavt has quit [Quit: ...]
astronavt has joined #lisp
toorevitimirp has quit [Ping timeout: 265 seconds]
<minion>
Remembered. I'll tell shka_ when he/she/it next speaks.
* thijso
didn't expect to be writing so much C code while working in CL...
<pjb>
thijso: what C code do you write?
<thijso>
I've been fixing a number of c-inline stuff in ECL and usocket these past couple of days.
<pjb>
So, you're not working "IN" cl , you're working "ON" CL stuff written in C…
<asdf_asdf_asdf>
(declaim (inline foo))
<asdf_asdf_asdf>
@thijso; this?
<thijso>
However, I now seem to have a state where I can actually use one of the logging packages I tried earlier. log4cl and verbose both ended up having the same issue, but now that I've gotten my patches merged I can try using one of them again. (<- Shinmera )
<Shinmera>
\o/
<thijso>
asdf_asdf_asdf: nope, c-inline. As in inline C code (used in Embedded Common Lisp)
rippa has joined #lisp
amerigo has quit [Quit: Connection closed for inactivity]
<thijso>
pjb: well, I'm "forced" to do that, otherwise what I'm actually working on wouldn't work (or get nice UNKNOWN_ERROR's sprinkled everywhere...)
<asdf_asdf_asdf>
thijso; write what You have so far.
<pjb>
Yes, sometimes we have to do low-level stuff…
<thijso>
asdf_asdf_asdf: what do you mean? I've found the (or, at least some) issues and fixed them. Now I can go back to what I was originally working on
<asdf_asdf_asdf>
What need to solve problem?
<thijso>
I'm actually a little shocked at how unfinished a lot of stuff seems in relation to ECL. In ECL code itself, but also supporting code in for example usocket and bordeaux-threads
<asdf_asdf_asdf>
Someone know which instruction in aliens instructions is void* and null from C?
<thijso>
Comments like ";; really big FIXME: This whole copy-buffer thing is broken." in SBCL sockets.lisp also doesn't really inspire a lot of nice fuzzy feelings...
nanoz has joined #lisp
<Shinmera>
thijso: I think in ECL's case it's because it didn't recieve a lot of love until jackdaniel picked up as maintainer.
shka_ has joined #lisp
<thijso>
Yeah, not complaining. It's just that I usually work in SBCL and haven't had the experience of these kinds of issues before. However, I'm stuck with ECL for now. Unless anyone knows of other ways to build android apps in Common Lips (that don't cost money).
Oladon1 has joined #lisp
<thijso>
But, on the other hand, seeing that comment in the SBCL source code... maybe I've just been lucky ;)
<Shinmera>
I have a CLOS regression in SBCL that I still need to reduce and report
<thijso>
Common Lips? Erhmm... Not what I meant. :) Common Lisps
red-dot has joined #lisp
Oladon has quit [Ping timeout: 245 seconds]
<pjb>
thijso: ecl is basically a one-man operation. The miracle, is that there has been one man for so long to make releases so far…
EvW1 has quit [Ping timeout: 245 seconds]
makomo_ has joined #lisp
makomo has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 260 seconds]
superkumasan has quit [Ping timeout: 240 seconds]
dale has quit [Quit: My computer has gone to sleep]
nanoz has quit [Read error: Connection timed out]
nanoz has joined #lisp
dale has joined #lisp
asdf_asdf_asdf has quit [Remote host closed the connection]
dale has quit [Quit: My computer has gone to sleep]
Lycurgus has joined #lisp
dale has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
Hsab_Selur has quit [Ping timeout: 246 seconds]
asdf_asdf_asdf has joined #lisp
nowhere_man has joined #lisp
varjag has joined #lisp
ebrasca has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
gravicappa has joined #lisp
Oladon_work has joined #lisp
alexande` has joined #lisp
alexanderbarbosa has quit [Ping timeout: 276 seconds]
asdf_asdf_asdf has quit [Remote host closed the connection]
asdf_asdf_asdf has joined #lisp
stepnem_ has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
georgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
asdf_asdf_asdf has quit [Ping timeout: 240 seconds]
cosimone has quit [Quit: Leaving]
asdf_asdf_asdf has joined #lisp
UgurKap has joined #lisp
iovec has joined #lisp
sjl_ has joined #lisp
akoana has joined #lisp
georgie has joined #lisp
kajo has quit [Ping timeout: 245 seconds]
q9929t has joined #lisp
Nomenclatura has joined #lisp
Inline has joined #lisp
pnp has joined #lisp
raghavgururajan has quit [Read error: Connection reset by peer]
<jackdaniel>
pjb: that might have been true for some time, but right now we have two regular maintainers and a steady stream of 3rd party contributions
permagreen has quit [Remote host closed the connection]
<jackdaniel>
thijso: thank you for your work on sockets in ecl
<whartung>
anyone ever see anything that compares the CL type system to Ada?
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kajo has joined #lisp
retropikzel has joined #lisp
igemnace has joined #lisp
q9929t has quit [Quit: q9929t]
vlatkoB has quit [Remote host closed the connection]
Nomenclatura has quit [Quit: q]
vlatkoB has joined #lisp
<Xach>
I have not
vlatkoB has quit [Remote host closed the connection]
<thijso>
jackdaniel: you're welcome. Thank you for ecl in general
sauvin has quit [Read error: Connection reset by peer]
analogue has joined #lisp
karlosz has joined #lisp
amerlyq has quit [Quit: amerlyq]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
jonatack has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
<aeth>
whartung: I think the main difference is that CL's type system is typical in that deftype is just a renaming, but afaik in Ada if you ask for a Foo you must get a Foo even if it's just defined as a range 10 .. 20 or a mod 24 (both of which CL has an equivalent for). That even wouldn't really work in CL. How would you make 13 be specifically of type foo in CL? Doesn't really work well without full static typing.
<aeth>
That's if I'm remembering that correctly.
bitmapper has quit []
<Bike>
i think ada's type system is nominal, yes
sameerynho has joined #lisp
<Bike>
whereas lisp's is structural
<aeth>
One thing I see here in Wikipedia (and I think I've mentioned this here once before!) is that there's pretty much a CL equivalent for every example here except the second subtype. You can represent weekdays as '(member :monday :tuesday :wednesday :thursday :friday :saturday :sunday) but you can't then do (range :monday :friday) as working-days. https://en.wikipedia.org/wiki/Ada_(programming_language)#Data_types
<aeth>
member types are, afaik, unordered, although the implementation will probably test them in the order you defined them.
<Bike>
they're unordered. you shouldn't rely on any kind of ordering within types
<aeth>
There also isn't a defsubtype, just a deftype. I guess the difference is that a defsubtype would have to determine that your definition is a subtype of a provided type in addition to defining the type. This could get complicated (or impossible?) if you provide arguments to the deftype or hypothetical defsubtype
<aeth>
whartung: And those are all of the differences I can get from public information on Ada without knowing Ada. There are probably more.
<sjl_>
Bike: can you rely on (check-type foo '(and t1 t2)) to check that foo is of type t1 before t2?
<sjl_>
> For example, the type specifier (and integer (satisfies evenp)) denotes the set of all even integers.
<sjl_>
If it's not guaranteed to check integer first, evenp could throw
<sjl_>
s/throw/signal an error/
<Bike>
a type specifier denotes a set, not a predication operation. that's wrong, that's all
<seok>
Morning
<sjl_>
I suppose. Seems odd that they would choose an example that would be broken if used with typep or check-type...
<pjb>
Bike: it is not structural: (deftype p1 x y) (deftype p2 x y) (p2-x (make-p1 :x 1 :y 2)) is not conforming!
<Bike>
is that supposed to be lisp?
<pjb>
is that #lisp?
<sjl_>
I think he meant defstruct, not deftype
<Bike>
i mean that's not how deftype works. is it defstruct
gxt has joined #lisp
<pjb>
Sorry s/deftype/defstruct/
pnp has quit [Remote host closed the connection]
<Bike>
well what i mean is that the deftype mechanism doesn't add any type names that affect resolution of type system questions. it is true you can name different struct types
<pjb>
Lisp is a generic programming language. Meaning that most code you write is just not typed, it's "template code" or "generic code". It can transport data of any type. It's usually left to the client code to determine what gets in, and what it gets out.
<pjb>
Take for example sort. sort can work on sequences of anything, you just give it a lessp function.
<pjb>
So all those discussions about typing and dumb and boring.
<pjb>
On of the tests to know if a person will be able to become a programmer, is to check if that person is able to reason with boxes, abstracting the contents. Trying th re-introduce restrictions on boxes such as boxes that can hold only numbers or only shoes doesn't help!
clothespin has joined #lisp
<pjb>
Of course, typing gives a lot of work to searchers and PhD students. It gives a lot of diplomas and university budgets…
<Josh_2>
xD
<sukaeto>
whartung: it's really hard to compare the type systems of Lisp and Ada
<sukaeto>
in Ada, every expression is typed at compile time
Achylles has quit [Remote host closed the connection]
alexande` has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]
<sukaeto>
as others have mentioned, you can have e.g. distinct range types which are incompatible with one another
alexanderbarbosa has joined #lisp
<sukaeto>
in Ada, defining types is a large part of programming. The type system in Ada can help you make sure you're not making semantic errors (for a simple e.g. trying to multiply a speed and a distance when you meant to multiply a speed and a time)
<sukaeto>
it's a lot different from Lisp, where you (at least if you're me :-) ) just kind of grow code organically at the REPL
retropikzel has quit [Remote host closed the connection]
retropikzel has joined #lisp
ebrasca has quit [Remote host closed the connection]
t58 has quit [Read error: Connection reset by peer]
<aeth>
sukaeto: I was saying what I said under the assumption that it would apply even if you (with ordinary semantics) DECLAREd every variable in your functions/bindings, Ada-style, and even used an Ada-syntax reader macro, what would differ.
<aeth>
Of course, with that many macros, you could probably cons up additional type-tracking data structures to match Ada more precisely...
orivej has quit [Ping timeout: 265 seconds]
stepnem has quit [Ping timeout: 246 seconds]
stepnem_ has joined #lisp
<aeth>
sukaeto: as for your specific problem (speed vs. distance), I wouldn't be surprised if Ada (or an extended Ada) had units in its type system
gareppa has joined #lisp
Lycurgus has quit [Quit: Exeunt]
gxt has quit [Remote host closed the connection]
<sukaeto>
aeth: it doesn't provide them in the standard library, but they're easy enough to declare on your own
<sukaeto>
and I think GNAT (which is pretty much defacto Ada) provides a library that will generate the matrix for you
<sukaeto>
and yeah, of course you *could* implement such rich type level programming in Lisp. I mean, look at what the Qi/Shen team has done!
t58 has joined #lisp
ggole has quit [Quit: Leaving]
gravicappa has quit [Ping timeout: 245 seconds]
shka_ has quit [Ping timeout: 265 seconds]
karlosz has quit [Quit: karlosz]
orivej has joined #lisp
<aeth>
sukaeto: Defining types is almost always a large part of programming, though, and it just differs based on the language. e.g. usually that means defining classes.
permagreen has joined #lisp
<aeth>
I guess the main exception would be ultra-dynamic languages like Lua maybe? Just a bunch of tables there.
<sukaeto>
it's kind of hard to explain (well, without writing an entire essay on the topic). In Ada, pretty much everything is about types and the relationships between them.
<whartung>
yea, there’s just been more “Ada” traffic (seemingly) recently, and (mostly) focused on its type system. And while typing is idiomatically optional in CL, it seems that the CL type system is quite rich. Whether it’s rich enough, or enforced well enough, to opt as a stand in for Ada (if all you were interested in was a typed language, vs some other issue), that I don’t know. Unlikely, but was just curious by how much
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<whartung>
and ceratinly not in every case, but whether there may be examples where the CL type system is “good enough” for someone who might else look at Ada
shka_ has joined #lisp
<sukaeto>
I think it's fair to say "you can do things in Ada out of the box with its type system that would require you to write a lot of macro code to achieve in Lisp"
<aeth>
whartung: Two problems. (1) You only get that richness if you use DECLARE, but DECLARE has undefined semantics (usually just means that it's ignored in some implementations, like CLISP) and the only implementation that normally handles it properly in almost all cases (SBCL) also does the worst (for reliability) semantics when at the (safety 0) optimization level, i.e. it assumes the type, like C.
Codaraxis has joined #lisp
<aeth>
DECLARE is fine, although you might want a macro for less-awkward syntax. I've written a lot of code both ways, thoguh.
<aeth>
*though
<whartung>
but the key question is whether, even with enough macro code, was CL capable at all. How much of an overlap is there. The point about subtypes is important, i think, and structurally similarity — that may be a deal breaker
<sukaeto>
well, it's clearly capable. One could make the argument that Shen's type system is even more powerful than Ada's
<sukaeto>
while Shen is it's own thing now, it started out as just a bunch of Common Lisp macros, if I understand it correctly
<whartung>
and, yea, there’s the question of implemenation level enforcement.
<aeth>
whartung: The other problem (2) CL usually compiles file-by-file and leaves (almost, structs are undefined here) everything up for redefinition so unless you violate the standard with something like sb-ext:*derive-function-types* you won't get the full benefit of static typing outside of a single file and the CL package built-ins (and even in SBCL, you don't get quite the full benefit in a file because the style is so uncommon)
<aeth>
(That variable is false by default)
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
<sukaeto>
in any event, in Ada the type system's real value is in how the programmer an leverage it to get "provably correct" code
<aeth>
whartung: And relating problem #2 to problem #1, SBCL only does its static type checking when safety > 0 so you are actually less safe than in C/C++ where you'll at least get static safety without runtime safety! With SBCL you have both or neither, not C-level safety.
analogue has quit [Quit: Leaving]
<pjb>
DECLARE is the user (programmer) giving hints to the compiler. It is by definition a bad thing.
<sukaeto>
(scare quotes because of course you don't get provably correct in general. But you can get some strong guarantees over some facets of the code.)
<sukaeto>
the extra efficiency the compiler can squeeze out given the extra information the types encode is just a bonus
<aeth>
whartung: Additionally, the ftype of a function that you get with DECLARE/DECLAIM-heavy code isn't exposed like the type information is. It's just for the compiler afaik.
<whartung>
right
<pjb>
The use of type in statically typed programming languages is to restrict the data flow. In dynamically typed programming language, the data flow is not restricted, we just check the type of the operands when needed. If you need to restrict the data flow, perhaps you should do so more explicitely than by just decclaring types. You should just write down the data flow, so to ensure that data that enters it doesn't leave it and no
<pjb>
data can enter it.
<aeth>
pjb: You are incredibly, absolutely wrong as far as types go. There is a major difference between DECLARE and CHECK-TYPE where supported, and SBCL will take a CHECK-TYPE to mean that the variable before that point is of type T, since anything can be provided, and you can at runtime turn that into the item of the correct type during the CHECK-TYPE process.
<aeth>
So DECLARE can guarantee more than CHECK-TYPE
<pjb>
Also, when you describe such data flow, you won't filter just by types, but you can and should filter more. For example, on units, or on the provenance of the data!
<aeth>
If you want to talk about static typing in CL, all you have is DECLARE.
<aeth>
(Static typing in addition to dynamic typing, i.e. gradual typing.)
<pjb>
For example, there should be no reason to use a password from something else than physical user input.
<sukaeto>
pjb: but see, type can (and in Ada, frequently does) encode units
<sukaeto>
I'm not sure what you mean by "provenance of the data"
sigjuice has quit [Ping timeout: 240 seconds]
<pjb>
That is, you need to tag the data by more than types, anything, and to filter on those tags.
xkapastel has quit [Quit: Connection closed for inactivity]
<pjb>
All this to mean again that types are useless and boring. Forget about them.
<sukaeto>
pjb: that is absolutely untrue
<pjb>
Start by writing a unit system first.
<aeth>
sukaeto: Afaik, pjb is against gradual typing, so while CL implementations are able to support it, pjb argues against this.
Bike has quit [Quit: Bike]
<sukaeto>
if you're looking at a system like Java or C and you think that what they offer is all there is to type systems, then I can understand how you'd get that impression
sigjuice has joined #lisp
<pjb>
I don't mind the compiler doing its job and signaling type inconsistencies early. But I don't want to have write anything about it.
<whartung>
an example of provenance of data, sukaeto, is Perls taint system
<sukaeto>
pjb: oh, you're saying that types in Lisp are useless and boring?
<sukaeto>
if so, sorry I misunderstood
<pjb>
sukaeto: declaring them, yes.
<sukaeto>
given that I don't really think about types much beyond "this thing should be a number" or "this method specializes over these classes", I could probably agree with you there :-)
<pjb>
Checking them, most of the time. The programmer will too often be too specific in his type specifications.
<sukaeto>
don't really think about types much *when programming in Lisp*, to be clear
<pjb>
thankfully.
krid has quit [Ping timeout: 265 seconds]
<pjb>
CL doesn't force you to think much about them.
<sukaeto>
well, CL's strengths lie along other dimensions
<whartung>
I honestly use types in two places: one, when reading code just so I know what I’m looking at ,and 2, when refactoring to have the compiler let me know when I break things.
<aeth>
Ime, it really depends on what you do. For functions used by macros, types are incredibly useless. You want to basically be able to handle anything that is thrown at you in a given variable. If you're working with numbers, arrays of numbers, structs of arrays of numbers, etc., you absolutely wind up writing the 100th defun-with-more-convenient-type-declarations macro at some point.
ralt has joined #lisp
<aeth>
(By incredibly useless in macros, I mean type declarations or even check-types. What you'd probably do at most is a typecase)
<sukaeto>
I can hot patch my running system in Lisp. I can just call anything that's been loaded at the REPL. When I hit bugs in development, the debugger just pops up and I get an interactive stack trace. Same with the profiler, it's just right there. I don't have to run the code with special flags to get it to dump some file that then has to be interpreted by another tool to give me output with the stuff I care
<sukaeto>
about buried amongst stuff I don't care about.
<sukaeto>
none of these things are true for ADa
<sukaeto>
Ada, even
<TMA>
thinking about types helps me even in CL; but to be frank those are not the CL-types, these are more domain specific. (length-in-meters instead of number, sequence-of-issue-ids instead of list or list-of-integers)
Aruseus has joined #lisp
<sukaeto>
TMA: and Ada gives you the power to codify those things in your type declarations
<pjb>
But when you write your code, you should distinguish parts that are very sepcific to meters and issue-ids, and the rest of the algorithms that work on reals or list of integers (note, numbers are not lengths! Only real are lengths! you got your typing wrong (this is why you should let the compiler do it!)).
<aeth>
sukaeto: Ironically, C++, which everyone loves to hate, is probably one of the best of those rigid (more than just merely "static" imo) languages as far as runtime debugging goes. I mean, yes, you do get a vommit of error messages where only the first one is relevant if it's at compile, but if you want to look at something semi-interactively, you can just define << for it and print it.
<pjb>
What I'm saying is that 90% of your code will be generic code dealing with lists of whatever or lists of integers, or reals.
<aeth>
Assuming, of course, that you can recompile it fast enough to make it almost interactive!
wooden has joined #lisp
wooden has quit [Changing host]
wooden has joined #lisp
<aeth>
pjb: It *really* depends on what you're doing
<aeth>
pjb: If your "reals" are best modeled by floats, suddenly you probably are thinking about types and declarations, at least a bit. And if you're just handling text, you can probably just work with streams and not really worry about types that much because FORMAT is usually smart enough with ~A
kajo has quit [Ping timeout: 276 seconds]
<TMA>
sukaeto: as does haskell. haskellers are proud in that they manage to squeeze a lot into the type system
<sukaeto>
TMA: yeah, Haskell is another language with a really rich type system
femi has quit [Ping timeout: 240 seconds]
<sukaeto>
I don't have a ton of experience with it, though
<aeth>
The reason I'm using CL instead of a more ideologically pure language is precisely because CL the language is less ideological than e.g. pjb is. If your code is almost all generic, good. It works. If your code isn't and it's almost all single-float/double-float, good. It also still works. It's incredibly multiparadigm because it doesn't force you into a way of thinking that's bad for certain domains.
femi has joined #lisp
kajo has joined #lisp
<aeth>
Of course, on Ada, the point is specifically to not give you that freedom, because if your numerical code is for rockets, you don't want the rocket to explode if the units are wrong.
<sukaeto>
well, you've got plenty of freedom in Ada. You just have to be judicious about telling the compiler when you want to take liberties and when you want it to complain at you.
<aeth>
The SLIME debugger can't currently pause reality if a bug happens.
<sukaeto>
people will always ask on #ada things like "why do I get an error when I try to use type X instead of type Y" (where X and Y are two different integer types or some such)
<sukaeto>
to which the answer is "Why did you define them that way if it wasn't what you wanted, silly?"
<pjb>
aeth: you keep getting it wrong. Your reals are not modeled by floats. When you say length it means order. < works only on real, not on complex. Writing your code for float is wrong, because there are also ratios! 3/4 is a perfectly good length.
<pjb>
as is 3 which is an integer.
<aeth>
pjb: Writing your code just for floating-point numbers is wrong, but it's wrong in a very well-studied, well-known way with algorithms written by people smarter than I that you can implement to work with them.
<aeth>
The main problem is if you force floats on everyone, e.g. JavaScript.
Codaraxis has quit [Read error: Connection reset by peer]
<pjb>
ok, but you're not writing lisp code then. You might be transfering C or fortran code to lisp.
Codaraxis has joined #lisp
<aeth>
pjb: And TAGBDOY will help you manually translate those FORTRAN programs into Lisp, too.
<pjb>
Yep.
<aeth>
That's something that a more ideologically pure language would absolutely not give you
<aeth>
pjb: In practice, though, LOOP with :of-type is what I tend to use when I'm translating numerical stuff into CL, though. Gives you pretty much everything you need.
<aeth>
(and it looks pretty close to the pseudocode (or not-CL) source, too)
scymtym has joined #lisp
<aeth>
pjb: I hope one day someone writes BLAS from scratch with CL (particularly SBCL's optimizations) in mind. Those Fortran to CL translators produce terrible numerical SBCL if you disassemble it (not surprising because they probably predate SBCL and maybe even CMUCL). Handwritten CL can do much better.
<aeth>
And similarly, I hope that (almost) no one directly uses that library since it would be so incredibly non-idiomatic.
mstdnuser[m] has quit [Remote host closed the connection]
no-defun-allowed has quit [Read error: Connection reset by peer]
Jachy has quit [Read error: Connection reset by peer]
keep-learning[m] has quit [Read error: Connection reset by peer]
v88m has quit [Read error: Connection reset by peer]
djeis[m] has quit [Remote host closed the connection]
sciamano has quit [Read error: Connection reset by peer]
malaclyps[m] has quit [Write error: Connection reset by peer]
Godel[m] has quit [Write error: Connection reset by peer]
fynzh[m] has quit [Write error: Connection reset by peer]
dtw has quit [Write error: Connection reset by peer]
nonlinear[m] has quit [Read error: Connection reset by peer]
munksgaard[m] has quit [Write error: Connection reset by peer]
eriix[m] has quit [Read error: Connection reset by peer]
liambrown has quit [Read error: Connection reset by peer]
hiq[m] has quit [Write error: Connection reset by peer]
shaakyamuni[m] has quit [Remote host closed the connection]
iarebatman has quit [Write error: Connection reset by peer]
Gnuxie[m] has quit [Write error: Connection reset by peer]
katco has quit [Write error: Connection reset by peer]
pnp has joined #lisp
akanouras has quit [Read error: Connection reset by peer]
LdBeth has quit [Remote host closed the connection]
kamog has joined #lisp
j-r has joined #lisp
j-r has joined #lisp
j-r has quit [Changing host]
<aeth>
pjb: Imo, though, for some tasks you have two options: (1) write Fortran or C in your language; or, (2) write FFI code to call into optimized Fortran/C/C++ libraries. And I'm glad CL is in the category that permits option 1 because native libraries with foreign dependencies are often hard to work with and because even just writing C-in-CL looks more idiomatic than wrapping C in CL.
<pjb>
Granted, option 1 is better than FFI.
<pjb>
But if you can solve your problem with symbolic algorithms, it probably be be better than with numeric algorithms. Anyways, for numeric, you won't beat cuda or tesla processors.
pnp has quit [Ping timeout: 260 seconds]
<aeth>
Cuda is for embarrassingly parallel afaik. And even there, sometimes memory latency going CPU to GPU and back will make it slower, again afaik.
<aeth>
As for symbolic being better, there are two issues with that that I know of. (1) Some things can only be solved numerically (in particular, some differential equations). (2) Even when a symbolic solution can be done, sometimes it's too slow.
<aeth>
As far as software bloat/expansion goes, eventually every symbolic system evolves to support numerical as well, for those reasons, and possibly some more. I guess Lisp in a sense can be seen as a case of this.
Agafnd has joined #lisp
bitmapper has joined #lisp
akanouras has joined #lisp
Bike has joined #lisp
madand has joined #lisp
shka_ has quit [Ping timeout: 265 seconds]
Lord_of_Life_ has joined #lisp
Achylles has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
jmercouris has joined #lisp
jmercouris has quit [Remote host closed the connection]
<ralt>
SIMD is what you need for embarassingly-parallel-on-CPU, no?
<whartung>
how are common block done in CL?
krid has joined #lisp
<aeth>
ralt: Ideally, something like BLAS-on-CL would be written in portable CL as a fallback for architectures/implementations not supported, and use SIMD asm where possible, like SBCL-on-x86-64. So it wouldn't be a simple task.
UgurKap has quit [Quit: Leaving]
retropikzel has quit [Remote host closed the connection]
<aeth>
And for the GPU, we have SPIR-V now.
Agafnd has quit [Ping timeout: 240 seconds]
dtw has joined #lisp
LdBeth has joined #lisp
Jachy has joined #lisp
iarebatman has joined #lisp
katco has joined #lisp
eriix[m] has joined #lisp
djeis[m] has joined #lisp
sciamano has joined #lisp
liambrown has joined #lisp
no-defun-allowed has joined #lisp
nonlinear[m] has joined #lisp
munksgaard[m] has joined #lisp
malaclyps[m] has joined #lisp
keep-learning[m] has joined #lisp
Godel[m] has joined #lisp
hiq[m] has joined #lisp
Gnuxie[m] has joined #lisp
fynzh[m] has joined #lisp
shaakyamuni[m] has joined #lisp
mstdnuser[m] has joined #lisp
v88m has joined #lisp
gxt has joined #lisp
Achylles has quit [Quit: Leaving]
Denommus has joined #lisp
mindCrime_ has quit [Ping timeout: 245 seconds]
gareppa has quit [Quit: Leaving]
Lycurgus has joined #lisp
v88m has quit [Read error: Connection reset by peer]
LiamH has left #lisp [#lisp]
Denommus has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
alexanderbarbosa has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
<mgsk>
Any package recommendations for a short lambda reader macro?
nanoz has quit [Ping timeout: 246 seconds]
paul0 has quit [Read error: Connection reset by peer]
_paul0 has joined #lisp
alexanderbarbosa has joined #lisp
<aeth>
mgsk: What are you looking for? For me, I just use an emacs thing (minor mode?) that turns "lambda" when typed into the Greek letter. As long as you don't have a multi-line lambda list (arguments list) it won't mess with indentation in the final source code. And if it is that complicated that you have multiple lines of arguments, it probably shouldn't be a lambda.
<aeth>
(If it is a multi-line lambda list then the subsequent arguments past the first line will be aligned for one character of the Greek letter when they should be aligned for 6, so that's where the illusion breaks down, by messing up the indentation)
TMA has quit [Ping timeout: 268 seconds]
<aeth>
It's called pretty-lambdada
<aeth>
It will work correctly for single-line lambdas (as long as you don't have a hard line length limit) and multi-line lambdas with single-line lambda lists like (lambda (x y z)\n...)
<aeth>
I think there's another emacs minor-mode that is more general (i.e. doing more substitutions, not just lambda), but of course that might have more edge cases that will mess up formatting. lambda just has that one (very rare) edge case.
<mgsk>
aeth: i know you know what i'm asking
<asdf_asdf_asdf>
@mgsk; retype question, please.
<aeth>
Well, that's "short lambda" in the literal sense of shortening "lambda". There are other possible short lambdas, like (lambda (x y z) ...) into #[x y z : ...] or something, or maybe (lambda (x) ...) into #[...] where x is now an implicit _
<aeth>
Of course, substituting "lambda" for "λ" (in several ways, including in the source code or locally in Emacs) gets you most of the way in terms of conciseness, especially once you take into account the extra # most reader macros will add.
<Oladon_work>
Huh, that substitution is a nice idea.
<aeth>
Especially since lambdas are almost always one-liners, or with a newline after the lambda-list (not in the middle of it) so it doesn't affect formatting
<mgsk>
I suppose it's one of those things that seems nice in theory, and when you have a tonne of throw-away lambdas scattered around. But in practice, it doesn't save you much.
<aeth>
and really imo it should be #λ((+ _ _)) because most lambda bodies aren't going to be just one expression (usually you can just use #'+ directly if you're in that situation)
<Oladon_work>
moldybits: And it's not like you're substituting some random character (*coughRubycough*); λ _is_ Lambda.
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
<moldybits>
i wish more symbols were used in code
Oladon_work has quit [Ping timeout: 260 seconds]
<aeth>
Well, that's more #apl than #lisp
<aeth>
Some Lispers don't like the few symbols that are used, like +, *, /, and -, but those are probably justifiable because they're more familiar than the letters and they're easy to type.
<aeth>
s/than the letters/than the words/
<moldybits>
really?
<moldybits>
what do they think is wrong with symbols
<aeth>
iirc, early Lisp didn't really use any symbols in the identifier names, which is why we have string= for case-sensitive string equality and string-equal for case-insensitive. Backwards compatibility! The old way was case-insensitive and its name remains
<aeth>
and then you have Scheme which sort of embraces symbols more, which is how you get ? and !
Codaraxis has quit [Read error: Connection reset by peer]
Codaraxis has joined #lisp
<aeth>
I'm pretty sure some historic Lisps didn't use +, -, *, and / iirc
<aeth>
I'm not sure if it was PLUS or ADD
Ricchi has joined #lisp
<Bike>
lisp 1.5 has plus.
<Bike>
but add1 for 1+... okay then
<aeth>
I'm surprised it wasn't INC and DEC, since they probably already had INCF and DECF at that point
<Bike>
nope.
<pjb>
mgsk: why do you want a package? (set-macro-character #\λ (lambda (s c) (declare (ignore s)) `(cl:lambda ,(read s) ,(read s)))) (mapcar λ (x) (* 2 x) '(1 2 3)) #| --> (2 4 6) |#
<Bike>
there's a (SETQ V (ADD1 V)) in here, even
<Bike>
no setf in lisp 1.5.
<pjb>
aeth: or pred succ; but that was because Pascal came only in 1969…
<Bike>
i mean, there are no macros at all, i don't think
<aeth>
If LISP 1.5 has no macros is it even a Lisp?
<aeth>
(Yes, that's a joke based on all of those "What is Lisp?" debates that the Internet loves to have.)