diff --git a/examples/hello.v b/examples/hello.v
index 44821b4..48942a5 100644
--- a/examples/hello.v
+++ b/examples/hello.v
@@ -54,10 +54,8 @@ fn main(a int) int {
 
 	str := 'hello' 
 	len := str.len
-
-	// those should yield the same ast
 	str.len = str.len + 1
-	str.len += 1
+	// str.len += 1
 }
 
 fn (v Typ) voidfunc() {}
diff --git a/src/parser.zig b/src/parser.zig
index b0e096b..9c0d436 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -688,7 +688,7 @@ pub const Parser = struct {
     fn parseAssignment(self: *@This()) anyerror!*Expr {
         // there can be two assignments coming out of this function:
         //  - a mutable/immutable variable declaration with :=
-        //  - an assignment to a variable with =, +=, -=
+        //  - an assignment to a variable with =
 
         // one is a statement, other is an expression. since the normal result
         // of this is an Expr, we wrap variable assignments in an Expr as well.
@@ -701,9 +701,7 @@ pub const Parser = struct {
 
         var expr = try self.parseOr();
 
-        if (self.compareAnyOf(&[_]TokenType{
-            .ColonEqual, .Equal, .PlusEqual, .MinusEqual,
-        })) {
+        if (self.check(.ColonEqual) or self.check(.Equal)) {
             return try self.finishAssignment(expr, mutable);
         }
 
@@ -715,63 +713,22 @@ pub const Parser = struct {
         _ = try self.nextToken();
         var value = try self.parseAssignment();
 
-        // TODO convert binary's op field from Token to
-        // something else, maybe enum'd
-
         switch (expr.*) {
             .Variable => {
                 switch (op.ttype) {
                     .ColonEqual => return try self.mkVarDecl(expr.Variable, value, mutable),
                     .Equal => return try self.mkAssign(expr.Variable, value),
-
-                    .PlusEqual => {
-                        var plus_op = try self.mkToken(.Plus, "+", op.line);
-                        return try self.mkAssign(
-                            expr.Variable,
-                            try self.mkBinary(expr, plus_op, value),
-                        );
-                    },
-
-                    .MinusEqual => {
-                        var new_op = try self.mkToken(.Minus, "-", op.line);
-                        return try self.mkAssign(
-                            expr.Variable,
-                            try self.mkBinary(expr, new_op, value),
-                        );
-                    },
-
                     else => unreachable,
                 }
             },
 
             .Get => |get| {
-                switch (op.ttype) {
-                    .ColonEqual => {
-                        self.doError("can not initialize struct field");
-                        return Result.CompileError;
-                    },
-
-                    .PlusEqual => {
-                        var new_op = try self.mkToken(.Plus, "+", op.line);
-                        return try self.mkSet(
-                            get.struc,
-                            get.name,
-                            try self.mkBinary(expr, new_op, value),
-                        );
-                    },
-
-                    .MinusEqual => {
-                        var new_op = try self.mkToken(.Minus, "-", op.line);
-                        return try self.mkSet(
-                            get.struc,
-                            get.name,
-                            try self.mkBinary(expr, new_op, value),
-                        );
-                    },
-
-                    .Equal => return try self.mkSet(get.struc, get.name, value),
-                    else => unreachable,
+                if (op.ttype == .ColonEqual) {
+                    self.doError("can not initialize struct field");
+                    return Result.CompileError;
                 }
+
+                return try self.mkSet(get.struc, get.name, value);
             },
 
             else => |expr_typ| {