Changes between Initial Version and Version 1 of Interface

Timestamp:

05/14/10 06:58:02 (15 years ago)

Author:

hopscc

Comment:

--

Interface

@@ +1 @@
+= Interface Definition =
+
+An interface defines a feature set or related functionality as a small group of 
+properties, methods, and events.
+
+A class or struct '''implementing''' an interface provides a concrete implementation for 
+all of the members defined by that interface.  
+
+An Interfaces members are automatically public.
+
+The interface itself provides no functionality (implementation) that a class or struct 
+can inherit the way that base class functionality can be inherited. 
+(Instead see [wiki:Mixins mixins])[[BR]]
+However, if a base class implements an interface, any derived class inherits that
+implementation (and thus continues to implement that interface).
+
+    * An interface is like an abstract base class:[[BR]] 
+      any non-abstract type inheriting the interface must implement all its members.
+    * An interface cannot be instantiated directly.
+    * Interfaces contain no implementation of methods or properties.
+    * An Interface cannot contain fields.  
+    * Classes and structs can inherit from more than one interface.
+    * An interface can itself inherit from multiple interfaces.
+
+
+In Cobra, Interfaces are declared using the '''interface''' keyword followed by the 
+interface name. [[BR]]
+The interface  may have any of the usual [wiki:AccessModifiers access modifiers] and
+interface hierarchies (!SuperInterfaces) can be specified using '''inherits'''
+
+Interfaces can have attributes and may be declared as generic with constraints.
+
+Use of a docstring on Interfaces is encouraged.
+
+
+=== Interface Grammar ===
+{{{
+# The grammar elements below are ordered for simplicity but the compiler will accept 
+# those elements in any reasonable order.
+
+interface <InterfaceName>  
+    [is <AccessModifiers>]
+    [has <Attributes>]
+    [where <GenericParam> must be <GenericConstraints>]
+    [inherits <BaseInterfaceName> [, <BaseInterfaceName>]... ]
+    [<DocString>]
+
+    [ 
+        [<Properties>]
+        [<Methods>
+        [<Events>]
+}}}
+
+== Example ==
+
+This example declares an interface, IDimensions, and a class, Box,[[BR]]
+which explicitly implements the interface members getLength and getWidth.
+
+The members are accessed through the interface instance dimensions.
+{{{
+interface IDimensions
+    """ Interface for Dimensions of a 2D object"""
+    def getLength as float
+    def getWidth as float
+
+class Box implements IDimensions
+    var lengthInches as float
+    var widthInches as float
+
+    cue init length as float, width as float)
+        .lengthInches = length
+        .widthInches = width
+
+    # Explicit interface member implementation: 
+    def getLength as float
+        return .lengthInches
+        
+    def getWidth as float
+        return .widthInches
+
+    def main is shared
+        #// Declare a class instance box1:
+        box1 = Box(30.0f, 20.0f)
+
+        #// Declare an interface instance dimensions:
+        dimensions = box1 to IDimensions
+
+        #// Print out the dimensions of the box by calling the methods 
+        #// from an instance of the interface:
+        print 'Length: [dimensions.getLength]'
+        print 'Width:  [dimensions.getWidth]'
+    }
+}
+/# Output:
+    Length: 30
+    Width: 20
+#/
+
+}}}
+
+
+
+Using generics
+{{{
+interface IEquatable<of T>
+    """Interface for an object that can tell if it is equal to other objects of the same type"""
+    def equals(obj as T) as bool
+
+
+class Car implements  IEquatable<of Car>
+    pro make as String
+    pro model as String
+    pro year as String
+
+    #// Implementation of IEquatable<of T> interface
+    def equals(car as Car) as bool
+        if .make == car.make and .model == car.model and .year == car.year
+            return true
+        return false
+}}}
+
+
+== Notes ==