use patterns for definitions instead of identifiers

ast.hs

@@ -15,7 +15,7 @@ data AST = Add AST AST
 		 | Block [AST]
 		 | FunDef String (Pattern, AST)
 		 | Defun String AST
-		 | Def String AST
+		 | Def Pattern AST
 		 | Var String
 		 | Lambda [(Pattern, AST)]
 		 | Call String AST

interp.hs

@@ -219,11 +219,14 @@ eval (Defun name fn) = do
                         newfn = FnV cls (oldpats ++ [(pat, body)]) in
                         put (s, bind env name newfn) >> return newfn
 
-eval (Def name v') = do
+eval (Def pat v') = do
 	v <- eval v'
-	(s,env) <- get
-	put (s, bind env name v)
-	return v
+	(s,locals:xs) <- get
+	case patternBindings pat v of
+		Nothing -> error $ "pattern binding doesn't satisfy: " ++ show v ++ " with " ++ show pat
+		Just bindings ->
+			put (s, (M.union bindings locals):xs) >> -- update our local bindings
+			return v
 
 eval (Lambda pats) =
 	get >>= \(_,env) ->

parser.hs

@@ -158,23 +158,23 @@ ifExpr = do
 bool = fmap BoolConst $ (symbol "true" >> return True) <|> (symbol "false" >> return False)
 
 def = do
-	name <- identifier
+	pat <- pattern
 	whiteSpace
 	symbol "="
 	value <- exprparser
-	return $ Def name value
+	return $ Def pat value
 
 expr' = try block
 	 <|> try funDef
 	 <|> try call
 	 <|> try lambda
+	 <|> try def
 	 <|> try (emptyTuple TupleConst)
 	 <|> try (tupleSeq exprparser TupleConst)
 	 <|> parens exprparser
 	 <|> listSeq exprparser ListConst
 	 <|> try ifExpr
 	 <|> try bool
-	 <|> try def
 	 <|> fmap Var identifier
 	 <|> fmap StrConst stringLiteral
 	 <|> fmap IntConst integer