Ralf Hemmecke <[EMAIL PROTECTED]> writes:
> > Do you mean that passing operations to the categories would be a feasible
> > approach? I.e., being allowed to say something like
> > Monoid(m:(%,%)->%): Category == with
> > square: % -> %
> > add
> > square a == m(a,a)
>
> Martin, stop writing in SPAD. I thought you also agreed that new things have
> to
> be written in Aldor. And there you would to write the default implementation
> with "default" and not with "add". Otherwise there would be an anonymous
> domain
> "add {square ...}" inside a with clause.
Well, I'm not yet fluent in Aldor. I'm waiting for your talk at the Workshop...
> > Of course, one would have to rethink this several times, the suggested
> > notation
> > here is clearly not yet perfect. One might object that this notation
> > violates
> > the possibility of creating anonymous categories, but I suspect that this
> > wouldn't make sense anyway.
>
> Yes, one has to rethink that quite a lot. The problem with your suggestion is
> the following
>
> 1) You cannot simply ask
>
> Integer has Monoid
>
> because you have to give a parameter.
I wouldn't want to ask "Integer has Monoid", since this doesn't make any sense
to me. I'd like to ask "Integer has Monoid(Integer, *)" or
"Integer has Monoid(*)"
> 2) If you say something like
>
> MyMonoid(T: Type, m: (T, T) -> T): Category == with {
> square: T-> T;
> default {square(t: T): T == m(t, t)}
> }
>
> then it is perfect Aldor.
> Then, however, you ask
>
> Integer has MyMonoid(Integer, *)
>
> and it will return true only if you have said
>
> extend Integer: MyMonoid(Integer, *) == add;
>
> somewhere.
> (But probably you had something else in mind.)
So, in fact in Aldor we can solve the "problem"?
Monoid(T: Type, m: (T, T) -> T): Category == with {
square: T-> T;
default {square(t: T): T == m(t, t)}
}
Word: BasicType == add {
add {*(a: %, b: %):% == concat(a,b) }
extend Word: Monoid(Word, *) == add;
??? If this is the case, I know what I want!!!
> Although I don't really like that an AbelianMonoid is not a Monoid, and
> although I think that renaming during inheritance would be nearer to
> mathematics... after all the discussion here, I somehow think that the design
> in Axiom is not really bad. The reason is that I have not seen a clear case
> where renaming would be over-advantageous.
yes
> I'd like to say
>
> Integer has Monoid
>
> instead of
>
> Integer has Monoid(*, 1);
> Integer has Monoid(+, 0);
NOOO!
> Simply think of a category Foo with hundreds of exported function, would you
> like to write
>
> Dom has Foo(f1, f2, ..., f100)
no, but wait a moment: It is obvious to me that I don't want to have all
exported functions as parameters. Only certain "defining" functions, like:
Integer has Monoid(*, 1);
Integer has Ring(+, *, 1);
Can you think of an example where more than, say 5, parameters would be
desirable?
Martin
_______________________________________________
Axiom-developer mailing list
[email protected]
http://lists.nongnu.org/mailman/listinfo/axiom-developer
