Fix type parsing bug and bump version to 0.4.5

Cargo.toml

@@ -6,7 +6,7 @@ documentation = "https://github.com/P-bibs/skiff"
 repository = "https://github.com/P-bibs/skiff"
 readme = "README.md"
 license = "MIT"
-version = "0.4.4"
+version = "0.4.5"
 authors = ["Paul Biberstein <biberstein.paul@gmail.com>"]
 edition = "2018"
 keywords = ["interpreters", "wasm", "programming-language", "cli"]

Cargo.wasm.toml

@@ -6,7 +6,7 @@ documentation = "https://github.com/P-bibs/skiff"
 repository = "https://github.com/P-bibs/skiff"
 readme = "README.md"
 license = "MIT"
-version = "0.4.4"
+version = "0.4.5"
 authors = ["Paul Biberstein <biberstein.paul@gmail.com>"]
 edition = "2018"
 keywords = ["interpreters", "wasm", "programming-language", "cli"]

src/parser/types/parse.rs

@@ -56,7 +56,7 @@ fn parse_type_args(
         args.push_back(parse_type(tokens)?.0);
         match tokens.pop() {
             Some((Token::Comma, _)) => continue,
-            Some((Token::Gt, span_end)) => return Ok((args, span_end.end)),
+            Some((Token::RParen, span_end)) => return Ok((args, span_end.end)),
             Some((t, span)) => {
                 return Err(ParseError(
                     format!("Unexpected token in type args {:?}", t).to_string(),

tests/files/success/language_tour.boat

@@ -1,22 +1,22 @@
-# We can define ADTs with the `data` keyword.
+# We can define ADTs with the \`data\` keyword.
 data Option:
     | some(v)
     | none()
 end
 
 # A simple linked list with a first item and a rest.
 data List:
-    | link(f,r)
+    | link(f, r)
     | empty()
 end
 
-# A binary tree node
+# A binary tree node with optional type annotations
 data Tree:
-    | node(v,l,r)
+    | node(v: Number, l: Tree, r: Tree)
     | leaf()
 end
 
-# Higher order functions are supported, so we can define a `map` function that
+# Higher order functions are supported, so we can define a \`map\` function that
 # takes a function and a list and applies the function to each element of the list
 def map(func, l):
     match l:
@@ -25,8 +25,9 @@ def map(func, l):
     end
 end
 
-# We define `filter` similar to `map` by using pattern matching and recursion.
-def filter(func, l):
+# We define \`filter\` similar to \`map\` by using pattern matching and recursion.
+# We can also supply optional type annotations.
+def filter(func: Number -> Boolean, l: List) -> List:
     match l:
         | link(f,r) => if func(f):
                 link(f, filter(func, r))
@@ -44,10 +45,11 @@ def fold(func, l, default):
     end
 end
 
-let list = link(1, link(2, link(3, link(4, empty()))))
+# type annotation could be omitted
+let list: List = link(1, link(2, link(3, link(4, empty()))))
 
 map(lambda(x): x + 1 end, list)
 
 filter(lambda(x): x == 2 end, list)
 
-fold(lambda(n,a): n + a end, list, 0)
+fold(lambda(n,a): n + a end, list, 0)