=pod
=encoding utf8
=head1 NAME
Language::MuldisD::Hierarchical -
Terse Muldis D dialect for daily work
=head1 VERSION
This document is Language::MuldisD::Hierarchical version 0.0.2.
=head1 PREFACE
This document is part of the Muldis D language specification, whose root
document is L<Language::MuldisD>; you should read that root document
before you read this one, which provides subservient details.
=head1 DESCRIPTION
The fundamental way to write Muldis D code is to compose appropriately
typed tuple and/or relation valued expressions which are then stored in the
Muldis D system catalog relvars, whereupon it becomes invokable. If you
had Muldis D code that was generating other Muldis D code at runtime, such
as you do with string-eval in Perl or you do with "prepared statements" in
SQL, then this process is what that first Muldis D code is actually doing.
If you were taking the bare-bones Muldis D syntax defined in either
L<Language::MuldisD::Grammar> or L<Language::MuldisD::PerlHosted>, along
with the system-built-in data types and routines defined in
L<Language::MuldisD::Core>, and using just those instructions to write your
own Muldis D code, you would essentially be working to the metal, and your
code would be very verbose by typical programming conventions. For now
lets call this writing in the I<Relational Muldis D> dialect, since the
code is composed entirely of tuple|relation definitions.
This document specifies another Muldis D dialect, which for now we will
call the I<Hierarchical Muldis D> dialect. Moreover, although its
principles could be generalized, for now the details of this document are
specific to the dialect's use in Muldis D as hosted in either Perl 5 or
Perl 6, such as I<PerlHosted> describes. So the relational Perl-hosted
dialect will be referred to herein as I<PHMD-R>, and the hierarchical
Perl-hosted dialect will be I<PHMD-H>.
This document is very much an early draft, and for not just contains a bit
of brainstorming in point form.
=head1 HIERARCHICAL MULDIS D DIALECT
PHMD-H code, like PHMD-R code, is fundamentally expressed as a tree of Perl
Array that also comprises some Perl Hash; the tree root is a Perl Array.
Literals of system-defined core scalar types (such as numbers and strings)
are expressed in the same way for both PHMD-H and PHMD-R, as simple Perl
Seq|Array values of 2-4 elements; see I<PerlHosted> for details. This then
retains all the meta-data necessary to unambiguously interpret the scalar
values where Perl may be more weakly typed itself.
A PHMD-H expression tree is generally expressed as an actual tree of node
definitions, and those nodes don't need to be named; contrast with PHMD-R
where the nodes are defined in a flat list and are all named. But PHMD-H
still supports disassembly into multiple named sub-trees, such as when part
of an expression is intended to be used multiple times, as per a
generalization of a named item in a SQL "WITH" clause. Having actual
N-depth expression trees makes the Muldis D code much more strongly
resemble expression trees in most typical high-level languages, as well as
how humans typically write their math and logic outside of computers.
A PHMD-H expression node does not include deadweight node attributes like
in PHMD-R, because it isn't restricted to making every node of the same
complete tuple data type. This leads to a drastic reduction in code size.
PHMD-H has a much larger grammar than PHMD-R does. Speaking in analogy,
its alphabet has 100 characters rather than 10, so you can express all the
possible ideas using a smaller number of characters. Speaking not in
analogy, PHMD-H has orders of magnitude more PHMD node types than PHMD-R
does; so for example, it has separate C<function|procedure> node types for
declaring a function|procedure, rather than a generic C<Tuple> node type
being used for that; or each kind of value expression (eg, a literal vs
a parameter use vs a function call) each has a different short PHMD node
for it, rather than 1 kind subsuming them all.
PHMD-H permits abbreviations of name-chains for invoking types or routines
et al when said entities are system-defined; generally speaking, any
C<sys.Core.> prefix can be omitted where applicable; often so can the
package name as well. This does not apply to user-defined entities;
however it is less needed there since there are several levels of
localizing top-level namespaces for user-defined entities already, such as
C<pkg> or C<inn>. The reason for this selective applicability is because
PHMD-H and PHMD-R code must be unambiguously translatable to the other
dialect in isolation from any knowledge of entities other than built-ins,
such as outside of the DBMS in which they would compile or execute.
PHMD-H provides a bunch of alternate spellings for various system-defined
operators, as aliases; in particular, many symbolic-character aliases. So
for example, C<=> is provided as an alias for C<is_identical>, and C<< < >>
an alias for C<is_before>, and C<*> as an alias for C<Int.product>, and
so-forth.
PHMD-H provides positional-argument syntax aliases for system-defined
routines, so they can be invoked without argument names. This does not
apply to user-defined routines as there is no provision in PHMD-R to
declare an order for user-defined routine parameters (save for faking it by
using character string representations of integers for their names).
I<Other details to come, stay tuned!>
=head1 SEE ALSO
Go to L<Language::MuldisD> for the majority of distribution-internal
references, and L<Language::MuldisD::SeeAlso> for the majority of
distribution-external references.
=head1 AUTHOR
Darren Duncan (C<perl@DarrenDuncan.net>)
=head1 LICENSE AND COPYRIGHT
This file is part of the formal specification of the Muldis D language.
Muldis D is Copyright © 2002-2008, Darren Duncan.
See the LICENSE AND COPYRIGHT of L<Language::MuldisD> for details.
=head1 ACKNOWLEDGEMENTS
The ACKNOWLEDGEMENTS in L<Language::MuldisD> apply to this file too.
=cut