Fixing enum namespacing, Iterators with associated types, lifetime bounds

Author: Marwes

builtins.rs

@@ -1,10 +1,11 @@
 use types::*;
+use types::Type::Generic;
 use interner::intern;
 
 ///Returns an array of all the compiler primitves which exist (not including numeric primitives atm)
 pub fn builtins() -> Vec<(&'static str, Type)> {
-    let var = Generic(TypeVariable { id: intern("a"), kind: StarKind, age: 0 } );
-    let var2 = Generic(TypeVariable { id: intern("b"), kind: StarKind, age: 0 } );
+    let var = Type::Generic(TypeVariable { id: intern("a"), kind: Kind::Star, age: 0 } );
+    let var2 = Type::Generic(TypeVariable { id: intern("b"), kind: Kind::Star, age: 0 } );
     vec![("error", function_type_(list_type(char_type()), var.clone())),
       ("seq", function_type_(var.clone(), function_type_(var2.clone(), var2.clone()))),
       ("readFile", function_type_(list_type(char_type()), io(list_type(char_type())))),

compiler.rs

@@ -1,5 +1,7 @@
 use module::encode_binding_identifier;
 use core::*;
+use core::Expr::*;
+use types::{bool_type, function_type_};
 use renamer::NameSupply;
 use interner::{intern, InternedStr};
 
@@ -102,7 +104,7 @@ impl DerivingGen {
         //Create a constraint for each type parameter
         fn make_constraints(mut result: Vec<Constraint<Name>>, class: InternedStr, typ: &Type) -> Vec<Constraint<Name>> {
             match typ {
-                &TypeApplication(ref f, ref param) => {
+                &Type::Application(ref f, ref param) => {
                     result.push(Constraint { class: Name { name: class, uid: 0 }, variables: box [param.var().clone()] });
                     make_constraints(result, class, *f)
                 }
@@ -120,10 +122,10 @@ impl DerivingGen {
         let match_id = Id::new(self.name_supply.anonymous(), Type::new_op(intern("Ordering"), box []), box []);
         Case(box cmp, box [
             Alternative {
-                pattern: ConstructorPattern(id("EQ", Type::new_op(intern("Ordering"), box [])), box []),
+                pattern: Pattern::Constructor(id("EQ", Type::new_op(intern("Ordering"), box [])), box []),
                 expression: def
             },
-            Alternative { pattern: IdentifierPattern(match_id.clone()), expression: Identifier(match_id) }
+            Alternative { pattern: Pattern::Identifier(match_id.clone()), expression: Identifier(match_id) }
         ])
     }
 
@@ -139,15 +141,15 @@ impl DerivingGen {
                 .collect();
             let ctor_id = Id::new(constructor.name, iter.typ.clone(), constructor.typ.constraints.clone());
             let expr = f(self, args_l, args_r);
-            let pattern_r = ConstructorPattern(ctor_id.clone(), args_r);
+            let pattern_r = Pattern::Constructor(ctor_id.clone(), args_r);
             let inner = Case(box Identifier(id_r.clone()), box [
                 Alternative { pattern: pattern_r, expression: expr },
                 Alternative { 
-                    pattern: WildCardPattern,
+                    pattern: Pattern::WildCard,
                     expression: Identifier(Id::new(Name { uid: 0, name: intern("False") }, bool_type(), box []))
                 }
             ]);
-            Alternative { pattern: ConstructorPattern(ctor_id, args_l), expression: inner }
+            Alternative { pattern: Pattern::Constructor(ctor_id, args_l), expression: inner }
         }).collect();
         alts
     }
@@ -181,7 +183,8 @@ fn true_expr() -> Expr<Id<Name>> {
 struct ArgIterator<'a> {
     typ: &'a Type
 }
-impl <'a> Iterator<&'a Type> for ArgIterator<'a> {
+impl <'a> Iterator for ArgIterator<'a> {
+    type Item = &'a Type;
     fn next(&mut self) -> Option<&'a Type> {
         use types::try_get_function;
         match try_get_function(self.typ) {
@@ -195,7 +198,7 @@ impl <'a> Iterator<&'a Type> for ArgIterator<'a> {
 }
 fn extract_applied_type<'a>(typ: &'a Type) -> &'a Type {
     match typ {
-        &TypeApplication(ref lhs, _) => extract_applied_type(*lhs),
+        &Type::Application(ref lhs, _) => extract_applied_type(*lhs),
         _ => typ
     }
 }

core.rs

@@ -1,6 +1,7 @@
 ///Graph module, contains a simple graph structure which is when typechecking to find
 ///functions which are mutually recursive
 
+use std::iter::repeat;
 use std::cmp::min;
 
 #[deriving(PartialEq, Show)]
@@ -66,8 +67,9 @@ impl <T> Graph<T> {
 pub fn strongly_connected_components<T>(graph: &Graph<T>) -> Vec<Vec<VertexIndex>> {
 
     let mut tarjan = TarjanComponents { graph: graph, index: 1, stack: Vec::new(), connections: Vec::new(),
-        valid: Vec::from_fn(graph.len(), |_| 0),
-        lowlink: Vec::from_fn(graph.len(), |_| 0)};
+        valid: repeat(0).take(graph.len()).collect(),
+        lowlink: repeat(0).take(graph.len()).collect()
+    };
 
 
     for vert in range(0, graph.len()) {
@@ -82,7 +84,7 @@ pub fn strongly_connected_components<T>(graph: &Graph<T>) -> Vec<Vec<VertexIndex
         .collect()
 }
 
-struct TarjanComponents<'a, T>{
+struct TarjanComponents<'a, T: 'a>{
     index: uint,
     graph: &'a Graph<T>,
     valid: Vec<uint>,

deriving.rs

@@ -9,8 +9,8 @@ impl MutVisitor<Name> for PrecedenceVisitor {
     fn visit_expr(&mut self, expr: &mut TypedExpr<Name>) {
         walk_expr_mut(self, expr);
         match expr.expr {
-            OpApply(..) => {
-                let mut temp = TypedExpr::new(Identifier(Name { uid: -1, name: intern("") }));
+            Expr::OpApply(..) => {
+                let mut temp = TypedExpr::new(Expr::Identifier(Name { uid: -1, name: intern("") }));
                 ::std::mem::swap(&mut temp, expr);
                 temp = self.rewrite(box temp);
                 ::std::mem::swap(&mut temp, expr);
@@ -31,14 +31,14 @@ impl PrecedenceVisitor {
 
     pub fn new() -> PrecedenceVisitor {
         let mut map = HashMap::new();
-        map.insert(Name { uid: 0, name: intern(":") }, (5, RightAssoc));
+        map.insert(Name { uid: 0, name: intern(":") }, (5, Assoc::Right));
         PrecedenceVisitor { precedence: map }
     }
 
     fn get_precedence(&self, name: &Name) -> (int, Assoc) {
         self.precedence.find(name)
             .map(|x| *x)
-            .unwrap_or_else(|| (9, LeftAssoc))
+            .unwrap_or_else(|| (9, Assoc::Left))
     }
 
     ///Takes a operator expression the is in the form (1 + (2 * (3 - 4))) and rewrites it using the
@@ -51,14 +51,14 @@ impl PrecedenceVisitor {
             let rhs = expr_stack.pop().unwrap();
             let lhs = expr_stack.pop().unwrap();
             let loc = lhs.location;
-            expr_stack.push(box TypedExpr::with_location(OpApply(lhs, op, rhs), loc));
+            expr_stack.push(box TypedExpr::with_location(Expr::OpApply(lhs, op, rhs), loc));
         }
         let mut expr_stack = Vec::new();
         let mut op_stack = Vec::new();
         loop {
             let TypedExpr { typ: typ, location:location, expr: expr } = *input;
             match expr {
-                OpApply(l, op, r) => {
+                Expr::OpApply(l, op, r) => {
                     expr_stack.push(l);
                     input = r;
                     loop {
@@ -72,10 +72,10 @@ impl PrecedenceVisitor {
                                 }
                                 else if op_prec == prev_prec {
                                     match (op_assoc, prev_assoc) {
-                                        (LeftAssoc, LeftAssoc) => {
+                                        (Assoc::Left, Assoc::Left) => {
                                             reduce(&mut expr_stack, &mut op_stack);
                                         }
-                                        (RightAssoc, RightAssoc) => {
+                                        (Assoc::Right, Assoc::Right) => {
                                             debug!("Shift op {}", op);
                                             op_stack.push(op);
                                             break
@@ -100,7 +100,7 @@ impl PrecedenceVisitor {
                         assert!(expr_stack.len() >= 1);
                         let lhs = expr_stack.pop().unwrap();
                         let op = op_stack.pop().unwrap();
-                        result = TypedExpr::with_location(OpApply(lhs, op, box result), location);
+                        result = TypedExpr::with_location(Expr::OpApply(lhs, op, box result), location);
                     }
                     return result;
                 }

graph.rs

@@ -41,7 +41,7 @@ impl Interner {
 
 ///Returns a reference to the interner stored in TLD
 pub fn get_local_interner() -> Rc<RefCell<Interner>> {
-    thread_local!(static INTERNER: Rc<RefCell<(Interner, Gc)>> = Rc::new(RefCell::new((Interner::new(), Gc::new()))));
+    thread_local!(static INTERNER: Rc<RefCell<Interner>> = Rc::new(RefCell::new(Interner::new())));
     INTERNER.with(|interner| interner.clone())
 }
 

infix.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use core::*;
+use core::Expr::*;
 use types::function_type_;
 use renamer::NameSupply;
 
@@ -15,8 +16,8 @@ struct FreeVariables {
 
 fn each_pattern_variables(pattern: &Pattern<Id>, f: &mut FnMut(&Name)) {
     match *pattern {
-        IdentifierPattern(ref ident) => (*f)(&ident.name),
-        ConstructorPattern(_, ref patterns) => {
+        Pattern::Identifier(ref ident) => (*f)(&ident.name),
+        Pattern::Constructor(_, ref patterns) => {
             for p in patterns.iter() {
                 (*f)(&p.name);
             }

interner.rs

@@ -5,6 +5,8 @@ use std::rc::Rc;
 use std::cell::RefCell;
 use interner::*;
 
+use self::TokenEnum::*;
+
 #[deriving(Clone, PartialEq, Show)]
 pub enum TokenEnum {
 	EOF,
@@ -150,7 +152,7 @@ fn is_operator(first_char : char) -> bool {
     }
 }
 
-pub struct Lexer<Stream> {
+pub struct Lexer<Stream: Iterator<Item=char>> {
     ///The input which the lexer processes
     input : Peekable<char, Stream>,
     ///The current location of the lexer
@@ -168,7 +170,7 @@ pub struct Lexer<Stream> {
 }
 
 
-impl <Stream : Iterator<char>> Lexer<Stream> {
+impl <Stream : Iterator<Item=char>> Lexer<Stream> {
 
     ///Constructs a new lexer with a default sized token buffer and the local string interner
     pub fn new(input : Stream) -> Lexer<Stream> {
@@ -297,7 +299,7 @@ impl <Stream : Iterator<char>> Lexer<Stream> {
     }
     ///Scans a number, float or integer and returns the appropriate token
     fn scan_number(&mut self, c : char, location : Location) -> Token {
-        let mut number = String::from_char(1, c);
+        let mut number = c.to_string();
         number.push_str(self.scan_digits().as_slice());
         let mut token = NUMBER;
         match self.peek_char() {
@@ -313,7 +315,7 @@ impl <Stream : Iterator<char>> Lexer<Stream> {
     }
     ///Scans an identifier or a keyword
     fn scan_identifier(&mut self, c: char, startLocation: Location) -> Token {
-        let mut result = String::from_char(1, c);
+        let mut result = c.to_string();
         loop {
             match self.peek_char() {
                 Some(ch) => {
@@ -497,7 +499,7 @@ impl <Stream : Iterator<char>> Lexer<Stream> {
         //Decide how to tokenize depending on what the first char is
         //ie if its an operator then more operators will follow
         if is_operator(c) {
-            let mut result = String::from_char(1, c);
+            let mut result = c.to_string();
             loop {
                 match self.peek_char() {
                     Some(ch) => {
@@ -556,7 +558,8 @@ impl <Stream : Iterator<char>> Lexer<Stream> {
             match self.read_char() {
                 Some(x) => {
                     if self.read_char() == Some('\'') {
-                        return Token::new(&self.interner, CHAR, ::std::str::from_char(x).as_slice(), startLocation);
+                        //FIXME: Slow
+                        return Token::new(&self.interner, CHAR, &*x.to_string(), startLocation);
                     }
                     else {
                         panic!("Multi char character")
@@ -577,7 +580,8 @@ impl <Stream : Iterator<char>> Lexer<Stream> {
             '\\'=> LAMBDA,
             _   => EOF
         };
-        Token::new(&self.interner, tok, ::std::str::from_char(c).as_slice(), startLocation)
+        //FIXME: Slow
+        Token::new(&self.interner, tok, c.to_string().as_slice(), startLocation)
     }
 }