remove semicolons

beat.ayin

@@ -10,16 +10,16 @@ let setup = fn() {
 	  .b: 0,
 	},
 	.dir: 1,
-  };
+  }
 }
 
 let update = fn(state, input) {
-  let dir = state.dir * speed * get_frame_time();
+  let dir = state.dir * speed * get_frame_time()
-  state.color.g = random_u8() % 1;
+  state.color.g = random_u8() % 1
-  state.color.r = (state.color.r + dir) % max;
+  state.color.r = (state.color.r + dir) % max
   if state.color.r < min {
-    state.color.r = min;
+    state.color.r = min
-  };
+  }
   state.dir =
     if state.color.r >= (max - 1) {
 	  -1
@@ -29,12 +29,12 @@ let update = fn(state, input) {
       } else {
 	    state.dir
 	  }
-	};
+  }
-  return state;
+  return state
 }
 
 let draw = fn(state) {
-  frame_clear(state.color.r, state.color.g, state.color.b);
+  frame_clear(state.color.r, state.color.g, state.color.b)
 }
 
 let migrate = fn(state) {

colorgame.ayin

@@ -20,7 +20,7 @@ let setup = fn() {
         .speed: 150,
 	  },
 	},
-  };
+  }
 }
 
 let migrate = fn(state) {
@@ -28,61 +28,61 @@ let migrate = fn(state) {
 }
 
 let update = fn(state, input) {
-  let delta = get_frame_time();
+  let delta = get_frame_time()
 
-  let dpad_x = if input.gamepad1.dpad.right { 1 } else { 0 } + if input.gamepad1.dpad.left { -1 } else { 0 };
+  let dpad_x = if input.gamepad1.dpad.right { 1 } else { 0 } + if input.gamepad1.dpad.left { -1 } else { 0 }
-  let dpad_y = if input.gamepad1.dpad.down  { 1 } else { 0 } + if input.gamepad1.dpad.up   { -1 } else { 0 };
+  let dpad_y = if input.gamepad1.dpad.down  { 1 } else { 0 } + if input.gamepad1.dpad.up   { -1 } else { 0 }
 
   # let movement = {
   #   .x: input.gamepad1.sticks.left.x + dpad_x,
   #   .y: input.gamepad1.sticks.left.y + dpad_y,
-  # };
+  # }
   let movement = {
     .x: dpad_x,
     .y: dpad_y,
-  };
+  }
 
   state.rect.dimensions.x =
-    state.rect.dimensions.x + (delta * state.rect.speed * movement.x);
+    state.rect.dimensions.x + (delta * state.rect.speed * movement.x)
   state.rect.dimensions.y =
-    state.rect.dimensions.y + (delta * state.rect.speed * movement.y);
+    state.rect.dimensions.y + (delta * state.rect.speed * movement.y)
 
   let color = {
     .r: state.rect.color.r + (input.gamepad1.sticks.right.x * delta * state.rect.color.speed),
     .g: state.rect.color.g + ((0 - input.gamepad1.sticks.right.y) * delta * state.rect.color.speed),
     .b: state.rect.color.b + ((0 - input.gamepad1.sticks.left.y) * delta * state.rect.color.speed),
-  };
+  }
 
-  state.rect.color.r = if ((0 <= color.r) && (color.r <= 255)) { color.r } else { if color.r < 0 { 0 } else { 255 } };
+  state.rect.color.r = if ((0 <= color.r) && (color.r <= 255)) { color.r } else { if color.r < 0 { 0 } else { 255 } }
-  state.rect.color.g = if ((0 <= color.g) && (color.g <= 255)) { color.g } else { if color.g < 0 { 0 } else { 255 } };
+  state.rect.color.g = if ((0 <= color.g) && (color.g <= 255)) { color.g } else { if color.g < 0 { 0 } else { 255 } }
-  state.rect.color.b = if ((0 <= color.b) && (color.b <= 255)) { color.b } else { if color.b < 0 { 0 } else { 255 } };
+  state.rect.color.b = if ((0 <= color.b) && (color.b <= 255)) { color.b } else { if color.b < 0 { 0 } else { 255 } }
-  return state;
+  return state
 }
 
 let draw = fn(state) {
-  frame_clear(state.color.r, state.color.g, state.color.b);
+  frame_clear(state.color.r, state.color.g, state.color.b)
-  draw_rectangle(state.rect.dimensions, state.rect.color);
+  draw_rectangle(state.rect.dimensions, state.rect.color)
 
-  let mut count = 0;
+  let mut count = 0
-  let r_diff = state.color.r - state.rect.color.r;
+  let r_diff = state.color.r - state.rect.color.r
-  let g_diff = state.color.g - state.rect.color.g;
+  let g_diff = state.color.g - state.rect.color.g
-  let b_diff = state.color.b - state.rect.color.b;
+  let b_diff = state.color.b - state.rect.color.b
-  let epsilon = 2;
+  let epsilon = 2
 
-  if ((0 - epsilon) < r_diff) && (r_diff < epsilon) { count = count + 1; };
+  if ((0 - epsilon) < r_diff) && (r_diff < epsilon) { count = count + 1 }
-  if ((0 - epsilon) < g_diff) && (g_diff < epsilon) { count = count + 1; };
+  if ((0 - epsilon) < g_diff) && (g_diff < epsilon) { count = count + 1 }
-  if ((0 - epsilon) < b_diff) && (b_diff < epsilon) { count = count + 1; };
+  if ((0 - epsilon) < b_diff) && (b_diff < epsilon) { count = count + 1 }
 
   if count == 0 {
-     draw_text("Match the colors", 70, 80, 30, { .r: 255, .g: 255, .b: 255 });
+     draw_text("Match the colors", 70, 80, 30, { .r: 255, .g: 255, .b: 255 })
-  };
+  }
   if count == 1 {
-     draw_text("Close", 200, 200, 50, { .r: 255, .g: 255, .b: 255 });
+     draw_text("Close", 200, 200, 50, { .r: 255, .g: 255, .b: 255 })
-  };
+  }
   if count == 2 {
-     draw_text("Closer!!", 200, 200, 50, { .r: 255, .g: 255, .b: 255 });
+     draw_text("Closer!!", 200, 200, 50, { .r: 255, .g: 255, .b: 255 })
-  };
+  }
   if count == 3 {
-     draw_text("Great Job!", 200, 200, 50, { .r: 255, .g: 255, .b: 255 });
+     draw_text("Great Job!", 200, 200, 50, { .r: 255, .g: 255, .b: 255 })
-  };
+  }
 }

game.ayin

@@ -46,168 +46,168 @@ let setup = fn() {
     },
     .timer: 0,
     .status: "ongoing",
-  };
+  }
 }
 
 let move_player = fn(state, input) {
-  let delta = get_frame_time();
+  let delta = get_frame_time()
 
-  let dpad_x = if input.gamepad1.dpad.right { 1 } else { 0 } + if input.gamepad1.dpad.left { -1 } else { 0 };
+  let dpad_x = if input.gamepad1.dpad.right { 1 } else { 0 } + if input.gamepad1.dpad.left { -1 } else { 0 }
-  let dpad_y = if input.gamepad1.dpad.down  { 1 } else { 0 } + if input.gamepad1.dpad.up   { -1 } else { 0 };
+  let dpad_y = if input.gamepad1.dpad.down  { 1 } else { 0 } + if input.gamepad1.dpad.up   { -1 } else { 0 }
 
   let movement = {
     .x: input.gamepad1.sticks.left.x + dpad_x,
     .y: input.gamepad1.sticks.left.y + dpad_y,
-  };
+  }
 
   state.player.pos.x =
     max(0,
       min( state.player.pos.x + ((delta * state.player.speed * movement.x) / state.player.shot)
        , screen_size - dim.w
        )
-  );
+  )
   state.player.pos.y =
     max(0,
       min( state.player.pos.y + ((delta * state.player.speed * movement.y) / state.player.shot)
        , screen_size - dim.w
        )
-    );
+    )
 }
 
 let move_opponent = fn(state) {
-  let delta = get_frame_time();
+  let delta = get_frame_time()
 
   let opponent_movement = {
     .x: if abs(state.opponent.pos.x - state.player.pos.x) < 5 { 0 } else { if state.opponent.pos.x < state.player.pos.x { 1 } else { -1 } },
     .y: if abs(state.opponent.pos.y - state.player.pos.y) < 5 { 0 } else { if state.opponent.pos.y < state.player.pos.y { 1 } else { -1 } },
-  };
+  }
 
   state.opponent.pos.x =
     max(0,
       min( state.opponent.pos.x + (delta * state.opponent.speed * opponent_movement.x)
        , screen_size - dim.w
        )
-  );
+  )
   state.opponent.pos.y =
     max(0,
       min( state.opponent.pos.y + (delta * state.opponent.speed * opponent_movement.y)
        , screen_size - dim.w
        )
-    );
+  )
 
-   shoot_bullets(state, opponent_movement);
+   shoot_bullets(state, opponent_movement)
 }
 
 let shoot_bullets = fn(state, opponent_movement) {
-  let delta = get_frame_time();
+  let delta = get_frame_time()
 
-  state.opponent.timer = state.opponent.timer - 1;
+  state.opponent.timer = state.opponent.timer - 1
   if (state.opponent.timer <= 0) && (state.status != "caught") {
-    state.opponent.timer = shoot_timer;
+    state.opponent.timer = shoot_timer
 
-    state.bullets.pos.x = state.opponent.pos.x + (dim.w * opponent_movement.x);
+    state.bullets.pos.x = state.opponent.pos.x + (dim.w * opponent_movement.x)
-    state.bullets.pos.y = state.opponent.pos.y + (dim.h * opponent_movement.y);
+    state.bullets.pos.y = state.opponent.pos.y + (dim.h * opponent_movement.y)
-    state.bullets.movement.x = opponent_movement.x;
+    state.bullets.movement.x = opponent_movement.x
-    state.bullets.movement.y = opponent_movement.y;
+    state.bullets.movement.y = opponent_movement.y
-  };
+  }
 
 }
 
 let move_bullets = fn(state) {
-  let delta = get_frame_time();
+  let delta = get_frame_time()
 
   state.bullets.pos.x =
-      state.bullets.pos.x + (delta * state.bullets.speed * state.bullets.movement.x);
+      state.bullets.pos.x + (delta * state.bullets.speed * state.bullets.movement.x)
   state.bullets.pos.y =
-      state.bullets.pos.y + (delta * state.bullets.speed * state.bullets.movement.y);
+      state.bullets.pos.y + (delta * state.bullets.speed * state.bullets.movement.y)
 }
 
 let update = fn(state, input) {
-  let delta = get_frame_time();
+  let delta = get_frame_time()
 
   if state.status != "caught" {
-    state.timer = state.timer + delta;
+    state.timer = state.timer + delta
-  };
+  }
 
   if state.status == "ongoing" {
-    move_player(state, input);
+    move_player(state, input)
-  };
+  }
 
   if state.player.shot_timer > 0 {
-    state.player.shot_timer = state.player.shot_timer - delta;
+    state.player.shot_timer = state.player.shot_timer - delta
   } else {
-    state.player.shot_timer = 0;
+    state.player.shot_timer = 0
-  };
+  }
 
-  move_opponent(state);
+  move_opponent(state)
-  move_bullets(state);
+  move_bullets(state)
 
   if is_touching(make_rect(state.bullets.pos, { .w: dim.w / 2, .h: dim.h / 2 }), make_rect(state.player.pos, dim)) && (state.player.shot_timer == 0) {
-    state.player.shot = state.player.shot + 1;
+    state.player.shot = state.player.shot + 1
-  state.player.shot_timer = shot_timer;
+  state.player.shot_timer = shot_timer
-  };
+  }
   if is_touching(make_rect(state.opponent.pos, dim), make_rect(state.player.pos, dim)) {
-    state.status = "caught";
+    state.status = "caught"
-  };
+  }
 
   if input.gamepad1.buttons.y {
-     let new_state = setup();
+     let new_state = setup()
-     state.player = new_state.player;
+     state.player = new_state.player
-     state.opponent = new_state.opponent;
+     state.opponent = new_state.opponent
-     state.bullets = new_state.bullets;
+     state.bullets = new_state.bullets
-     state.status = new_state.status;
+     state.status = new_state.status
-     state.timer = new_state.timer;
+     state.timer = new_state.timer
-  };
+  }
 
-  return state;
+  state
 }
 
 let draw = fn(state) {
-  frame_clear(0, 0, 0);
+  frame_clear(0, 0, 0)
   let player_rect = {
     .x: state.player.pos.x,
     .y: state.player.pos.y,
     .w: dim.w,
     .h: dim.h,
-  };
+  }
-  let color = { .r: 105 + (state.player.shot_timer * 100), .g: 225, .b: 125 };
+  let color = { .r: 105 + (state.player.shot_timer * 100), .g: 225, .b: 125 }
-  draw_rectangle(player_rect, color);
+  draw_rectangle(player_rect, color)
 
   let opponent_rect = {
     .x: state.opponent.pos.x,
     .y: state.opponent.pos.y,
     .w: dim.w,
     .h: dim.h,
-  };
+  }
 
-  let color = { .r: 255, .g: 155, .b: 255 - (state.player.shot_timer * 50) };
+  let color = { .r: 255, .g: 155, .b: 255 - (state.player.shot_timer * 50) }
-  draw_rectangle(opponent_rect, color);
+  draw_rectangle(opponent_rect, color)
 
   let bullet_rect = {
     .x: state.bullets.pos.x,
     .y: state.bullets.pos.y,
     .w: bullet_dim.w,
     .h: bullet_dim.h,
-  };
+  }
 
-  let color = { .r: 255, .g: 135, .b: 225 };
+  let color = { .r: 255, .g: 135, .b: 225 }
-  draw_rectangle(bullet_rect, color);
+  draw_rectangle(bullet_rect, color)
 
   if state.status == "caught" {
-    draw_text("You got caught <3", 20, 20, 20, { .r: 155, .g: 55, .b: 255 });
+    draw_text("You got caught <3", 20, 20, 20, { .r: 155, .g: 55, .b: 255 })
   } else {
-    draw_text("There she is!", 40, 20, 20, { .r: 255, .g: 55, .b: 155 });
+    draw_text("There she is!", 40, 20, 20, { .r: 255, .g: 55, .b: 155 })
 
     if state.player.shot_timer > 0 {
       draw_text("<3", 200, 20, 20, {
       .r: 100 + (state.player.shot_timer * 50 * state.player.shot) % 255,
       .g: 100,
       .b: 100,
-    });
+    })
-    };
+    }
-  };
+  }
 
-  draw_text(state.timer, 260, 20, 20, { .r: 55, .g: 205, .b: 155 });
+  draw_text(state.timer, 260, 20, 20, { .r: 55, .g: 205, .b: 155 })
 }
 
 let min = fn(a,b) {

src/lib.rs

@@ -31,8 +31,8 @@ let main = fn() {
     fn let_add_3() {
         let program = "
 let main = fn() {
-  let a = 1;
+  let a = 1
-  let b = 2;
+  let b = 2
   a + b
 }
 ";
@@ -43,8 +43,8 @@ let main = fn() {
     fn let_if_4() {
         let program = "
 let main = fn() {
-  let a = 1;
+  let a = 1
-  let b = if a > 0 { 3 } else { 5 };
+  let b = if a > 0 { 3 } else { 5 }
   a + b
 }
 ";
@@ -56,12 +56,12 @@ let main = fn() {
     fn bor_onearm_4() {
         let program = "
 let main = fn() {
-  let a = 1;
+  let a = 1
-  let b = 2 | 3;
+  let b = 2 | 3
   if true {
-    return a + b;
+    return a + b
-  };
+  }
-  return a;
+  return a
 }
 ";
         let result = run_main(program);
@@ -72,12 +72,12 @@ let main = fn() {
     fn loop_counter_9() {
         let program = "
 let counter = fn(a,b) {
-  let mut count = 0;
+  let mut count = 0
   loop {
     if (a + count) >= b {
-      break;
+      break
     };
-    count = count + 1;
+    count = count + 1
   };
   count
 }
@@ -95,7 +95,7 @@ let main = fn() {
         let program = "
 
 let main = fn() {
-  let state = setup();
+  let state = setup()
   update(state)
 }
 
@@ -109,7 +109,7 @@ let setup = fn() {
 }
 
 let update = fn(state) {
-  state.color.b = (state.color.b + state.dir) % 256;
+  state.color.b = (state.color.b + state.dir) % 256
   state.dir =
     if state.color.b == 255 {
 	  -1
@@ -119,8 +119,8 @@ let update = fn(state) {
       } else {
 	    state.dir
 	  }
-	};
+	}
-  return state;
+  return state
 }
 ";
         let result = run_main(program);

src/parser/parser.rs

@@ -243,7 +243,7 @@ fn parse_fn(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
 }
 
 fn parse_block(tokens: &mut Tokens) -> ParseResult<Vec<ast::Statement>> {
-    if let Some(mut stmts) = tokens.many_sep_by(&Token::Semicolon, parse_statement)? {
+    if let Some(mut stmts) = tokens.many_sep_by_maybe(&Token::Semicolon, parse_statement)? {
         //println!("{stmts:#?} {} {:#?}", stmts.len(), tokens.peek());
         if stmts.len() > 0 && tokens.next_if(&Token::Semicolon).is_some() {
             stmts.push(ast::Statement::Expr(ast::UNIT));
@@ -542,13 +542,13 @@ mod tests {
     fn let_loop_count() {
         let program = "
 let counter = fn(a,b) {
-  let mut count = 0;
+  let mut count = 0
   loop {
     if (a + count) >= b {
       break;
-    };
+    }
     count = count + 1;
-  };
+  }
   count
 }
 "
@@ -562,21 +562,21 @@ let counter = fn(a,b) {
 let setup = fn() {
   return {
     .player: { .position: { .x: 10, .y: 20 }, },
-  };
+  }
 }
 
 let update = fn(state, events) {
-  let new = 100;
+  let new = 100
-  state.player.position.x = new;
+  state.player.position.x = new
-  return state;
+  return state
 }
 
 let draw = fn(frame, state) {
-  frame.clear(0,0,0);
+  frame.clear(0,0,0)
 }
 
 let migrate = fn(state) {
-    return { .player: { .pos: state.player.position } };
+    return { .player: { .pos: state.player.position } }
 }
 "
         .to_string();

src/parser/types.rs

@@ -153,6 +153,26 @@ impl Tokens {
             Ok(None)
         }
     }
+    pub fn many_sep_by_maybe<T>(
+        &mut self,
+        separator: &Token,
+        parser: Parser<T>,
+    ) -> ParseResult<Vec<T>> {
+        if let Some(first) = parser(self)? {
+            let mut results = vec![first];
+            loop {
+                self.next_if(&separator);
+                if let Some(result) = parser(self)? {
+                    results.push(result);
+                } else {
+                    break;
+                }
+            }
+            Ok(Some(results))
+        } else {
+            Ok(Some(vec![]))
+        }
+    }
     pub fn many_sep_by<T>(&mut self, separator: &Token, parser: Parser<T>) -> ParseResult<Vec<T>> {
         if let Some(first) = parser(self)? {
             let mut results = vec![first];