This note is from Darren Duncan.

Greetings,

I am pleased to announce that version 0.129.1 of the specification of the Muldis D language, for object-relational databases, has been released on CPAN.

This release marks a milestone for Muldis D in that the /language specification/ is now fundamentally complete, with all of the important details now formally specified. Prior to this milestone, some important details were missing, and so it would have been difficult to demonstrate what actual Muldis D code looks like, whereas now it is feasible to write and understand code for any given task. Some code examples follow.

However, no Muldis D implementation actually exists yet, so you can't actually /run/ any code. The next Muldis D milestone will be the creation of a substantially complete self-contained reference implementation, which I expect to have done sometime in the next few months. Until that next milestone is reached, the Muldis D language spec is officially of pre-alpha quality; as of that milestone, it will officially be alpha quality. Here is the specification.

For those of you who are not familiar, Muldis D is an industrial-strength computationally complete high-level programming language with fully integrated database functionality; you can use it to define, query, and update "object-relational" databases. The language's paradigm is a mixture of declarative, homoiconic, functional, imperative, and object-oriented.

The syntax of Muldis D is like that of a general purpose programming language, with Perl 6 being a strong influence (and multiple other languages contributing too), but it also greatly resembles SQL as well, and so shouldn't be too difficult to learn.

For all intents and purposes you can consider Muldis D to be what SQL should have been; it can express anything useful that SQL can, but in a much improved manner. So it should be easier to write more expressive and less kludgy code in Muldis D than in SQL. The simple code comparisons further below should demonstrate this.

In order to get a more thorough introduction to Muldis D, please go to:

http://muldis.com/Muldis_D.html

This document gives some side-by-side code comparisons with SQL, ideas for what you can use Muldis D for /right now/ (in existing database tools), a list of its features, and more.

See CD.pod for a complete database schema plus test application example.

Browse through PTMD_STD for the concrete grammar plus a lot more code examples.

Sample Code

slurping a table

   SELECT * FROM tab1
[download]

muldis version

   $tab1
[download]

refining a table slurp

   SELECT *
   FROM tab1
   WHERE col1 = 'hello' AND col2 = 5
      OR col1 = 'world' AND col2 = 7
[download]

muldis version

   $tab1 matching Relation:{
     col1 => 'hello', col2 => 5,
     col1 => 'world', col2 => 7
   }
[download]

column selection from table

Given the example relvar/table "tab" that has the 8 attributes/columns (col1,col2,col3,bigcol4,col5,col6,col7,col8), here's how you select all but one

   SELECT col1, col2, col3, col5, col6, col7, col8
   FROM tab
[download]

muldis version

   $tab@{!bigcol4}
[download]

counting grouped records

   SELECT age, ctry, COUNT(*) AS count_per_age_ctry
   FROM people
   GROUP BY age, ctry
[download]

muldis version

   $people@{#@count_per_age_ctry <- !age,ctry}
[download]

More Muldis Samples

This code in an atomic statement will swap the values of 2 variables:

   $x := $y
   $y := $x
[download]

Here's an example of an atomic stored procedure that performs and returns the result of a query; it uses a higher-order function:

     recipe count_heads (&$count : NNInt, $search : Text,
             $people ::= $fed.data.db1.people) {
         with value-filter filt 
           (Bool <-- $topic : Tuple, $search : Text) {
             $.name like ('%' ~ $search ~ '%')
         }
         $count := r# ($people where <nlx.lib.filt>( $>search ))
     }
[download]

Here's an atomic stored procedure example that demonstrates self-recursion:

     updater make_coprime (&$a : NNInt, &$b : NNInt) {
         with function gcd (NNInt <-- $a : NNInt, $b : NNInt) {
             $b = 0 ?? $a !! rtn( a => $b, b => $a mod $b round Down )
         }
         $gcd ::= nlx.lib.gcd( $>a, $>b )
         $a := $a div $gcd round Down
         $b := $b div $gcd round Down
     }
[download]

See also my site for the 3 official public email lists that are specific to Muldis D and its implementations: "-announce", "-devel", and "-users"; just the latter 2 are for discussions.

If you want a "homepage" url to link to, you can use muldis.com concerning this project or particularly its commercial support.

And http://github.com/muldis/ is its main public GIT version control repository.

Thank you in advance for any interest in or support for this project that you can give. Any kind of support is welcome, from trying to update your own projects to use Muldis D, or from contributing your time and expertise to improving Muldis D or its implementations or ancillary projects, or promoting this project in various media and forums. Support is welcome in providing significant financial sponsorship towards my further work, in which case you have more of a say in its direction and priorities. But mainly I want to see it get used to enrich projects and their users and developers.

This project and ancillary projects are a serious endeavor that I intend to commercially support over the long term, and others can do likewise.

Good day. -- Darren Duncan