Dear Maude Abusers,

A new alpha release can be accessed at SRI-CSL in:

~eker/public_html/Maude/Alpha83/

or downloaded from:

http://www.csl.sri.com/~eker/Maude/Alpha83/

Alpha release site authentication:

User Name: maudeabuser
Password: bughunter

This version is a pure alpha release - it is not destined for the
Maude website though of course you may redistribute it under the GPL.
Because of this I have only made binaries for Linux, Solaris and
Darwin.

Bug fixes
==========
(1) A bug in the meta-context code where iter operators were not
    properly handled. Reported by Alberto Verdejo, and provoked by the
    following example:

red in META-LEVEL : metaXmatch(mod 'SORTING is
  protecting 'BOOL .
  protecting 'STRING .
  protecting 'NAT .
  sorts 'Pair ; 'PairSet .
  subsort 'Pair < 'PairSet .
  op '<_;_> : 'Nat 'String -> 'Pair [none] .
  op '__ : 'PairSet 'PairSet -> 'PairSet [assoc comm id('empty.PairSet)] .
  op 'empty : nil -> 'PairSet [none] .
  none
  none
  rl '__['<_;_>['J:Nat,'X:String],'<_;_>['I:Nat,'Y:String]]=> '__['<_;_>[
    'J:Nat,'Y:String],'<_;_>['I:Nat,'X:String]] [label('switch)] .
endm, 
'__['<_;_>['B:Nat,'C:String],'<_;_>['A:Nat,'D:String]],
'__['<_;_>['s_['0.Zero],'"d".Char],'__['<_;_>['s_^2['0.Zero],
    '"b".Char],'__['<_;_>['s_^3['0.Zero],'"a".Char],'<_;_>['s_^4['0.Zero],
    '"c".Char]]]],
'_and_['_<_['B:Nat,'A:Nat],'_>_['C:String,'D:String]] = 'true.Bool,
0, unbounded, 0) .

(2) A bug in the handling of bubbles at the object level where adding
    an "Exclude" id-hook caused the bubble property to be
    ignored. Provoked by the following example:

fmod BUBBLE-TEST is
  inc QID-LIST .
  sort Text .
  op text : QidList -> Text 
        [special (
                  id-hook Bubble (1 -1 ( ))
                  id-hook Exclude ( x y z )
                  op-hook qidSymbol (<Qids> : ~> Qid)
                  op-hook qidListSymbol (__ : QidList QidList ~> QidList))] .
  op f : Text -> Bool .

endfm

red f( a c b ) .


Other changes
==============
(1) Polymorphic operators are now declared explicitly by the
    polymorphic (abbreviates to poly) attribute. This take a set of
    integers enclosed in parentheses that indicates which arguments
    are polymorphic; 0 indicates the range. For polymorphic operators
    that are not constants, at least one argument should be
    polymorphic to avoid ambiguities. Since there are no polymorphic
    equations, polymorphic operators are limited to constructors and
    builtins. Polymorphs are always instantiated with the polymorphic
    arguments going to the kind level which further limits their
    generality. The sort name in a polymorphic position is purely a
    place holder - any legal type name could be used but it seems a
    useful convention to use "Universal".

    One reasonable use for polymorphic operators beyond the existing
    builtins is to define hetrogeneous lists:

fmod HET-LIST is
  inc CONVERSION .

  sort List .
  op nil : -> List .
  op __ : Universal List -> List [ctor poly (1)] .
endfm

red 4 "foo" 4.5 1/2 nil .

    The polymorphic attribute is reflected by:
      op poly : NatList -> Attr [ctor] .

(2) The show all and show mod commands now print out the special
    attribute and its hooks.

(3) The set of ascent functions is completed with:
      op upModule : Qid Bool ~> Module .
      op upImports : Qid ~> ImportList .
      op upSorts : Qid Bool ~> SortSet .
      op upSubsortDecls : Qid Bool ~> SubsortDeclSet .
      op upOpDecls : Qid Bool ~> OpDeclSet .

    These work in an analogous fashion to the existing ascent
    functions. Note that upImports() does not take a Bool since it is
    not useful to query the imports of a flattened module.

Steven