View difference between Paste ID: h5cuvm1P and zPcMFMG8

 struct Point {
     x:  int,
     y:  int
 }
 
 impl Point {
     fn neighbors() -> ~[Point] {
         return ~[Point { x: self.x - 1, y: self.y - 1 },
                  Point { x: self.x    , y: self.y - 1 },
                  Point { x: self.x + 1, y: self.y - 1 },
                  Point { x: self.x + 1, y: self.y     },
                  Point { x: self.x + 1, y: self.y + 1 },
                  Point { x: self.x    , y: self.y + 1 },
                  Point { x: self.x - 1, y: self.y + 1 },
                  Point { x: self.x - 1, y: self.y     }];
     }
 }
 
 struct LifeMap {
     width:  int,
     height: int,
     data:   ~[mut bool]
 }
 
 fn LifeMap(width: int, height: int) -> ~LifeMap {
     return ~LifeMap {
         width:  width,
         height: height,
         data:   vec::to_mut(vec::from_elem((width * height) as uint, false))
     };
 }
 
 impl LifeMap {
     fn get(p: &Point) -> bool {
         let wx = (p.x + self.width) % self.width;
         let wy = (p.y + self.height) % self.height;
 
         return self.data[(wy * self.width) + wx];
     }
 
     fn set(p: &Point, v: bool) {
         let wx = (p.x + self.width) % self.width;
         let wy = (p.y + self.height) % self.height;
 
         self.data[(wy * self.width) + wx] = v;
     }
 
     fn live_neighbors(p: &Point) -> int {
         let mut count = 0;
 
         for vec::each(p.neighbors()) |n| {
             if self.get(n) {
                 count += 1;
             }
         }
 
         return count;
     }
 
     fn survives(p: &Point) -> bool {
         let n = self.live_neighbors(p);
 
         if self.get(p) {
             match n {
                 2 | 3 => true,
                 _ => false
             }
         } else {
             match n {
                 3 => true,
                 _ => false
             }
         }
     }
 
     fn render() {
         for int::range(0, self.height) |y| {
             for int::range(0, self.width) |x| {
-                if self.get(&Point { x: x, y: y }) {
+                match self.get(&Point { x: x, y: y }) {
-                    io::print("*");
+                    true => io::print("*"),
-                } else {
+                    false => io::print("-")
-                    io::print("-");
+
             }
             io::print("\n");
         }
         io::print("\n");
     }
 }
 
 fn evolve(curr: &LifeMap, next: &LifeMap) {
     for int::range(0, curr.height) |y| {
         for int::range(0, curr.width) |x| {
             let p = Point { x: x, y: y };
             match curr.survives(&p) {
-            if curr.survives(&p) {
+                true => next.set(&p, true),
-                next.set(&p, true);
+                false => next.set(&p, false)
-            } else {
+
-                next.set(&p, false);
+
     }
 }
 
 fn main() {
     let mut curr = LifeMap(4, 4);
     let mut next = LifeMap(4, 4);
 
     curr.set(&Point { x: 1, y: 1 }, true);
     curr.set(&Point { x: 2, y: 1 }, true);
     curr.set(&Point { x: 3, y: 1 }, true);
 
     for 4.times {
         curr.render();
         evolve(curr, next);
         curr <-> next;
     }
 }