added a couple things, cleaned up some `use` statements

tutorial1/src/main.rs

@@ -10,6 +10,12 @@ extern crate rand;
 use rand::Rng;
 
 
+// I think you can `use` stuff internal to this file, which makes
+// some things much easier
+
+use self::Peano::*;
+use self::MyOption::*;
+
 // record types
 struct Point {
     x: i32,
@@ -50,9 +56,6 @@ enum MyOption<TypeT> {
 // does (x:MyOption<TypeName>)
 // using i32 to get it to compile
 fn nullalgebraicdatatypes(x:MyOption<i32>) -> bool {
-    // have to import the constructor names?
-    use MyOption::MyNone;
-    use MyOption::MySome;
     match x {
         MyNone     => false,
         MySome(_)  => true
@@ -60,6 +63,10 @@ fn nullalgebraicdatatypes(x:MyOption<i32>) -> bool {
 }
 
 
+
+
+
+
 // lambda expressions & higher-order functions
 
 // ||int,int| -> int, int| -> int
@@ -102,16 +109,10 @@ enum Peano {
     Succ(Box<Peano>)
 }
 
-impl PartialEq for Box<Peano> {
-    fn eq(&self, other:&Box<Peano>) -> bool {
-        (self.deref() == other.deref())
-    }
-}
-
+// == and != are implemented as `eq` and `ne` in the std::cmp::PartialEq trait
+//
 impl PartialEq for Peano {
     fn eq(&self, other:&Peano) -> bool {
-        use Peano::PZero;
-        use Peano::Succ;
         match (self, other) {
             (&PZero, &PZero)             => true,
             (&Succ(ref a), &Succ(ref b)) => (a == b),
@@ -120,11 +121,16 @@ impl PartialEq for Peano {
     }
 }
 
-trait PartialEq {
-    fn eq(&self, other:&Self) -> bool;
-    fn ne(&self, other:&Self) -> bool
-    { ! self.eq(other) }
-}
+// also see std::cmp::PartialOrd
+// and the various traits in std::ops::*
+//              .::Add, .::Sub, .::Mul, .::Div, .::Rem (remainder -- %),
+//              .::Neg, .::Not, .::Deref (dereference -- *),
+//              .::BitAnd, .::BitOr, .::BitXor, // (&, |, and ^, respectively)
+//              .::Shl, .::Shr  // (shift left and right -- << and >>)
+
+// for loops use std::iter::Iterator, which implements next (which returns Option)
+
+
 
 
 // function types and definitions
@@ -171,6 +177,25 @@ fn collatz(n:i32) {
 }
 
 
+// references
+
+struct Pt { x:f32, y:f32 }
+
+fn distval(p1:Pt, p2:Pt) -> f32 {
+    let xd = p1.x - p2.x;
+    let yd = p1.y - p2.y;
+    (xd * xd + yd * yd).sqrt()
+}
+
+// body is the same, only type signature is different
+// (also how you call it is different)
+fn distref(p1:&Pt, p2:&Pt) -> f32 {
+    let xd = p1.x - p2.x;
+    let yd = p1.y - p2.y;
+    (xd * xd + yd * yd).sqrt()
+}
+
+
 // playground
 
 fn main() {
@@ -191,5 +216,16 @@ fn main() {
         println!("{}, {}", i, fact(i))
     }
 
+
+    let a = Pt { x:1.0, y:2.0 };
+    let b = Pt { x:0.0, y:3.0 };
+
+    // have to call in this order, unless I implement
+    // the Copy trait for Pt
+    println!("{}", distref(&a, &b));
+    // because this 'moves' a and b, so they are no longer
+    // in scope, and you get
+    // "use of moved value: `a`"
+    println!("{}", distval(a, b));
 }