Dear Maude Abusers,

A new alpha release can be accessed at SRI in

~eker/public_html/Maude/Alpha64/

or downloaded from

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

Currently only linux and solaris are supported. The changes from
Alpha63e are: 

(1)	The special/hook mechanism has been reimplemented in what
	should be a more extensible way. All hooks now work at the
	metalevel and hook names have changed. In particular
	qidSymbol must be used rather than qidBaseSymbol in bubbles.

(2)	metaMatch and metaXmatch implemented

(3)	The garbage collector mark phase has been reimplemented to
	use less stack space for very deep terms in cases where the
	previous tail recursive approach failed (typically lists where
	the list constructor has an identity but no other attributes).

(4)	getName and getType are now implemented via maude strings
	rather than being builtin.

(5)	[_] : Qid -> Module implemented in maude.

(6)	Identity clashes detected.

(7)	match/xmatch commands now use the same code as metaMatch and
	metaXmatch and handle ^C interrupts more cleanly

There are also various bug fixes:

(1)	No longer crashes if user tries to make a sort test at the
	meta level without defining SystemTrue and SystemFalse.

(2)	Fixed bug in
	  op  wellFormed : Module Substitution ~> Bool .
	that could cause memory corruption.

(3)	Fixed memory leaks in metaApply and metaXapply.

(4)	Output buffer is now flushed before reading input, even if
	output is not going to a tty.

(5)	Fixed bug in the statement importation code that leaves the
	imported module in a bad state and which causes importation to
	fail if the statements of a module are imported twice in
	succession without any intervening signature importation
	(which would return the imported module to a good state) from
	that module.

(6)	.*** and .--- are no longer considered to be the end of a
	command followed by a comment when encountered in a command,
	outside of parentheses.

(7)	Fixed wrap-around bug for string built-ins that was provoked by
	using very large numbers (typically maxMachineInt) to stand in
	for infinity or "end of string".

Steven


Various examples:

red in META-LEVEL : metaReduce(
fmod 'FOO is
  including 'BOOL .
  sorts 'MI .
  none
  op 'mi : nil -> 'MI [special(id-hook('MachineIntegerSymbol, nil))] .
  op '< : 'MI 'MI -> 'MI [special(id-hook('MachineIntegerOpSymbol, '<)
				  op-hook('machineIntegerSymbol, 'mi, nil, 'MI)
				  term-hook('trueTerm, 'true.Bool)
				  term-hook('falseTerm, 'false.Bool))] .
  none
  none
endfm, '<['9.MI, '10.MI]) .

red in META-LEVEL : metaParse(
fmod 'FOO is
  including 'QID-LIST .
  sorts 'Token ; 'Foo .
  none
  op 'tokens : 'Qid -> 'Token [special(id-hook('Bubble, '0 '10)
                                       op-hook('qidSymbol, '<Qids>, nil, 'Qid)
				       op-hook('nilQidListSymbol, 'nil, nil, 'QidList)
				       op-hook('qidListSymbol, '__, 'QidList 'QidList, 'QidList)
				       id-hook('Exclude, 'assoc 'com 'memo))] .
  op '`[_`] : 'Token -> 'Foo [none] .
  none
  none
endfm, '`[ 'a 'b 'c '`] , anyType) .

red in META-LEVEL : metaReduce(
fmod 'FOO is
  nil
  sorts 'Foo ; 'Bool .
  none
  op 'true : nil -> 'Bool [special(id-hook('SystemTrue, nil))] .
  op 'false : nil -> 'Bool [special(id-hook('SystemFalse, nil))] .
  op 'a : nil -> 'Foo  [none] .
  none
  none
endfm, '_::`Foo['a.Foo]) .

red in META-LEVEL : metaReduce(
fmod 'FOO is
  nil
  sorts 'Foo ; 'Bool .
  none
  op 'itef : 'Bool 'Universal 'Universal -> 'Universal
	[special(id-hook('BranchSymbol, nil)
                 term-hook('trueTerm, 'true.Bool)
                 term-hook('falseTerm, 'false.Bool))] .

  op 'true : nil -> 'Bool [none] .
  op 'false : nil -> 'Bool [none] .

  op 'a : nil -> 'Foo  [none] .
  op 'b : nil -> 'Foo  [none] .
  none
  none
endfm, 'itef['false.Bool, 'a.Foo, 'b.Foo]) .

red in META-LEVEL : metaReduce(
fmod 'FOO is
  nil
  sorts 'Foo ; 'Bit .
  none
  op '= : 'Universal 'Universal -> 'Bit
	[special(id-hook('EqualitySymbol, nil)
                 term-hook('equalTerm, '1.Bit)
                 term-hook('notEqualTerm, '0.Bit))] .

  op '1 : nil -> 'Bit [none] .
  op '0 : nil -> 'Bit [none] .

  op 'a : nil -> 'Foo  [none] .
  op 'b : nil -> 'Foo  [none] .
  none
  none
endfm, '=['a.Foo, 'b.Foo]) .

red in META-LEVEL : metaMatch(fmod 'FOO is
  protecting 'BOOL .
  sorts 'Foo ; 'Bar .
  subsort 'Bar < 'Foo .
  op 'a : nil -> 'Foo [none] .
  op 'b : nil -> 'Foo [none] .
  op 'f : 'Foo 'Foo -> 'Foo [comm] .
  none
  none
endfm, 'f['X:Foo, 'Y:Foo], 'f['a.Foo, 'b.Foo], 1) .

red in META-LEVEL : metaXmatch(
fmod 'FOO is
  protecting 'BOOL .
  sorts 'Foo ; 'Bar .
  subsort 'Bar < 'Foo .
  op 'a : nil -> 'Foo [none] .
  op 'b : nil -> 'Foo [none] .
  op 'c : nil -> 'Foo [none] .
  op 'f : 'Foo 'Foo -> 'Foo [assoc comm] .
  none
  none
endfm,
'f['X:Foo, 'Y:Foo],
'f['a.Foo, 'b.Foo, 'c.Foo, 'c.Foo], 0, 100, 0) .