initlist.as and axextend.as

[Ralf Hemmecke]

Dear Peter,

Last night I was wondering why you haven't put "Segment" into
baselist.lsp, but rather SegmentBinding.

Am I right, that the baselist.lsp (or rather now my initlist.as) has
only slightly to do with axlit.as and axextend.as.

Being more precise (and maybe oversimplifying) the compilation of
libaxiom.al could *theroretically* be done in the following way.

1) compute a compilation order of axiom types by grouping together in
cliques axiom types that depend on each other. That should give a list
of cliques that can (nearly) be compiled one after the other.

2) Determine an the smallest index in that list where axlit.as and
axextend.as come into the compilation order.

3) Compile the cliques and axlit.as and axextend.as in the above order
to get libaxiom.al.

Saying that, I have the suspicion one could completely do without
initlist.as if the aldor compiler were stable enough to handle big
files/cliques.

The only reason for the existance of initlist.as I can think of is that
it is impossible to determine an index in 2) and that this would mean
there would have to be a really big initial clique that also includes
axlit.as and axextend.as.
But then there might be problems since a domain definition and an
"extend" of it live in the same file and maybe a domain that needs the
"extend" appears in that file before the compiler has seen the extend.

So my guess is that initlist.as is used to make sure an index in 2) can
be found. Am I right?

If that is true, then I can imagine why "Segment" need not be in
initlist.as.

I hope my thoughts are not too confused/confusing...

Ralf


------------------------------------------------------------------
-- Some initial stuff to get the compiler understand some identifiers.
-- These declarations are wrong, but all we need is to make the
-- identifiers known for the export's that follow.
Type: with;
Tuple: with;
(->): with;

-- The following list contains some basic domains and categories from
-- the Axiom algebra library.
-- Declarations are sufficient.
export Boolean:                    with;
export Field:                      with;
export InputForm:                  with;
export IntegralDomain:             with;
export NonNegativeInteger:         with;
export OpenMathDevice:             with;
export OutputForm:                 with;
export PositiveInteger:            with;
export SetCategory:                with;
export SingleInteger:              with;
export Ring:                       with;
export String:                     with;

export DoubleFloat:                SetCategory;
export Float:                      SetCategory;
export Symbol:                     SetCategory;

export Integer:                    IntegralDomain;

export Equation:                   (T: Type)           -> with;
export List:                       (T: Type)           -> with;
export SegmentBinding:             (T: Type)           -> with;
export UniversalSegment:           (T: Type)           -> with;
export Vector:                     (T: Type)           -> with;

export Factored:                   (T: IntegralDomain) -> IntegralDomain;
export Fraction:                   (T: IntegralDomain) -> Field;
export Matrix:                     (T: Ring)           -> with;
export SparseUnivariatePolynomial: (T: Ring)           -> IntegralDomain;

_______________________________________________
Aldor-l mailing list
Aldor-l@...
http://aldor.org/mailman/listinfo/aldor-l_aldor.org