The Grace Programming Language Draft Specification Version 0.3
Contents
1. can a type extend another type Kim Yes though we use amp to denote it lt Kim May be an issue and distinction if we allow SelfType lt Structural typing means we neither need nor want any variance anno tations Because Grace is structural programmers can always write an anonymous structural type that gives just the interface they need or such types could be stored in a library Kim Yes Move this somewhere reasonable in the spec lt ObjectTypes require formal parameter names amp need to fix examples TE Tuples 11 11 Syntax as a type Literal Tuple Syntax Nesting Serialization Include dialect description Pragmatics The distribution medium for Grace programs objects and libraries is Grace source code Grace source files should have the file extension grace If for any bizzare reason a trigraph extension is required it should be grc Grace files may start with one or more lines beginning with these lines are ignored 36 Revision 1303 committed on 2013 10 17 22 42 57Z by black 12 1 Garbage Collection Grace implementations should be garbage collected Safepoints where GC may occur are at any backwards branch and at any method request Grace will not support finalisation Kim gt Seems like we will need it lt 12 2 Concurrency and Memory Model The core Grace specification does not describe a concur2. cleanup __ B Kim gt We still do have a problem inserting type definitions in a context How can we distinguish it from a block Perhaps we need to say that only type names possibly with a prefix path and type parameters after can appear in a context expecting a type expression lt 4 11 4 Relationships between Types Conformance Rules The key relation between types is conformance We write B lt A to mean B conforms to A that is that B is a subtype of A A is a supertype of B This section draws heavily on the wording of the Modula 3 report LI with apologies to Luca Cardelli et al If B lt A then every object of type B is also an object of type A The converse does not apply If A and B are ground object types then B lt A iff for every method m in A there is a corresponding method m with the same name in B such that e The method m in B must have the same number of arguments as m in A with the same distribution in multi part method names e Ifthe method m in A has signature P P gt R and m in B has signature Q1 Qn gt S then Argument types must be contravariant P lt Qi Results types must be covariant S lt R Kim almost feel the signature should be further subdivided to reflect multi part names but that seems too paintul lt 32 Revision 1303 committed on 2013 10 17 22 42 57Z by black If a class or object B inherits fr
3. 45 46 47 48 49 50 51 Revision 1303 committed on 2013 10 17 22 42 57Z by black Martin Odersky and Matthias Zenger Scalable component abstractions In OOPSLA 2005 Alan J Perlis The American side of the development of ALGOL In History of Programming Languages I pages 75 91 ACM Press 1981 Martin Richards and Colin Whitby Stevens BCPL the language and its compiler Cambridge University Press 1980 Andrew Shalit The Dylan reference manual the definitive guide to the new object oriented dynamic language Apple Computer Inc 1996 Bjarne Stroustrup Why C is not just an object oriented program ming language In OOPSLA Companion ACM Press 1995 Gerald Sussman and Guy Steele SCHEME An interpreter for extended lambda calculus Technical Report AI Memo 349 MIT Artificial Intel ligence Laboratory December 1975 Don Syme The Ff draft language specification Technical report Mi crosoft 2009 Antero Taivalsaari Delegation versus concatenation or cloning is inher itance too OOPS Messenger 6 3 1995 David Ungar and Randall B Smith SELF the Power of Simplicity Lisp and Symbolic Computation 4 3 June 1991 Larry Wall Perl the first postmodern computer language http www wall org larry pm html Spring 1999 Allen Wirfs Brock and Brian Wilkerson Modular Smalltalk In OOP SLA 1998 Niklaus Wirth Modula 2 and Oberon In HOPL 2007
4. c then the pattern itself is translated into a composite object structure def mypat MatchAndDestructuringPattern new Pair VariablePattern new a MatchAndDestructuringPattern new Pair VariablePattern new b VariablePattern new c Finally the translated pattern and block are glued together via a LambdaPattern LambdaPattern new mypat _ a b c gt a b c Revision 1303 committed on 2013 10 17 22 42 57Z by black 25 The translation is as follows e Le ie v fresh unbound variable v bound variable vie e f g literal e not otherwise translated fe WildcardPattern VariablePattern v error AndPattern new VariablePattern new v e MatchAndDestructuringPattern new e f g literal e 9 2 3 Implementing Match case Finally the match 1 case N methods can be implemented directly e g method match o Any case b1 Block lt B1 R gt case b2 Block lt B2 R gt for b1 b2 do b gt def rv b match o if rv succeeded then return rv result FailedMatchException raise or because matching blocks are patterns in terms of pattern combinators method match o Any case b1 Block lt B1 R gt case b2 Block lt B2 R gt def rv b1 b2 match o if rv succeeded then return rv result FailedMatchException raise 26 Revision 1303 committed on 2013 10 17 22 42 57Z by black First
5. rule methodWithArgsHeader unaryMethodHeader def inheritsClause rule opt inheritsld expression semicolon def unaryMethodHeader rule identifier genericFormals def methodWithArgsHeader rule firstArgumentHeader repsep argumentHeader opt ws def firstArgumentHeader rule identifier genericFormals methodFormals def argumentHeader rule identifier methodFormals def operatorMethodHeader rule otherOp oneMethodFormal def prefixMethodHeader rule opt ws token prefix otherOp forbid space after prefix def assignmentMethodHeader rule identifier assign oneMethodFormal def accessingMethodHeader rule IrBrack genericFormals methodFormals def accessingAssignmentMethodHeader rule IrBrack assign genericFormals methodFormals def methodReturnType rule opt arrow nonEmptyTypeExpression def methodFormals rule IParen replsep identifier opt colon typeExpression comma rParen def oneMethodFormal rule IParen identifier opt colon typeExpression rParen def blockFormals rule repsep identifier opt colon typeExpression comma def matchBinding rule identifier literal parenExpression opt colon nonEmptyTypeExpression opt matchingBlockTail def matchingBlockTail rule IParen replsep matchBinding comma rParen def typeDeclaration rule typeld identifier genericFormals equals nonEmpt
6. target means the syntactic thing to the left of the dot while re ceiver means the dynamic thing that gets the request I m not sure if these are the right names lt Methods can be explicitly annotated as is public this has no effect unless a dialect changes the default encapsulation Andrew f this is possible lt Grace does not have private methods Thus all methods can be overrid den Michael know what this means but it is confusing between two senses of can be overridden and also private It sounds like it s talking about final methods 8 8 2 Fields Variables and definitions var and def declarations immediately inside an object constructor create fields in that object A field declared as var x can be read using the request x and assigned to using the assignment request x see 48 2 A field declared as def y can be read using the request y and cannot be assigned By default fields are confidential they can be accessed and assigned from the object itself and from inheriting objects but not from clients Andrew gt What about from inner objects Can say outer confidentialField Michael Yesa In other words these requests can be made only on self and super Andrew and outer a However fields can be made available to client objects using annotations The annotation readable can be applied to
7. Vassili Bykov Yaron Kashai William Maddox and Eliot Miranda6 Modules as objects in Newspeak In ECOOP 2010 Tim Budd A Little Smalltalk Addison Wesley 1987 Luca Cardelli Type systems In Allen B Tucker editor Computer Science Handbook chapter 97 CRC Press 2nd edition 2004 Luca Cardelli James Donahue Lucille Glassman Mick Jordan Bill Kalsow and Greg Nelson Modula 3 reference manual Technical Report Research Report 53 DEC Systems Research Center SRC 1995 J Dedecker T Van Cutsem S Mostinckx T D Hondt and W De Meuter Ambient oriented programming in AmbientTalk In ECOOP pages 230 254 2006 46 13 14 15 16 17 18 19 20 21 22 23 24 25 26 Revision 1303 committed on 2013 10 17 22 42 57Z by black Carlton Egremont III Mr Bunny s Big Cup o Java Addison Wesley 1999 Erik Ernst Family polymorphism In ECOOP 2001 Matthias Felleisen Robert Bruce Findler Matthew Flatt and Shriram Krishnamurthi How To Design Programs MIT Press 2001 Richard P Gabriel LISP Good news bad news how to win big AI Expert 6 6 30 39 1991 Joseph Gil and Itay Maman Whiteoak Introducing structural typing into Java In OOPSLA 2008 Brian Goetz Time Peierls Joshua Block Joesph Bowbeer David Holmes and Doug Lea Java Concurrency in Practice Addison Wesley Professional 2006 Adele Goldberg and David Robson Smalltalk 80 The
8. absent type arguments must be populated with Dynamic on the receiving end lt Examples sumSq lt Integer64 gt 10 i64 20 164 sumSq 10 i64 20 164 Andrew An example that gives the method definition and uses the type in some way would be more useful lt 8 11 Precedence of Method Requests Grace programs are formally defined by the language s grammar see ap pendix B The grammar gives the following precedence levels higher num bers bind more tightly 1 Assignment operator as a suffix to a named request or accessing operator 2 Other operators no priority for different operators associate left to right Michael gt no priority meaning is a syntax error Additive operators and associate left to right Multiplicative operators x and associate left to right Prefix operators associate right to left O a A W Named requests with or without arguments the accessing operator Multi part named requests accumulate words and arguments as far to the right as possible 7 Literals numbers strings objects types parenthesized expres sions 9 Control Flow Control flow statements in Grace are syntactically method requests This allows instructors to use libraries to define domain specific control flow con structs that look the same as the rest of Grace 22 Revision 1303 committed on 2013 10 17 22 42 57Z by black 9 1
9. 22 42 57Z by black 39 10 11 12 13 14 15 16 17 18 19 20 21 support multiple constructors for classes Kim gt Show how it is done but no need for separate syntax lt where should we draw the lines between object constructor expres sions named object declarations class declarations and hand built classes Kim Don t understand what the issue is lt what s the difference between class FOO and def FOO class for various values of class Kim The second is not currently legal though could write def of factory object generating similar items as class lt how do factories etc relate to uninitialized decide what to do about equality operators Kim gt Thiat is impor tant lt Support for identifying static type decltype and dynamic type typeid foo get Type Support for type test like instanceof and static casts More to the point what is the type system Kim We should insert definition We don t support instance of instead use match lt Multiple Assignment Kim Why bother lt Type assertions should they just be normal assertions between types so e g lt could be a normal operator between types Grace needs subclass compatibility rules Kim YES lt BRANDS Brand Brand Brand kim Maybe not needed lt weak refer
10. 42 57Z by black 29 Unlike in other parts of Grace Type declarations are always statically typed and their semantics may depend on the static types The main case for this is determining between identifiers that refer to types and those that refer to constant name definitions introduced by def which are interpreted as Singleton types 11 1 Basic Types Grace s standard prelude defines the following basic types Kim We should specify the signature of each of these types I ve listed some here but it would be better to just write out the full type definitions lt None an uninhabited type None conforms to all other types Kim Perhaps we should consider undefined as a member lt Andrew gt Since one can nerver dereference an in defined variable one can never request a method from undefined lt Done the type of the object returned by assignments and methods that have nothing interesting to return Andrew gt All other types conform to Done lt The only method on such objects is asDebugString Kim Minigrace includes and That seems reasonable to me lt Object the common interface of most objects Object can also be written Kim t has methods and asString We should specify that these are part of all types How do we distinguish between Done and Object structurally Boolean methods
11. Basic Control Flow If statements if test then block if test then block else block While statement while test do block For statement for collection do item gt block body for course students do s Student gt print s for 0 n do i gt print i To allow for conventional syntax with a leading keyword if while for etc these methods are treated as if they are sent to outer Methods defined in a dialect are treated as if they are defined on an outer level enclosing object Andrew Add Xref to as yet unwritten section on dialects 9 2 Case The match case construct which attempts to match its first argument against a series of patterns introduced by case Patterns support destructuring Andrew gt The description of blocks in 5 needs to be enhanced to talk about blocks like the Ist and 3rd examples below lt Examples match x case 0 gt Zero match against a literal constant case s String gt print s typematch binding s identical to block with typed parameter case pi gt print Pi pi match against the value of an expression requires parenthesis case _ Some v gt print v Revision 1303 committed on 2013 10 17 22 42 57Z by black 23 typematch binding a variable looks like a block with parameter case _ gt print did not match match against placeholder match
12. Language and its Implementation Addison Wesley 1983 C A R Hoare Hints on programming language design Technical Report AIM 224 Stanford Artificial Intelligence Laboratory 1973 Ric Holt and Tom West OBJECT ORIENTED TURING REFER ENCE MANUAL seventh edition version 1 0 Technical report Holt Software Associates Inc 1999 Paul Hudak John Hughes Simon Peyton Jones and Philip Wadler A history of Haskell being lazy with class In History of Programming Languages ITT pages 12 1 12 55 ACM Press 2007 Roberto Ierusalimschy Luiz Henrique de Figueiredo and Waldemar Ce les The evolution of Lua In HOPL ITI 2007 A Igarashi B C Pierce and P Wadler Featherweight Java A minimal core calculus for Java and GJ ACM Transactions on Programming Languages and Systems 23 3 396 450 2001 Atsushi Igarashi and Hideshi Nagira Union types for object oriented programming Journal of Object Technology 6 2 31 45 February 2007 http www jot fm issues issues 2007 02 article3 Daniel H H Ingalls Design principles behind Smalltalk BYTE Maga zine August 1981 Revision 1303 committed on 2013 10 17 22 42 57Z by black 47 27 Kathleen Jensen and Niklaus Wirth Pascal User Manual and Report Springer 1975 28 Brian W Kernighan and Dennis M Ritchie The C Programming Language Addison Wesley 2nd edition 1993 29 Gregor Kiczales Erik Hilsdale Jim Hugunin Mik Kersten Jeffrey Palm and William G Gris
13. are written in the ASCII subset of Unicode As a matter of policy the names of methods defined in the required libraries are also restricted to the ASCII subset of Unicode James and the character 74 3 1 Layout Grace uses curly brackets for grouping and semicolons as statement termi nators and infers semicolons at the end of lines Code layout cannot be inconsistent with grouping code with punctuation while stream hasNext do print stream read i code without punctuation while stream hasNext do print stream read A line break followed by an increase in the indent level implies a line continuation whereas line break followed by the next line at the same or lesser indentation implies a semicolon if one is permitted syntactically James We need to define this precisely 3 2 Comments Grace s comments start with a pair of slashes and are terminated by the end of the line as in C and Java However comments are not treated as white space Each comment is conceptually attached to the smallest im mediately preceding syntactic unit except that comments following a blank line are attached to the largest immediately following syntactic unit comment to end of line 4 Revision 1303 committed on 2013 10 17 22 42 57Z by black 3 3 Identifiers Identifiers must begin with a letter which is followed by a sequence of zero or more letters digits and characters An unde
14. determined statically Thus the rules for conformance are more restrictive S lt S T T lt S T S lt S amp T lt T gt S T lt S T Kim gt Added this example Does it help The following example illustrates the limitations Suppose type S m A gt B n C gt D type T m A gt B k E gt F type U m A gt B Then U fails to conform to S T even though U contains all methods continued in both S and T Kim fix font of S T U 11 6 Intersection Types option An object conforms to an Intersection type written T1 amp T2 amp amp Tn if and only if that object conforms to all of the component types The main use of intersection types is as bounds on where clauses Revision 1303 committed on 2013 10 17 22 42 57Z by black 33 class Happy lt T gt where T lt Comparable lt T gt amp Printable amp Happyable p gt 11 7 Union Types option Structural union types sums written T1 T2 Tn may refer to an object that conforms to any of the component types Unions are mostly included for completeness variant types subsume most uses 11 8 Type subtraction option A type written T1 T2 has the interface of T1 without any of the methods in T2 Kim Need to tighten up this definition 11 9 Singleton Types James gt How does this work with the new pattern matching interpretati
15. executing the method involves the code of the method which is local to the receiver 8 1 Named Requests A named method request is a receiver followed by a dot then a method name an identifier then any arguments in parentheses Parentheses are not used if there are no arguments To improve readability a the name of a method that takes more than one parameter may comprise multiple parts or words with argument lists between the words and following the last word For example method drawLineFrom source to destination Revision 1303 committed on 2013 10 17 22 42 57Z by black 15 The name of a method and the position of its argument lists within that name is determined when the method is declared When reading a request of a multi part method name you should continue accumulating words and argument lists as far to the right as possible right as possible If the receiver of a named method is self it may be left implicit i e the self and the dot may both be omitted Grace does not allow the overloading of method names the type and number of arguments in a method request does not influence the name of the method that is being requested Parenthesis may be omitted where they would enclose a single argument that is a string or block literal Examples canvas drawLineFromPoint p1 toPoint p1 canvas drawLineFromPoint origin ofLenthXY 3 5 canvas movePen ToXY x y canvas movePen ToPoint p print Hello wo
16. for true and false Kim Has operations methods string concatenation amp amp and match lt prefix not not ifType asString Number numbers Kim Has operations methods l lt lt gt gt asString prefix inBase truncate and match lt 4 String strings and individual characters kim Has operations size ord at iter substringFrom to replace with hash code indices asString asNumber match lt Pattern pattern used in match case statements In addition variables can be annotated as being Dynamic Dynamic is not a type but a label that the type system uses when reasoning about the 30 Revision 1303 committed on 2013 10 17 22 42 57Z by black values of expressions Dynamic is also implicitly assigned to parameters and variables for which no type is declared 11 2 Types Types define the interface of objects by detailing their public methods and the types of the arguments and results of those methods Types can also contain definitions of other types The various Cat object and class descriptions see would produce objects that conform to an object type such as the following Notice that the public methods implicitly inherited from Object are implicitly included in all types colour gt Colour name gt String miceEaten gt Number miceEaten
17. 43 Eiffel 35 B6 Emerald 5 Fy KO Revision 1303 committed on 2013 10 17 22 42 57Z by black 37 Ft 46 FGJ 24 FJV B5 FORTRESS I gBeta 14 Haskell 22 Java 13 18 Kevo 47 Lua 23 Lisp 16 ML 87 Modula 2 51 Modula 3 II Modular Smalltalk 50 Newspeak 8 6 Pascal 27 Perl 49 Racket 15 Scala 401 39 Scheme 45 Self 48 Smalltalk 19 26 9 7 Object Oriented Turing 21 Noney 84 and Whiteoak at least we apologise if we ve missed any languages out All the good ideas come from these languages the bad ideas are all our fault 20 38 Revision 1303 committed on 2013 10 17 22 42 57Z by black A To Be Done As well as the large list in Section I of features we haven t started to design this section lists details of the language that remain to be done 1 specify full numeric types Kim Should be single type not types lt 2 Block apply How should we spell apply run Kim decided on apply lt 4 Andrew Because mapping can be represented by Maps and Func tions thee is an argument to spell apply and at he same way at is also shorter than apply lt 3 confirm method lookup algorithm in particular relation between lex ical scope and inheritance see 8 Out then Up Is that enough Does the no shadowing rule work If it does is this a problem Kim gt W
18. 9 3 Exceptions under discussion Grace supports exceptions which can be raised and caught Exceptions are raised by requesting the raise method from an Exception object with a string argument explaining the problem userException raise Oops Exceptions are caught by a catch 1 case 1 case 1 construct that syn tactically parallels match 1 case 1 Andrew gt This is a bad name try catch catch would make more sense catch def f File open data store case e NoSuchFile gt print No Such File return case e PermissionError gt print Permission denied return case Exception gt print Unidentified Error System exit finally f close Raising an Exception terminates the execution of the expression contain ing the raise request it is not possible to restart or resume that executior 1 However implementors should pickle the stack frames that are terminated when an exception is raised so that they can be used in the error reporting machinery debugger stack trace 28 Revision 1303 committed on 2013 10 17 22 42 57Z by black Andrew continue here lt catch 1 case 1 finally 1 construct and a do 1 finally 1 construct sup port finalization even through exceptions Following Scala a using 1 do 1 construct supports resource allocation and deallocation using Closable new do stranger gt bound to the new Closable stranger
19. Class Patterns While all types are patterns not all patterns are types For example it would seems sensible for regular expressions to be pat terns potentially created via one or more shorthand syntaxes shorthands all defined in standard Grace match myString case gt print null string case Regexp new a z gt print lower case case A Z r gt print UPPER CASE case O 9 x gt print numeric case Forename A Za z Surname A Za z r2 fn sn gt print Passenger fn first sn With potentially justifiable special cases more literals e g things like tu ples lists could be descructured a b gt a b Although it would be very nice it s hard to see how e g points created with 3 4 could be destruc ted like a b gt print x a y b without yet more bloated special case syntax Discussion This rules try to avoid literal conversions and ambiguous syn tax The potential ambiguity is whether to treat something as a variable dec laration and when as a first class pattern These rules should treat only fresh variables as intended binding instances so a pattern that syntactically matches a simple variable declaration as in this block empty gt print the singleton empty collect will raise an error even though this is unambiguous given Grace s no shad owing rule Match statements that do nothing but match on ty
20. Design of Design 2010 First year university students learning programming in CS1 and CS2 classes that are based on object oriented programming a The courses may be structured objects first or imperative first Is it necessary to support procedures first b The courses may be taught using dynamic types static types or both in combination in either order c We aim to offer some but not necessarily complete support for functional first curricula primarily for courses that proceed rapidly to imperative and object oriented programming University students taking second year classes in programming algo rithms and data structures concurrent programming software craft and software design Faculty and teaching assistants developing libraries frameworks ex amples problems and solutions for first and second year programming classes Programming language researchers needing a contemporary object oriented programming language as a research vehicle Designers of other programming or scripting languages in search of a good example of contemporary OO language design Revision 1303 committed on 2013 10 17 22 42 57Z by black 3 3 Syntax Much of the following text assumes the reader has a minimal grasp of computer terminology and a feeling for the structure of a program Kathleen Jensen and Niklaus Wirth Pascal User Manual and Report Grace programs are written in Unicode Reserved words
21. The Grace Programming Language Draft Specification Version 0 3 1303 Andrew P Black Kim B Bruce James Noble October 17 2013 1 Introduction This is a specification of the Grace Programming Language This specifica tion is notably incomplete and everything is subject to change In particular this version does not address the library especially collection syntax and collection literals nested static type system although we ve made a start module system James should write up from DYLA paper lt metadata Java s annotations C attributes final abstract etc James pe should add this too lt Kim Need to add syntax but not necessarily details of which attributes are in language yet lt immutable data and pure methods reflection assertions data structure invariants pre amp post conditions contracts Kim gt Put into dialects section lt Dialects regexps libraries including more complex Numeric types and testing For discussion and rationale see http gracelang org Where this document gives options we outline choices in the language design that have yet to be made Revision 1303 committed on 2013 10 17 22 42 57Z by black User Model All designers in fact have user and use models consciously or subconsciously in mind as they work Team design requires explicit models and assumptions Frederick P Brooks The
22. _ Number gt Done For commonality with method declarations method arguments are nor mally named in type declarations These names are useful when writing specifications of the methods If a parameter name is omitted it must be replaced by an underscore The type of a parameter may be omitted in which case the type is Dynamic 11 3 Type Declarations Types and parameterized types may be named in type declarations type MyCatType color gt Colour name gt String care only about names and colours type MyParametricType lt A B gt where A lt Hashable B lt DisposableReference at _ A put _ B gt Boolean cleanup __ B Grace has a single namespace types live in the same namespace as meth ods and variables Revision 1303 committed on 2013 10 17 22 42 57Z by black 31 Kim There is no advantage to writing constraints on the type parameters in parameterized type definitions Those really only make sense for classes and methods In particular you can t write a type definition that only makes sense when constrained lt James gt Declaring parameterized types with like this is very confusing How do we write an anonymous structural parameterized type Do we need to Or aren t we able to write such types lt Kim gt suppose we could instead write lt type MyParametricType lt A B gt at _ A put _ B gt Boolean
23. a def or var declaration and makes the accessor request available to any object The annotation writable can be applied to a var declaration and makes the assignment request avail able to any object It is also possible to annotate a field declaration as public In the case of a def public is equivalent to readable Andrew Do we want this It s an option In the case of a var public is equivalent to readable writable Fields and methods share the same namespace The syntax for variable access is identical to that for requesting a reader method while the syntax for variable assignment is identical to that for requesting an assignment method This means that an object cannot have a field and a method with the same name and cannot have an assignment method x as well as a var field x Examples object def a 1 Confidential access to a def b is public 2 Public access to b def c is readable 2 Public access to c 20 Revision 1303 committed on 2013 10 17 22 42 57Z by black var d 3 Confidential access and assignment var e is readable Public access and confidential assignment var f is writable Confidential access public assignment var g is public Public access and assignment var h is readable writable Public access and assignment 8 9 Private Fields Michael gt This insistent terminology really needs to be explained somewhere or else better unless the
24. a name optionally a pa rameter list potentially repeated optionally a return type declaration and a method body Methods may not be nested Revision 1303 committed on 2013 10 17 22 42 57Z by black 9 Methods may contain one or more return e statements If a return state ment is executed the method terminates with the value of the expression e If the method returns Done then no expression may follow the return If ex ecution reaches the end of the method body without executing a return the method terminates and returns the value of the last expression evaluated Methods can be named by an identifier suffixed with this form of name is conventionally used for writer methods both user written both automatically generated and custom as exemplified by the example value below Prefix operator methods are named prefix followed by the operator character s Methods may have repeated parameters to allow them to take a variable number of parameters that is to provide method of variable arity called varargs in some other languages A repeated parameters if present must be the last parameter in any on the parameter lists following a part of a multi part method name Repeated parameters are designated by a star x before the name of the parameter Inside the method a repeated parameter has the type of an immutable collection of the declared type for example a pa rameter declared xargs String has t
25. and side of an inherits clause is restricted to be an expression that creates a new object such as the name of a class followed by a request on its constructor method or a request to copy an exiting object When executing inherited code self is first bound to the object under construction self requests are resolved in the same way as the finally con structed object def and var initialisers and inline code are run in order from the topmost superclass down to the bottom subclass Accesses to unitialised vars and defs raise uninitialised exceptions 96 2 Andrew gt Kim to insert a rewriting of the above code to illustrate this processa 7 4 Understanding Inheritance under discussion Grace s class declarations can be understood in terms of a flattening transla tion to object constructor expressions that build the factory object Under standing this translation lets expert programmers build more flexible facto ries The above declaration for class aPedigreeCat is broadly equivalent to the following nested object declarations not considering types modules and renaming superclass methods so that an object s method names must actually be unique def aPedigreeCat object a cat factory method ofColour c Colour named n String gt PedigreeCat object the cat herself def colour Colour c def name String n var Cat__miceEaten 0 ugly very ugly var prizes 0 method miceEaten 0 me
26. andard precedence for programming languages with chainable method calls It may also imply that x 5 x 5 which is not standard practice and think probably not the intention More tightly than operators and less tightly than named requests is how it should work lt Michael In fact this is how the precedence is actually defined in Section Examples 3 4 b squared b squared b squared parses as b squared status ok engine isOnFire amp amp wings areAttached amp amp isOnCourse Andrew By the above rule we are OK only if the wings have fallen off and we are offcourse lt 4 8 5 Accessing Operator Requests Grace supports operators and which can be defined in libraries e g for indexing and modifying collections Examples print a 3 requests method on a with argument 3 a 3 Hello requests method on a with arguments 3 and Hello Note Somewhere we need to have a list of reserved operators that cannot be used normally Andrew eh What does that mean lt 8 6 Super Requests The reserved word super may be used only as an explicit receiver In over riding methods method requests with the pseudo receiver super request the prior overridden method with the given name from self Note that no search is involved super requests can be resolved statically unlike other method re que
27. ave higher or lower precedence that the other operators Michael and have precedence over and Each of those pairs has equal precedence internally Since you can t mix any other operators with them there is no need for a defined precedence lt Examples 14 2 3 evaluates to 6 1 2 3 evaluates to 7 1 2 3 evaluates to 9 1423 evaluates to 7 1 4 x 4 syntax error Named method requests without arguments bind more tightly than op erator method requests The following examples show the Grace expressions on the left and the parse on the right Examples 1 2 1 2 1 a x a b x b sqrt a x a b b sqrt a xa b b sqrt a a b xb sqrt axat tbxb a xa b xb a b c a b c a b c a b c 8 4 Unary Prefix Operator Requests Grace supports unary methods named by operator symbols that precede the explicit receiver Since binary operator methods must also have an explicit receiver there is no syntactic ambiguity Revision 1303 committed on 2013 10 17 22 42 57Z by black 17 Prefix operators bind less tightly than other method requests and there fore need parentheses to disambiguate Andrew gt This seems backwards in math prefix operators bind more tightly The statement above is also a non se quitur lt Michael gt This means that f x length f x length rather than f x length This is st
28. compasses multOp and addOp def operator rule otherOp reservedOp def unaryRequest rule trim identifier genericActuals not delimitedArgument def requestWithArgs rule firstRequestArgumentClause repsep requestArgumentClause opt ws def firstRequestArgumentClause rule identifier genericActuals opt ws delimitedArgument def requestArgumentClause rule identifier opt ws delimitedArgument def delimitedArgument rule argumentsInParens blockLiteral stringLiteral def argumentsInParens rule Paren replsep drop opt ws expression comma rParen def implicitSelfRequest rule requestWithArgs rep1sep unaryRequest dot def primaryExpression rule literal nonNakedSuper implicitSelfRequest parenExpression def parenExpression rule IParen replsep drop opt ws expression semicolon rParen TODO should parenExpression be around a codeSequence def nonNakedSuper rule superld not not operator Brack generics def genericActuals rule opt IGeneric opt ws replsep opt ws typeExpression opt ws opt ws comma opt ws opt ws rGeneric def genericFormals rule opt IGeneric rep1sep identifier comma rGeneric def whereClause rule repdel whereld typePredicate semicolon def typePredicate rule expression wherever genericFormals appear there should be a whereClause nearby literals
29. ctory object with the defini tion of a single object creation method on that object This method creates instances of the class A class declaration is syntactically a combination of an object literal and a method declaration everything in the body of the class declaration can be imagined as being part of an implicit object literal that is executed each time an instance of the class is created Examples class aCat ofColour c Colour named n String def colour Colour c def name String n var miceEaten 0 method eatMouse miceEaten miceEaten 1 print The Cat name has been created This declares a class binds it to the name aCat and declares an instance creation method on that class called ofColour named This method takes two arguments and returns a newly created object with the fields and meth ods listed Creating the object also has the side effect of printing the given string since executable code in the class declaration is also part of the im plicit object literal 12 Revision 1303 committed on 2013 10 17 22 42 57Z by black This class might be used as follows def fergus aCat ofColour Colour Tortoiseshell named Fergus This creates an object with fields colour set to Colour Tortoiseshell name set to Fergus and miceEaten initialized to 0 prints The Cat Fergus has been created and binds fergus to this object The above declaration for aCat is equivalent to the follow
30. def literal rule stringLiteral selfLiteral blockLiteral numberLiteral objectLiteral tupleLiteral typeLiteral def stringLiteral rule opt ws doubleQuote rep stringChar doubleQuote opt ws def stringChar rule drop backslash escapeChar anyChar space def blockLiteral rule Brace opt matchBinding blockFormals arrow innerCodeSequence rBrace def selfLiteral symbol self def numberLiteral trim DigitStringParser new def objectLiteral rule objectld IBrace inheritsClause codeSequence rBrace def tupleLiteral rule IBrack repsep expression comma rBrack def typeLiteral rule typeld opt ws nakedTypeLiteral Revision 1303 committed on 2013 10 17 22 42 57Z by black 43 def nakedTypeLiteral rule IBrace opt ws repdel methodHeader opt ws rBrace methodReturnType semicolon whereClause terminals def backslash token doesn t belong here doesn t work if left below def doubleQuote token def space token def semicolon rule symbol opt trim newLine def colon rule both symbol not assign def newLine symbol n def Paren symbol def rParen symbol def IBrace symbol def rBrace symbol def IBrack symbol def rBrack symbol def IrBrack symbol def arrow symbol gt def dot symbol def assign symbol def eq
31. doSomething the close method is automatically requested of the Closable when the block terminates 10 Equality and Value Objects All objects automatically implement the following non overridable methods option Library programmers are able to override these methods 1 and operators implemented as per Henry Baker s egal pred icate 2 That is immutable objects are egal if they are of the same shape have the same methods declared in the same lexical enviorn ments and if their fields contents are egal while mutable objects are only ever egal to themselves 2 hashcode compatible with the egal As a consequence immutable objects objects with no var fields which capture only other immutable objects act as pure value objects without identity This means that a Grace implementation can support value objects using whatever implementation is most efficient either passing by reference always by passing some times by value or even by inlining fields into their containing objects and updating the field if the containing object assigns a new value 11 Types Grace uses structural typing 7 Types primarily describe the re quests objects can answer Fields do not directly influence types except in so far as a field with publicly visible accessor methods cause those methods to be part of the type and in general to be visible to unconstrained clients Revision 1303 committed on 2013 10 17 22
32. e seem to have given up on the no shadowing rule The general rule for name lookup is that all paths are explored If two paths give same name then the using occurrence must be annotated with self or some number of outers to disambiguate the use lt Andrew can t see any reason to allow method or block temporaries and parameters to shadow variables from an enclosing lexical scope But method names are different programmers are not free to choose their own method names because they may have to implement a type Mini grace currently implements outer dynamically as a method that resolves to the enclosing object So I think that there is no way to explicitly refer to a shadowed name in an enclosing method lt 4 confirm super or other mechanism for requesting overridden methods 8 6 Kim gt We seem to have settled on super lt 4 5 confirm outer as meaning the object enclosing self Kim Current decision Kim gt My e mail to grace core raises issues with understanding outer Cur rently it is the self for the object enclosing the current self 6 update grammar to incude outer 8 7 7 confirm rules on named method argument parenthesization 8 how are mutually recursive names initialised 9 make the def keyword optional or remove it or return to const Kim gt No leave it as it is lt Revision 1303 committed on 2013 10 17
33. ences Kim 7 why lt Grammar top level def program rule codeSequence rep ws end def codeSequence rule repdel declaration statement semicolon def innerCodeSequence rule repdel innerDeclaration statement semicolon declarations def declaration rule varDeclaration defDeclaration classDeclaration typeDeclaration methodDeclaration def innerDeclaration rule varDeclaration defDeclaration classDeclaration 40 Revision 1303 committed on 2013 10 17 22 42 57Z by black typeDeclaration def varDeclaration rule varld identifier opt colon typeExpression opt assign expression def defDeclaration rule defld identifier opt colon typeExpression equals expression def methodDeclaration rule methodld methodHeader methodReturnType Brace innerCodeSequence rBrace def classDeclaration rule classld identifier dot classHeader methodReturnType Brace inheritsClause codeSequence rBrace whereClause whereClause def oldClassDeclaration rule classld identifier IBrace opt genericFormals blockFormals arrow codeSequence rBrace warning order here is significant def methodHeader rule accessingAssignmentMethodHeader accessingMethodHeader assignmentMethodHeader methodWithArgsHeader unaryMethodHeader operatorMethodHeader prefixMethodHeader def classHeader
34. es anything The case arguments are patterns objects that understand the request match and return a MatchResult which is either a SuccessfulMatch object or a FailedMatch object Each of the case patterns is requested to match x in turn until one of them returns SuccessfulMatch v the result of the whole match case construct is v 9 2 1 Patterns Pattern matching is based around the Pattern objects which are objects that respond to a request match anObject The pattern tests whether or not the argument to match matches the pattern and returns a MatchResult which is either a SuccessfulMatch or a FailedMatch An object that has type SuccessfulMatch behaves like the boolean true but also responds to the requests result and bindings An object that has type FailedIMatch behaves like the boolean false but also responds to the requests result and bindings Andrew gt This needs to be completed started using the information in the DLS paper but soon got confused The tone if not the content of much of what follows is not appropriate for the spec lt 4 result is the return value typically the object matched and the bindings are a list of objects that may be bound to intermediate variables generally used for destructuring objects For example in the scope of this Point type type Point x gt Number y gt Number extract gt List lt Number gt implemented by this class class aCar
35. eturn opt ws opt expression doesn t need parens def assignmentTail rule assign expression expressions def expression rule opExpression def opExpression rule rep1sep addExpression otherOp def opExpression rule this complex rule ensures two different otherOps have no precedence var otherOperator addExpression opt ws opt guard otherOp s gt otherOperator s true replsep addExpression opt ws guard otherOp s gt s otherOperator def addExpression rule replsep multExpression addOp def multExpression rule replsep prefixExpression multOp def prefixExpression rule rep otherOp selectorExpression rep1 otherOp superld we can have super def selectorExpression rule primaryExpression rep selector def selector rule dot unaryRequest dot requestWithArgs IBrack replsep expression comma rBrack 42 Revision 1303 committed on 2013 10 17 22 42 57Z by black def operatorChar CharacterSetParser new amp x gt lt had to be moved up special symbol for operators cannot be followed by another operatorChar method opsymbol s String trim token s not operatorChar def multOp opsymbol x opsymbol def addOp opsymbol opsymbol def otherOp rule guard trim rep1 operatorChar s gt parse s with reservedOp end en
36. explanation is repeated with every occurrence removed lt 4 Grace does not have private fields all fields can be accessed from sub objects However the parameters and temporary variables of constructor methods can be used to obtain an effect similar to privacy Examples method newShipStartingAt s Vector2D endingAt e Vector2D returns a battleship object extending from s to e This object cannot be asked its size or its location or how much floatation remains assert s x e x sy ey def size s distanceTo e var floatation size object method isHitAt shot Vector2D if shot onLineFrom s to e then floatation floatation 1 if floatation 0 then self sink true else false 8 10 Requesting Methods with Type Parameters Methods that have type parameters may be requested without explicit type arguments When a method declared with type parameters is requested in a statically typed context without explicit type arguments the type arguments are inferred Andrew gt We haven t defined statically typed context More recent Revision 1303 committed on 2013 10 17 22 42 57Z by black 21 thinking is that types are always inferred if not given explicitly the inferred types may be Dynamic lt Michael gt As discussed they cannot be inferred at all although a static type checker may pick a type to assume for itself internally Dynamically
37. g a to b gives a b Guillemets may be used for strings that don t support the interpolation feature Andrew gt not currently implemented lt 5 Blocks Grace blocks are lambda expressions they may or may not have parameters If a parameter list is present the parameters are separated by commas and the list is terminated by the gt symbol do something i gt i 1 sum next gt sum next Blocks construct objects containing a method named apply apply n apply n m depending on the number of parameters Requesting the apply method evaluates the block It is an error to provide the wrong number of arguments for 1 10 do i gt print i might be implemented as method for collection do block block apply collection at i Here is another example var sum 0 def summingBlock Block lt Number Number gt i Number gt sum sum i summingBlock apply 4 sum now 4 summingBlock apply 32 sum now 36 Blocks are lexically scoped inside their containing method or block A naked block literal that is a block literal that is neither the target of a method request nor an argument is a syntax error The body of a block consists of a sequence of declarations and expressions 8 Revision 1303 committed on 2013 10 17 22 42 57Z by black 6 Declarations Declarations of constants and variables may occur anywhere within an ob ject a me
38. he type args lmmutableCollection lt String gt Methods may be declared with type parameters in which case they must be requested with type arguments Andrew This contradicts which says that the type arguments are optional lt Type parameters may be constrained with where clauses Examples method pi 3 141592634 method greetUser print Hello World method other Point gt Point x other x y other y method other x other x y other y method other return x other x y other y method value n Number gt Done print value currently value now assigned n 10 Revision 1303 committed on 2013 10 17 22 42 57Z by black super value n method either a Block0 lt Done gt or b BlockO lt Done gt gt Done if random nextBoolean then a apply else b apply method print xargs Printable gt Done method sumSq lt T gt a T b T gt T where T lt Numeric a x a b b method prefix gt Number 0 self Andrew gt The where T lt Numeric should be T matches Numeric lt 7 Objects and Classes Grace object constructor expressions and declarations produce individual objects Grace provides class declarations to create classes of objects all of which have the same structure Grace s class and inheritance design is complete but tentative We need experience before confirming the des
39. ign 7 1 Objects Objects are created by object literals The body of an object literal consists of a sequence of declarations object def colour Colour Colour tabby def name String Unnamed var miceEaten 0 method eatMouse miceEaten miceEaten 1 Object literals are lexically scoped inside their containing method or block In particular any object level expressions initializer expressions and method bodies are executed in that lexical context Each time an object literal is executed a new object is created Object literals are expressions that evaluate to an object with the given features Object literals can also contain statements which are executed as Revision 1303 committed on 2013 10 17 22 42 57Z by black 11 a side effect of evaluating the object literal Thus constant can be defined by an object literal like this def unnamedCat object def colour Colour Colour tabby def name String Unnamed var miceEaten 0 method eatMouse miceEaten miceEaten 1 print The Cat name has been created to bind a name to an object Repeated invocations of the reader method unnamedCat return the same object Andrew gt Do all of the names declared in a scope come into existence simultane ously when that scope is first entered lt James gt That s the aim Minigrace does not do that lt 7 2 Classes Class declarations combine the definition of a fa
40. ing nested object declarations def aCat object a cat factory method ofColour c Colour named n String object the cat herself def colour Colour c def name String n var miceEaten 0 method eatMouse miceEaten miceEaten 1 print The cat name has been created If the programmer wants a factory object with more than one method she is free to build such an object using nested object constructors Kim Are the two definitions really equivalent We believe so lt 7 3 Inheritance Grace supports inheritance with single subclassing multiple subtyping like Java by way of an inherits C clause in a class declaration or object literal A new declaration of a method can override an existing declaration but overriding declarations must be annotated with is override Overrid den methods can be accessed via super calls see 48 6 It is a static error for a field to override another field or a method This example shows how a subclass can override accessor methods for a variable defined in a superclass in this case to always return 0 and to ignore assignments class aPedigreeCat ofColour aColour named aName inherits aCat ofColour aColour named aName var prizes 0 method miceEaten is override 0 method miceEaten n Number gt Number is override return ignore attempts to change it Revision 1303 committed on 2013 10 17 22 42 57Z by black 13 The right h
41. nheritsld classid objectld typeld whereld defld varld methodld prefixld interfaceld more to come def reservedOp rule assign equals dot arrow colon semicolon this is not quite right Revision 1303 committed on 2013 10 17 22 42 57Z by black 45 References 1 2 3 4 5 6 7 8 9 10 11 12 Eric Allen David Chase Joe Hallett Victor Luchangco Jan Willem Maessen Sukyoung Ryu Guy L Steele Jr and Sam Tobin Hochstadt The Fortress language specification version 1 05 Technical report Sun Microsystems Inc March 2007 Henry G Baker Equal rights for functional objects or the more things change the more they are the same OOPS Messenger 4 4 October 1993 Gavin M Bierman Erik Meijer and Mads Torgersen Lost in transla tion formalizing proposed extensions to Cf In OOPSLA 2007 Gavin M Bierman Erik Meijer and Mads Torgersen Adding dynamic types to Ct In ECOOP 2010 Andrew P Black Eric Jul Norman Hutchinson and Henry M Levy The development of the Emerald programming language In History of Programming Languages III ACM Press 2007 Gilad Bracha Newspeak programming language draft specification ver sion 0 0 Technical report Ministry of Truth 2009 Gilad Bracha and David Griswold Stongtalk Typechecking Smalltalk in a production environment In OOPSLA ACM Press 1993 Gilad Bracha Peter von der Ah
42. nothing Type GroundType Type amp Type Type Ground Type BasicType BasicType lt Type gt Selftype BasicType TypelD TypelD 11 13 Reified Type Information Metaobjects and Type Lit erals option Types are represented by objects of type Type Hmm should be Type lt T gt Since Grace has a single namespace so types can be accessed by requesting their names To support anonymous type literals types may be written in expressions type Type This expression returns the type metaobject representing the literal type Kim gt don t understand the need for this Can someone give an example 4 11 14 Type Assertions option Type assertions can be used to check conformance and equality of types assert B lt A B conforms to A assert B lt foo _ C gt D B had better have a foo method from C returning D assert B A C Revision 1303 committed on 2013 10 17 22 42 57Z by black 35 11 15 Notes 1 10 12 Sanity Check these rules Kim What s the relationship between type members across inheritance and subtyping Kim No variance in type definitions when inherit On matching How does destructuring match works What s the pro tocol Who defines the extractor method not sure why this is here Kim gt Doesn t this go back in matching section lt
43. of digits optionally preceded by a minus Revision 1303 committed on 2013 10 17 22 42 57Z by black 5 2 Explicit radix numerals written as a decimal number between 2 and 35 representing the radix a leading x and a string of digits where the digits from 10 to 35 are represented by the letters A to Z in either upper or lower case As a special case a radix of 0 is taken to mean a radix of 16 Explicit radix numerals may optionally be preceded by a minus 3 Base exponent numerals always in decimal which use e as the expo nent indicator Base exponent numerals may optionally be preceded by a minus Al literals evaluate to exact rational numbers explicit conversions such as f64 must be used to convert rationals to other objects Examples 1 1 42 3 14159265 13 343e 12 414 45e3 16xF00F00 2x10110100 Oxdeadbeef Radix zero treated as 16 4 2 Booleans The predefined constants true and false denote the only two values of Grace s Boolean type Boolean operators are written using amp amp for and for or and prefix for not Examples P amp amp Q toBe toBe not Short circuit a k a non commutative boolean operators take blocks as their second argument Examples 6 Revision 1303 committed on 2013 10 17 22 42 57Z by black P andAlso Q toBe orElse toBe 4 3 Strings and Characters String literals in Grace are written between double quotes Strings literals support a
44. om another class A then B s type should conform to A s type If A and B are parameterized classes then similar instantiatons of their types should conform Kim Need to reword and resolve what this means Could allow but make type checker work harder all the way up the inheritance chain or disallow This does not make it clear lt The conformance relationship is used in where clauses to constrain type parameters of classes and methods Kim Not really must define matches 11 5 Variant Types Variables with untagged retained variant types written T1 T2 Tn may refer to an object of any one of their component types No objects actually have variant types only expressions The actual type of an object referred to by a variant variable can be determined using that object s reified type information Andrew reworded the above Is it what we mean a The only methods that may be requested via a variant type are methods with exactly the same declaration across all members of the variant Option methods with different signatures may be requested at the most most specific argument types and least specific return type Kim f we choose this we should write it more carefully lt Variant types are retained as variants they are not equivalent to the object type which describes all common methods This is so that the ex haustiveness of match case statements can be
45. on think singleton objects must be self matching for this to work reliably The names of singleton objects typically declared in object declarations may be used as types Singleton types match only their singleton object Singleton typs can be distinguised from regular types because Grace type declarations are statically typed def null object method isNull gt Boolean return true type Some lt T gt thing gt T method isNull gt Boolean type Option lt T gt Some lt T gt null Kim Fixed type of thing above Correct Also changed from class to type as can t use classes as types 11 10 Nested Types Type definitions may be nested inside other expressions for example they may be defined inside object class method and other type definitions If they are defined inside object class and other type definitions they are accessed using dot notation written o T 34 Revision 1303 committed on 2013 10 17 22 42 57Z by black In this way a type may be used as a specification module Types may also be imported from modules since modules are objects 11 11 Additional Types of Types Option Grace may support exact types written Type option Grace probably will probably not support Tuple types probably written Tuple lt T1 T2 Tn gt Option Grace may support selftypes written Selftype 11 12 Syntax for Types This is very basic but hopefully better than
46. pes must distinguish Andrew something lt themselves syntactically from a variable declaration e g match rv case FailedMatch gt print failed case _ SuccessfulMatch gt print succeeded while writing just match rv case FailedMatch gt print failed case SuccessfulMatch gt print succeeded although closer to the type declaration less gratuitous and perhaps less error prone would result in two errors about variable shadowing Revision 1303 committed on 2013 10 17 22 42 57Z by black 27 Self Matching For this to work the main value types in Grace the main literals Strings Numbers must be patterns that match themselves That s what lets things like this work method fib n Number match n case 0 gt 0 case 1 gt 1 case _ gt fib n 1 fib n 2 With this design there is a potential ambiguity regarding Booleans true false as an expression is very different from true false as a com posite pattern Unfortunately if Booleans are Patterns then there s no way the type checker can distinguish these two cases If you want to match against objects that are not patterns you can lift any object to a pattern that matches just that object by writing e g LiteralPattern new o option or something shorter like a prefix Michael believe this description is all accurate lt
47. range of escape characters such as t b and also escapes for Unicode these are listed in Table I Individual characters are represented by Strings of length 1 Strings are immutable Grace values see 910 and so may be interned Strings conform to the protocol of an immutable Index ableCollection and Grace s standard library includes mechanisms to support efficient incremental string construction Escape Meaning Escape Meaning backslash iv single quote ya double quote b backspace n line feed r carriage return t tab l unicode NEL f page down e escape left brace Ap right brace space non breaking space Table 1 Grace string escapes Michael gt non breaking space really isn t an appropriate escape definition can t see why it s necessary but if anything it should be defined as a particular non breaking space probably U 00A0 should probably be U 2028 LINE SEPARATOR rather than U 0085 NEXT LINE which is largely an EBCDIC compatibility character lt Examples Hello World t The End of the Line n A 4 3 1 String interpolation Within a string literal expressions enclosed in braces are treated specially The expression is evaluated the asString method is requested on the resulting object and the resulting string is inserted into the string literal in place of the brace expression Revision 1303 committed on 2013 10 17 22 42 57Z by black 7 Examples Addin
48. rent language Dif ferent concurrency models may be provided as dialects Grace does not provide overall sequential consistency Rather Grace pro vides sequential consistency within a single thread Across threads any value that is read has been written by some thread sometime but Grace does not provide any stronger guarantee for concurrent operations that interfere Kim Semantics of language must be independent of the hardware specs Grace s memory model should support efficient execution on architec tures with Total Store Ordering TSO 13 Libraries Kim gt Need to put standard libraries in appendices lt 13 1 Collections Grace will support some collection classes Collections will be indexed 1 size by default bounds should be able to be chosen when explicitly instantiating collection classes Acknowledgements Thanks to Josh Bloch Cay Horstmann Micahel Kglling Doug Lea the participants at the Grace Design Workshops and the IFIP WG2 16 Pro gramming Language Design for discussions about the language design Thanks to Michael Homer and Ewan Tempero for their comments on drafts The Scala language specification 2 8 and the Newspeak language specification 0 05 6 were used as references for early versions of this docu ment The design of Grace so far has been influenced by Algol BS AmbientTalk 12 AspectJ 29 BCPL M2 Beta 33 Blue 32 C 28 C 44 Ct A B Dylan
49. rld size 8 2 Assignment Requests An assignment request is a variable followed by or it is a request of a method whose name ends with in each case followed by a single argument Spaces are optional before and after the Examples x 3 y 2 widget active true Assignment methods return Done 8 3 Binary Operator Requests Binary methods have a receiver and one argument Grace allows operator symbols to name binary methods but the receiver of a binary method must always be explicit A binary operator method is named by one or more operator characters provided that the operator is not a reserved symbol of the Grace language 16 Revision 1303 committed on 2013 10 17 22 42 57Z by black So for example and are valid operator symbols but is not because it is reserved Andrew This rules out as an operator Do we want to reconsider lt Most Grace operators have the same precedence it is a syntax error for two different operator symbols to appear in an expression without paren thesis to indicate order of evaluation The same operator symbol can be requested more than once without parenthesis such expressions are evalu ated left to right Four simple arithmetic operators do have precedence and over and James gt James and Andrew hate this exception with a vengeance but understand why it is here lt Andrew Do and h
50. rscore _ acts as a placeholder identifier it is treated as a fresh identifier everywhere it is used 3 4 Reserved Words and Reserved Operators Grace has the following reserved words and reserved operators The indi cates words related to design options not yet chosen class def inherits is method object outer prefix return self Selftype super type var where SSS gt James gt we should decide how to handle these properly esp names always defined in the standard library true false etc lt 3 5 Tabs and Control Characters Newline can be represented by the unicode newline character by carriage return or by line feed a line feed that immediately follows a carriage return is ignored Tabs and all other non printing control characters except carriage re turn line feed and line separator are syntax errors even in a string literal There are escape sequences for including special characters in string liter als 4 Built in Objects 4 1 Numbers Grace supports a single type Number Number supports at least 64 bit pre cision floats Andrew gt Inconsistent with statement that follows about literals evaluating to exact rationals Implementations may support other numeric types a full specification of numeric types is yet to be completed Grace has three syntactic forms for numerals that is literals that denote Numbers 1 Decimal numerals written as strings
51. sts 18 Revision 1303 committed on 2013 10 17 22 42 57Z by black Examples super value super bar 1 2 6 super doT his 3 timesTo foo super 1 Isuper foo super syntax error 1 super syntax error 8 7 Outer Requests The reserved word outer denotes the object enclosing self it is an error if there is no such enclosing object Moreover outer outer denotes the object enclosing outer and so on for as many outers as there are enclosing objects Andrew minigrace recognizes outer as a method that can be requested of any object and that answers a reference to its enclosing object Do we want to support this lt Examples outer outer value outer bar 1 2 6 outer outer doThis 3 times To foo outer 1 louter 8 8 Encapsulation Grace has different default encapsulation rules for methods and fields The defaults can be changed by explicit annotations The details are as follows 8 8 1 Methods By default methods are public which means that they can be requested by any client that has access to the object Thus any expression can be the target of a request for a public method If a method is annotated is confidential it can be requested only on the target self or super This means that such a method is accessible to the object that contains it and to inheriting objects but not to client objects Revision 1303 committed on 2013 10 17 22 42 57Z by black 19 Andrew gt Here
52. tesianPoint x x Number y y Number gt Point method x x method y y method extract aList with x y these hold def cp aCartesianPoint new 10 20 24 Revision 1303 committed on 2013 10 17 22 42 57Z by black Point match cp result returns cp Point match cp bindings returns an empty list Point match true returns FailedMatch 9 2 2 Matching Blocks Blocks with a single parameter are also patterns they match any object that can validly be bound to that parameter For example if the parameter is annotated with a type the block will successfully match an object that has that type and will fail to match other objects Matching blocks support an extended syntax for their parameters In addition to being a fresh variable as in a normal block the parameter may also be a pattern Matching blocks are themselves patterns one argument Andrew Here gave up lt matching block with parameter type A and return type R also implements Pattern lt R Done gt A recursive syntax directed translation maps matching blocks into blocks with separate explict patterns non matching blocks that are called via apply only when their patterns match First the matching block is flattened translated into a straightforward non matching block with one parameter for every bound name or place holder For example _ Pair a Pair b c gt a b c is flattened into a b c gt a b
53. thod or a block their scope is the whole of their defining object method or block Grace has a single namespace for all identifiers this shared namespace is used for methods constants variables and types It is an error to declare a constant or variable that shadows a lexically enclosing constant or variable 6 1 Constants Constant definitions are introduced using the def keyword they bind an identifier to the value of an initialising expression optionally at a precise type Constants cannot be re bound Examples def x 3 x 100 0 01 def x Number 3 means the same as the above def x Number Syntax Error x must be initialised 6 2 Variables Variable definitions are introduced using the var keyword they optionally bind an identifier to the value of an initialising expression optionally at a precise type Variables can be re bound to new values as often as desired using an assignment statement If a variable is declared without an initializ ing expression it is said to be uninitialized any attempt to access the value of an initialized variable is an error This error may be caught either at run time or at compile time depending on the cleverness of your implementor Examples var x Rational 3 explicit type var x Rational ok x must be initialized before being referenced var x 3 x has type dynamic var x x is uninitialised and dynamic 6 3 Methods Methods are declared with the method keyword
54. thod miceEaten n Number return ignore attempts to change it object method object Andrew gt This translation is confusing because it re writes both the class syntax and the inheritance syntax suggest that we do these one at a time in the appropriate places lt 4 14 Revision 1303 committed on 2013 10 17 22 42 57Z by black 7 5 Parameterized Classes Classes may optionally be declared with type parameters The correspond ing requests on the factory methods may optionally be provided with type arguments Type parameters may be constrained with where clauses Examples class aVector ofSize size lt T gt var contents Array size size method at index Number gt T return contents at method at index Number put elem T class aSortedVector ofSize lt T gt where T lt Comparable lt T gt Andrew gt That last lt needs to be a matches I think lt 8 Method Requests Grace is a pure object oriented language Everything in the language is an object and all computation proceeds by requesting an object to execute a method with a particular name The response of the object is to execute the method We distinguish the act of requesting a method what Smalltalk calls sending a message and executing that method Requesting a method involves only the object receiving the request the method name and possibly some arguments In contrasty
55. uals symbol def IGeneric token lt def rGeneric token gt def comma rule symbol def escapeChar CharacterSetParser new bnrtlfe def azChars abcdefghijklmnopqrstuvwxyz def AZChars ABCDEFGHIJKLMNOPQRSTUVWXYZ def otherChars 12345678907 0 amp _ lt gt def anyChar CharacterSetParser new azChars AZChars otherChars def identifierString trim GraceldentifierParser new def identifier rule bothAll trim identifierString not reservedidentifier bothAll ensures parses take the same length def identifier rule both identifierString not reservedidentifier both doesn t ensure parses take the same length def identifier rule guard identifierString s gt parse s with reservedidentifier end probably works but runs out of stack anything in this list needs to be in reservedidentifier below or it won t do what you want def superld symbol super def extendsld symbol extends def inheritsld symbol inherits def classld symbol class def objectld symbol object def typeld symbol type def whereld symbol where def defld symbol def def varld symbol var def methodld symbol method def prefixld symbol prefix 44 Revision 1303 committed on 2013 10 17 22 42 57Z by black def interfaceld symbol interface def reservedidentifier rule selfLiteral superld extendsld i
56. wold An overview of AspectJ In ECOOP 2001 30 Michael Kolling Bett Koch and John Rosenberg Requirements for a first year object oriented teaching language In ACM Conference on Computer Science Education SIGCSE 1995 31 Michael K lling and John Rosenberg Blue a language for teaching object oriented programming In ACM Conference on Computer Sci ence Education SIGCSE 1996 32 Michael K lling and John Rosenberg Blue a language for teach ing object oriented programming language specification Technical Re port TR97 13 Monash University Department of Computer Science and Software Engineering 1997 33 Ole Lehrmann Madsen Birger Meller Pedersen and Kristen Nygaard Object Oriented Programming in the BETA Programming Language Addison Wesley 1993 34 Donna Malayeri and Jonathan Aldrich Integrating nominal and struc tural subtyping In ECOOP 2008 35 Bertrand Meyer Object oriented Software Construction Prentice Hall 1988 36 Bertrand Meyer Eiffel The Language Prentice Hall 1992 37 Robin Milner Mads Tofte and Robert Harper The Definition of Stan dard ML MIT Press 1990 38 Peter Naur The European side of the development of ALGOL In History of Programming Languages I pages 92 139 ACM Press 1981 39 Martin Odersky The Scala language specification version 2 8 Technical report Programming Methods Laboratory EFPL July 2010 48 40 41 42 43 44
57. yTypeExpression semicolon whereClause def typeExpression rule opt ws typeOpExpression opt ws opt ws def nonEmptyTypeExpression rule opt ws typeOpExpression opt ws def typeOp rule opsymbol opsymbol amp opsymbol def typeOpExpression rule replsep basic TypeExpression typeOp def typeOpExpression rule this complex rule ensures two different typeOps have no precedence var otherOperator Revision 1303 committed on 2013 10 17 22 42 57Z by black 41 basicTypeExpression opt ws opt guard typeOp s gt otherOperator s true replsep basicTypeExpression opt ws guard typeOp s gt s otherOperator def basicTypeExpression rule nakedTypeLiteral literal pathTypeExpression parenTypeExpression if we keep this note that in a typeExpression context a is interpreted as type a otherwise as the block a def pathTypeExpression rule opt superld dot replsep identifier genericActuals dot def parenTypeExpression rule IParen typeExpression rParen statements def statement rule returnStatement expression opt assignmentTail do we need constraints here on which expressions can have an assignment Tail could try to rewrite as options including expression arrayAccess assignment Tail expression dot identifier assignmentTail def returnStatement rule symbol r
Download Pdf Manuals
Related Search