3 ms·

I think the non-object-oriented philosophy in Arc is so deeply ingrained it'll be hard to change without starting over. But really the question is whether any

by lacker 18y ago

I think the non-object-oriented philosophy in Arc is so deeply ingrained it'll be hard to change without starting over. But really the question is whether any object-oriented philosophy is necessary. My take is, let's say you write a function in Arc that operates on lists. It's recursive using car and cdr. Now ideally, you could also run that function on anything else that is list-like. But in Arc, car only works on lists. Maybe you can fix this without making everything an object, that'd be fine by me. In practice modern programming languages are tending towards a default dynamic-array-like datastructure that supports both random access and amortized-O(1) append. This is so convenient for hacking programs together, I can't believe the 100-year language won't have this as a very basic part of the system. But Arc doesn't do this. In news.arc you have a very Lisp-list-centric way of programming. But I think for many problems less restrictive datatypes are the most convenient. Hash tables and dynamic arrays need to be just as easy as Lisp lists. This is the Python way, the Ruby way, and I think the way of the 100-year language. But I don't know how to make iteration on any of these look equivalent without making the core of the language be more object oriented.

jwilliams 18y ago
To be honest, I don't understand your point fully. Are you able to expand on your points a bit more? Are you saying you believe you need some OO elements of polymorphism on car and cdr? Not sure you need these - there are loop constructs that let for "for each do X". With macros you could make this do almost any type of iteration. I might be missing your point though, as I'm not sure how Objects help in this scenario. Why can't you iterate on hash tables in Arc? ...or another related question, what do you mean by iterate in the context of a hash table? Similarly... Isn't a dynamic array just a list? Or it is specifically the performance of this that you're concerned about - surely this is just an optimisation step rather than a hole in the language?... Either way, I'll agree that they're convenient for hacking programs together :)
- lacker 18y ago
  Your point is that it is possible to iterate over any sort of data structure. This is true. The problem is that you have to use different sorts of iteration for different data structures. Yes, it is possible to use macros to write code that works over both lists and other iterable things. But that isn't the most natural usage; Arc encourages you to write recursive functions using car and cdr. And if you have a lot of code using car and cdr, you have to rewrite that if you want to convert data from lists to another data type. Objects could possibly give you a polymorphic car and cdr, similar to Clojure, so you just don't have to worry about "what sort of iterable object" a function is going to work on. As far as dynamic arrays versus lists, you can consider it "just an optimization step" as long as you can swap in a dynamic array for a list later on without changing your code. But that isn't possible in Arc because you will have to replace car/cdr with other iteration constructs. I think it's a little unfair to consider the difference between Lisp lists and dynamic arrays just a matter of optimization - there are plenty of things that you can't even play around with when random access is O(n). E.g. randomly shuffling the lines of a large text file.
silentbicycle 18y ago
Lua's tables seem like a pretty elegant solution to the dynamic-array-like datastructure, and they're also usable as a relational map. Also, Lua is not object-oriented, but it's trivial to build on the core semantics to make it OO, when doing so would be a practical approach to the problem at hand. (As far as the iteration concern, everything in Lua besides unboxed primitives is a (pseudo-hash) table.) > But I don't know how to make iteration on any of these look equivalent without making the core of the language be more object oriented. Haskell's typeclasses would work, as well, and in practice seem to generalize far better. Instead of restricting the iterator used to a specific type, restrict it to any type that supports the interface of iteration. (It's kind of like duck-typing that is verified at compile-time.) It sounds like Clojure has a similar mechanism.
jimbokun 18y ago
Clojure seems to tackle this problem by having different "iterable" data types (lists, hashes, vectors), but having them implement a common interface that allows many functions to operate on all of them.
- lacker 18y ago
  I think Clojure does this well; this solution pretty much requires that every collection is a full-fledged object, though, which is why I can't see it going into Arc. Maybe you could special-case lists and hash tables.

by lacker 18y ago

jwilliams 18y ago

To be honest, I don't understand your point fully. Are you able to expand on your points a bit more? Are you saying you believe you need some OO elements of polymorphism on car and cdr? Not sure you need these - there are loop constructs that let for "for each do X". With macros you could make this do almost any type of iteration. I might be missing your point though, as I'm not sure how Objects help in this scenario. Why can't you iterate on hash tables in Arc? ...or another related question, what do you mean by iterate in the context of a hash table? Similarly... Isn't a dynamic array just a list? Or it is specifically the performance of this that you're concerned about - surely this is just an optimisation step rather than a hole in the language?... Either way, I'll agree that they're convenient for hacking programs together :)

lacker 18y ago
Your point is that it is possible to iterate over any sort of data structure. This is true. The problem is that you have to use different sorts of iteration for different data structures. Yes, it is possible to use macros to write code that works over both lists and other iterable things. But that isn't the most natural usage; Arc encourages you to write recursive functions using car and cdr. And if you have a lot of code using car and cdr, you have to rewrite that if you want to convert data from lists to another data type. Objects could possibly give you a polymorphic car and cdr, similar to Clojure, so you just don't have to worry about "what sort of iterable object" a function is going to work on. As far as dynamic arrays versus lists, you can consider it "just an optimization step" as long as you can swap in a dynamic array for a list later on without changing your code. But that isn't possible in Arc because you will have to replace car/cdr with other iteration constructs. I think it's a little unfair to consider the difference between Lisp lists and dynamic arrays just a matter of optimization - there are plenty of things that you can't even play around with when random access is O(n). E.g. randomly shuffling the lines of a large text file.

silentbicycle 18y ago

Lua's tables seem like a pretty elegant solution to the dynamic-array-like datastructure, and they're also usable as a relational map. Also, Lua is not object-oriented, but it's trivial to build on the core semantics to make it OO, when doing so would be a practical approach to the problem at hand. (As far as the iteration concern, everything in Lua besides unboxed primitives is a (pseudo-hash) table.) > But I don't know how to make iteration on any of these look equivalent without making the core of the language be more object oriented. Haskell's typeclasses would work, as well, and in practice seem to generalize far better. Instead of restricting the iterator used to a specific type, restrict it to any type that supports the interface of iteration. (It's kind of like duck-typing that is verified at compile-time.) It sounds like Clojure has a similar mechanism.

jimbokun 18y ago

Clojure seems to tackle this problem by having different "iterable" data types (lists, hashes, vectors), but having them implement a common interface that allows many functions to operate on all of them.

lacker 18y ago
I think Clojure does this well; this solution pretty much requires that every collection is a full-fledged object, though, which is why I can't see it going into Arc. Maybe you could special-case lists and hash tables.