Added experimental shorthand generics syntax for when only specifying a single type argument

Author: IsaacShelton

Diff for: src/lexer/mod.rs

@@ -42,6 +42,7 @@ impl<T: Text + Send> Lexer<T> {
             State::String(_) => self.feed_string(),
             State::Number(_) => self.feed_number(),
             State::HexNumber(_) => self.feed_hex_number(),
+            State::ShortGeneric => self.feed_short_generic(),
         }
     }
 
@@ -378,7 +379,7 @@ impl<T: Text + Send> Lexer<T> {
             }
             _ => {
                 let token = state.finalize();
-                self.state = State::Idle;
+                self.state = State::ShortGeneric;
                 Has(token)
             }
         }
@@ -517,6 +518,16 @@ impl<T: Text + Send> Lexer<T> {
             Has(token)
         }
     }
+
+    fn feed_short_generic(&mut self) -> FeedResult<Token> {
+        self.state = State::Idle;
+
+        if let Ok(source) = self.characters.eat_remember('-') {
+            FeedResult::Has(TokenKind::ShortGeneric.at(source))
+        } else {
+            self.feed_idle()
+        }
+    }
 }
 
 impl<T: Text + Send> InflowStream for Lexer<T> {

Diff for: src/lexer/state.rs

@@ -14,6 +14,7 @@ pub enum State {
     String(StringState),
     Number(NumberState),
     HexNumber(HexNumberState),
+    ShortGeneric,
 }
 
 impl State {

Diff for: src/parser/parse_type.rs

@@ -62,6 +62,10 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
     pub fn parse_type_args(&mut self) -> Result<Vec<TypeArg>, ParseError> {
         let mut generics = vec![];
 
+        if self.input.eat(TokenKind::ShortGeneric) {
+            return Ok(vec![self.parse_type_arg()?]);
+        }
+
         if !self.input.eat(TokenKind::OpenAngle) {
             return Ok(generics);
         }
@@ -79,16 +83,20 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                 return Err(self.unexpected_token_is_next());
             }
 
-            generics.push(if self.input.peek().could_start_type() {
-                TypeArg::Type(self.parse_type(None::<&str>, Some("for compile time argument"))?)
-            } else {
-                TypeArg::Expr(self.parse_expr_primary()?)
-            });
+            generics.push(self.parse_type_arg()?);
         }
 
         Ok(generics)
     }
 
+    pub fn parse_type_arg(&mut self) -> Result<TypeArg, ParseError> {
+        Ok(if self.input.peek().could_start_type() {
+            TypeArg::Type(self.parse_type(None::<&str>, Some("for compile time argument"))?)
+        } else {
+            TypeArg::Expr(self.parse_expr_primary()?)
+        })
+    }
+
     pub fn parse_type_from_parts(
         &mut self,
         name: Name,

Diff for: src/token.rs

@@ -136,6 +136,7 @@ pub enum TokenKind {
     StaticMember,
     Extend,
     FatArrow,
+    ShortGeneric,
 }
 
 impl Display for TokenKind {
@@ -231,6 +232,7 @@ impl Display for TokenKind {
             TokenKind::StaticMember => f.write_str("'::'"),
             TokenKind::Extend => f.write_str("'..'"),
             TokenKind::FatArrow => f.write_str("'=>'"),
+            TokenKind::ShortGeneric => f.write_str("short generic '-'"),
         }
     }
 }
@@ -324,7 +326,8 @@ impl TokenKind {
             | TokenKind::Dereference
             | TokenKind::StaticMember
             | TokenKind::Extend
-            | TokenKind::FatArrow => 0,
+            | TokenKind::FatArrow
+            | TokenKind::ShortGeneric => 0,
         }
     }