update examples on homepage

src/tests/site/code/syntax.dart

Index: src/tests/site/code/syntax.dart
diff --git a/src/tests/site/code/syntax.dart b/src/tests/site/code/syntax.dart
new file mode 100644
index 0000000000000000000000000000000000000000..4abdd7187162ae42e2c879e0414c8eed3c3dad47
--- /dev/null
+++ b/src/tests/site/code/syntax.dart
@@ -0,0 +1,23 @@
+import 'dart:html';                   // Dart supports libraries.
+
+// Define functions either inside or outside of classes.
+startOrEndTest() {
+  // ...
+}
+
+class Rectangle implements Shape {    // Declaring a class...
+  final num height, width;            // ...with properties.
+  num get area => height * width;     // A property implemented with a getter.
+                                      // Also: function shorthand syntax (=>).
+  Rectangle(this.height, this.width); // Compact constructor syntax.
+}
+
+// Every app has a main() function, where execution starts.
+main() {
+  // The cascade operator (..) saves you from repetitive typing.
+  query("#button")
+    ..text = "Run test"
+    ..onClick.listen(startOrEndTest);

[sethladd, 2013/08/08 19:00:32]

can we connect this to the rectangle class? As this stands, the poor old
Rectangle is getting no love.

If you want to show libraries, don't use dart:html, try another like
dart:convert. That way, all the code in here is cohesive and runnable.

[Kathy Walrath, 2013/08/08 23:16:59]

Any ideas for a good example that uses cascades? I suppose I could make
rectangle non-final. Or maybe make it an ellipse, which will require importing
dart:math for various calculations. Maybe something like this:

import 'dart:math';                  // Importing a library.

// Define functions either inside or outside of classes.
createGoldenEllipse(width) =>        // Function shorthand syntax (=>)
    new Ellipse(width, width*(1 + sqrt(5))/2);

class Ellipse implements Shape {     // Declaring a class.
  num width = 0;                     // With a property.
  num height = 0;                    // And another property.
  num get area => PI*width*height/4; // A property implemented with a getter.
  
  Ellipse(this.width, this.height);  // Compact constructor syntax.
  Ellipse.empty();                   // Named constructor.
  Ellipse.circle(num size) {         // Constructor with a body.
    width = height = size;
  }
  
  // Overriding Object's toString() method.
  String toString() => 'Ellipse: ${width}x${height} ($area)';
}

// Every app has a main() function, where execution starts.
main() {
  print(createGoldenEllipse(1));
  
  // The cascade operator (..) saves you from repetitive typing.
  var imperfectEllipse = createGoldenEllipse(1)
    ..width = 20
    ..height *= 10;
  
  print(imperfectEllipse);
}

abstract class Shape {
  num height;
  num width;
  num get area;
}

On 2013/08/08 19:00:32, sethladd wrote:

[sethladd, 2013/08/08 23:43:12]

should createGoldenEllipse be a named constructor?

how about give a color and a rotation as fields on Shape, so you can cascade
those?

Your top-level function could add shapes to a top-level list of shapes. (bonus:
you can show off a real list collection)

Thoughts?

[Kathy Walrath, 2013/08/08 23:51:59]

Actually, I played with a List<Shape> but wasn't sure I wanted to get into
generics...

OK, I'll play around with it some more.

+}
+
+class Shape {}