Separating patterns and other expressions

[danilopedraza]

I need to check that patterns are only written where they are allowed. These are the allowed places:

• As function parameters (named and anonymous)
  • Named
  • Anonymous
• In the left hand side of case expression rules
• In the left hand side of declarations
• In the left hand side of assignments
• As for loop variables
• In list comprehensions
• In set comprehensions

They are forbidden everywhere else. Currently, when a pattern is written somewhere else, the evaluator panics. I don't like that. Specific enough error messages should be shown instead.

[danilopedraza]

Now that syntactically correct patterns are represented by the Pattern type, this is straightforward. We gotta check where do we want a pattern, and replace the String or ASTNode in there with a Pattern. For example, in anonymous functions, parameters are represented by Strings, which are parameter names. We just have to put Patterns in there, make the compiler happy, add some unit tests, and a e2e test. Any order of these tasks is fine!

[danilopedraza]

This will require changes in (at least) these places:

• ast.rs: Here is where you actually change the data type of the params value in the ASTNodeKind::Function variant (from Vec<String> to Vec<Pattern>), and trigger the remaining changes. For instance, here you will also need to change the signature of the function function in the tests module.
• weeder.rs: Here you will modify the code to accept patterns in the params of the function. Currently the weeder only accepts strings as lambda parameters, but instead of performing that checking you will only have to call the rewrite_pattern function to collect the parameters. This is compatible with the previous syntax, since any name is also a pattern.
• exec.rs: Code is interpreted here. You should use the destructure and set_inmutable functions.

Every one of these files has a tests section, where you should add at least one test for the new feature.