Robert Maas, see http://tinyurl.com/uh3t
wrote:
> From: Jon Harrop <use...@[EMAIL PROTECTED]
>
>> Mathematica lacks static type checking
>
> So there's no way to assert a fact about some data value somewhere
> in your code and have the compiler warn you if that fact can't be
> guaranteed based on what it knew earlier in the same code?
You only have run-time assertions in Mathematica.
>> Callcc is a lot more like forking than threads.
>
> I've been under the impression that forking was a special case of
> multiple threads, where a single thread spawns two continuation
> threads, taking opposite paths from some branch point, and the
> original thread then waits for both to complete before combining
> their results and proceeding as a single thread.
The difference is that with forked threads the OS can lazily copy the
shared
heap as it is mutated. So if you create a big immutable data structure and
then fork two threads that use it, you get sharing of the data structure
for free. If you use vanilla threads then you must either work with
explicit sharing or do a deep copy of the data structure.
>> Arrays are Mathematica's primitive data type and it calls them
>> (confusingly) "List"s.
>
> Well they *are* lists i.e. vectors, they just aren't linked lists,
> they're contiguous lists, which have some advantages and some
> disadvantages compared with linked lists. Can elements of
> Mathematica's contiguous lists be contiguous lists (arrays)
> themselves?
Yes, that's exactly how it works.
>> But Mathematica's equivalent of cons cells are arrays of objects,
>> so they can store an arbitrary number of elements contiguously.
>> Speaking of which, why doesn't Lisp do that?
>
> No, you're wrong. Mathematica doesn't have an exact equivalent of
> CONS cells, i.e. ordered pairs of a distinct type different from
> any multi-pointer object. Lisp has the equivalent of Mathematica's
> "lists", namely one-dimensional general arrays. Lisp has *both*
> kinds of objects, one-dimensional general arrays which can hold any
> number of pointers, and CONS cells which are specialized to have
> exactly two pointers and to be more efficient than a two-element
> general array. CONS cells are *not* a sub-type of general arrays,
> whereas a list of two elements in Mathematica, as you cite, *is* a
> sub-type of multi-element lists.
Ok, yes.
> Now it would be possible in Lisp to use two-element general arrays
> as if CONS cells: Have a new version of READ that generated them
> where CONS cells would normally be generated, a new version of
> PRINT that printed as if they were CONS cells, and a new version of
> EVAL that traversed them just as the regular EVAL traversed regular
> CONS cells. That would be a cute hack, even if of no practical
> value.
Assuming that is possible, why didn't scheme do it part of "cutting down"
Lisp?
--
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/products/?u
|
