I am rethinking the expression of the types of literals in the Cat language.
Previously I had separated the notion of primitive types and
functions. Now I am thinking that all literals should be also
functions which yield themselves, like they are in Joy.
I've posted more about the rationale at
http://www.artima.com/weblogs/viewpost.jsp?thread=182140
Does anyone see any problem with expressing primitives types as
functions which generate themselves?
Christopher Diggins
--- Christopher Diggins <cdiggins@...> wrote:
> Now I am thinking that all literals should be alsoIs that definition recursive?
> functions which yield themselves
"...all literals should be functions which yield functions, which yield
functions, which yield functions, which..."
I think that things like numbers in Joy are a union of types, sometimes a
primitive value, sometimes a function which pushes a primitive value on
to the stack, depending on context. I think I probably understand what
you mean, but what about the following program...
42 [42] cons
...now does that final list have two elements of the same type
(presumably functions that push a number on the stack), or does it have
elements of two different types, a number and a function which pushes a
number on the stack.
I think for a statically typed lanugage, you might want to think
about differentiating between the type of lists and quotations. So that
you'd could have either...
42 42 unitlist cons [1 +] map
...or...
42 stackify 42 stackify compose i
...but mixing wouldn't be allowed.
Greg Buchholz
__________________________________________________
Do You Yahoo!?
Tired of spam? Yahoo! Mail has the best spam protection around
http://mail.yahoo.com
Greg Buchholz scripsit:
> I think that things like numbers in Joy are a union of types, sometimes aOr to put it another way:
> primitive value, sometimes a function which pushes a primitive value on
> to the stack, depending on context.
Every object in Joy is invokable.
So 42 can be added to 23 (but not to "x", because "x" does not understand
addition), but all three can be invoked. Invocation is distributed over
the members of a list, but in all other cases causes the stack to grow
by one element. (Note that "i" is not primitive invocation.)
--
And it was said that ever after, if any John Cowan
man looked in that Stone, unless he had a cowan@...
great strength of will to turn it to other http://ccil.org/~cowan
purpose, he saw only two aged hands withering
in flame. --"The Pyre of Denethor"
> > Now I am thinking that all literals should be alsoYes.
> > functions which yield themselves
>
> Is that definition recursive?
> "...all literals should be functions which yield functions, which yieldBut the question remains: how do you express that formally in a static
> functions, which yield functions, which..."
>
> I think that things like numbers in Joy are a union of types, sometimes a
> primitive value, sometimes a function which pushes a primitive value on
> to the stack, depending on context.
type system?
> I think I probably understand whatThis was precisely the question I was flip-flopping between. Both
> you mean, but what about the following program...
>
> 42 [42] cons
>
> ...now does that final list have two elements of the same type
> (presumably functions that push a number on the stack), or does it have
> elements of two different types, a number and a function which pushes a
> number on the stack.
answers seem valid to me.
> I think for a statically typed lanugage, you might want to thinkThat is definitely a valid approach and is in fact the one that I use
> about differentiating between the type of lists and quotations. So that
> you'd could have either...
>
> 42 42 unitlist cons [1 +] map
>
> ...or...
>
> 42 stackify 42 stackify compose i
>
> ...but mixing wouldn't be allowed.
in the current implementation of Cat (which I hope to release this
weekend if all goes well). The challenge of that approach is that it
is more verbose. I find myself comparing Cat code to Joy code, and
being jealous of the more powerful expressiveness of Joy.
However i still find myself asking is there any substantial reason not
to have ints as being self referential types which can be used
whereever a function is required?
Perhaps one convincing argument is that by separating primitive values
from functions yielding primitve values is that the type system can
more easily catch programming mistakes.
I am still straddling the fence on this issue.
-Christopher