[Grace-core] belated Minutes of Telecon 27-28.02.2014

[James Noble]

more belated collated minutes:

- factory methods:
 - can declare classes without dot
 - inherits clause - definitively static call when ends with tail-returning object constructor
 - for now, no "factory" annotations, but something to think about later on.

- traits
 - support inheritance of traits only (not other operators for now) 
 - required e.g. for dialect composition, perhaps for libraries. 
 - inherits X with Y,Z,W 

- ambiguity - banned. must override in the body of the definition
- NO WAY To resend, choosing a parent - leaving it til later

- (a Andrew-trait is an object which explicit inherits from "trait" - which means no "Standard Methods") 
  - although the rest of us might just write class foo {...}
  - classes/objects without an explicit inherits clauses, get the "standard methods" by default.

X is an expression - inherits objects { }   with... 
  considered whether we should we move inherits outside the brackets 
   be clear inherits & with clauses are part of the language syntax, *not* requests.

- standard methods
- Michael thinks its it's in the Spec!  Look it up!   
    **asDebugString** is deprecated!    
     == !=  asString   --- defined in "object { }"  ??? is this what we want ???

- abstract methods .... write method foo {abstract} 


-   (method done -> Done)

-   type Dynamic renamed as type Unknown 

- brands
 - tim will write something up.
 - at this point, he's hoping for OOPSLA so Andrew can't be involved for now.

- annotations:
 - syntactically: annotations are requests 
  - you can't use an annotation in the module in which they are defined

 at compile time call the method to get a "syntatic annotation objects"
   declare annotations by declaring the method (wonders of a single namespace :-)

    at run time - when a declaration is instantiated, it's AST annotation objects are 
       instantiated into runtime annotation objects (which could be the same) 
       full metaobject protocol?

* when are annotations valid?  (not every method can be used as an annotation)
   options: -  java-style annotate the annotation with annotation(target) 
                 - type of return value

potential annotations:

* public, private
* abstract?
* owenership
* documentation,
* deprecated, 
* logging!
* synchronised
* fruity