
OGATA
=====

Pat(rick) Brown - Ireland, Dublin, CafeOBJ in discrete math - 
	logical approach to discrete math


MIT Scheme


* p.2: description of rewriting logic should be improved
  rewriting logic is used for 
 
  rewriting logic != rewriting engine

  rewriting engine is used in all areas (also order logic rewriting)
  rewriting logic is used only for transitions

  We need to describe what is "rewriting logic" and have a separate
  point on "rewriting" as engine.

* behavioral logic - mention what which connection to co-algebra

* chpater 2 - start with mod!
	metnion that ! tight semantics ... some short comment

* p.5: use "mixfix" instead of "infix"

* p.8: "the last equation in each models" -> model ...

* p.8: == is not about behaviour, but about "equal by rewriting"
  remove the "behavioral" ... just remove what is written before

* p.8: make clear that it is normally *NOT* recommendable to use ==
  especially =/= which is dangerous
  Here we have to made clear that this is only a very restricted usage
  for literals


open PNAT .
  op a : -> Nat .
  red not ( a == 0 ) .
close.

reduces to true ... because it is only equivalence via rewriting.


* p.8 parametrized modules: mention templates in C++ ????

* p.8 before after :: is not "sort" but "module" !!!

* p.10 bottom:
	mixing protecting(STATE)
	with State => State transitions
  we actually have two "interpretations":
  - trans are on the "meta" level and we do not use rewriting logic
  	we are protecting STATE
  - trans are part of a new algebra with trans (rewriting logic)
  	we should use "extending"


* p.10 bottom:
	if _ then _ else _ fi
  instead of ....

* difference between == and =
  == reduction of terms to syntactical smae term => true else false
  = .. if no eq eqaution then the term is returned "as"is"
  	(a = b)


* new commands -> ask Sawada ...




SAWADA
======
p 10 renaming fst -> fst.clstate

currently this is *ignored* but *no* warning/error!!!

two things to be fixed: 
- if ignored then still a warning should be given
- support dots in names


-------------

DONE
mail from Sawada-san concerning operator precedence:

(1) standard form: ex.  op foo : S1 .. Sk -> S                                  
      precedence = 0                                                            
(2) unary operator: ex.  op unary_ : S1 -> S                                    
      precedence = 15                                                           
(3) mix-fix with first & last tokens are both arguments: ex. op _ arg-or-op _ : 
S1 .. Sn -> S                                                                   
      precedence = 41
(4) otherwise (constant operator, operators of the form like "begin__end")
      precedence = 0

---------------

comments from Sawada-san 2013-10-30

(DONE)
(1) on-the-fly declarations (on p.21)
     The description of on-the-fly constant "`a:Nat" declaration

     "On-the-fly declaration of constants are done the same way, where
the <name> is a con-
      stant name as in \a:Nat‘. Using this construct is equivalent to
defining an operator
      op <name> : -> <sort> "

      is not incorrect, but I feel it is better to stress the fact
that the declaration is effective
      only within the current context (axioms or a term).

(2)  obsolete commands/switches
      There seems to be some commands which don't work properly and are now
      almost obsolete. One of them is the command 'save-system' which
tries to dump the
      executable image of the interpreter for later use. But I feel
nobody use this command any more.
      And there would be other commands/switches which don't have
significant value no more.
      I would like to list these things up and discuss the treatment
of them with you.

(3) putting some useful tips into the manual
     I think veteran users have many useful tips for avoiding troubles
with the system or
     for enhancing productivity of their work. These are valuable
information for novice users.
     Including tips might not fit the aim of the reference manual, though.

-----------------


