---

yaml
---
r: 879
b: refs/heads/master
c: 1d214b4
h: refs/heads/master
i:
  877: 10c5a51
  875: 0ae3013
  871: a13ca83
  863: 735079e
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 16faef2218ec5c3621079f04e6b093a5bb1b44c2
+refs/heads/master: 1d214b4df3013a53e50d778fa921ed99bc498d02

trunk/src/comp/driver/rustc.rs

@@ -5,9 +5,9 @@ import front.token;
 import middle.trans;
 import middle.resolve;
 
-import std.util.option;
-import std.util.some;
-import std.util.none;
+import std.option;
+import std.option.some;
+import std.option.none;
 import std._str;
 import std._vec;
 
@@ -39,8 +39,8 @@ fn usage(session.session sess, str argv0) {
 impure fn main(vec[str] args) {
 
   auto sess = session.session();
-  let option[str] input_file = none[str];
-  let option[str] output_file = none[str];
+  let option.t[str] input_file = none[str];
+  let option.t[str] output_file = none[str];
   let bool do_warn = true;
 
   auto i = 1u;

trunk/src/comp/front/ast.rs

@@ -1,5 +1,4 @@
 
-import util.common.option;
 import std.map.hashmap;
 import std.util.option;
 import util.common.span;

trunk/src/comp/front/parser.rs

@@ -1,8 +1,8 @@
 import std._io;
-import std.util.option;
-import std.util.some;
-import std.util.none;
+import std.option.some;
+import std.option.none;
 import std.map.hashmap;
+import std.util.option;
 
 import driver.session;
 import util.common;

trunk/src/comp/middle/fold.rs

@@ -1,7 +1,7 @@
 import std.map.hashmap;
+import std.option.some;
+import std.option.none;
 import std.util.option;
-import std.util.some;
-import std.util.none;
 
 import util.common.new_str_hash;
 import util.common.spanned;

trunk/src/comp/middle/resolve.rs

@@ -8,9 +8,9 @@ import std.map.hashmap;
 import std.list.list;
 import std.list.nil;
 import std.list.cons;
+import std.option.some;
+import std.option.none;
 import std.util.option;
-import std.util.some;
-import std.util.none;
 import std._str;
 
 tag scope {

trunk/src/comp/middle/trans.rs

@@ -3,9 +3,9 @@ import std._vec;
 import std._str.rustrt.sbuf;
 import std._vec.rustrt.vbuf;
 import std.map.hashmap;
+import std.option.some;
+import std.option.none;
 import std.util.option;
-import std.util.some;
-import std.util.none;
 
 import front.ast;
 import driver.session;

trunk/src/lib/deque.rs

@@ -2,7 +2,7 @@
  * A deque, for fun.  Untested as of yet.  Likely buggy.
  */
 
-import std.util;
+import std.option;
 import std._vec;
 import std._int;
 
@@ -23,7 +23,7 @@ type t[T] = obj {
 
 fn create[T]() -> t[T] {
 
-    type cell[T] = mutable util.option[T];
+    type cell[T] = mutable option.t[T];
 
     let uint initial_capacity = 32u; // 2^5
 
@@ -39,7 +39,7 @@ fn create[T]() -> t[T] {
             if (i < nelts) {
                 ret old.((lo + i) % nelts);
             } else {
-                ret util.none[T];
+                ret option.none;
             }
         }
 
@@ -50,7 +50,7 @@ fn create[T]() -> t[T] {
 
     fn get[T](vec[cell[T]] elts, uint i) -> T {
         alt (elts.(i)) {
-            case (util.some[T](?t)) { ret t; }
+            case (option.some[T](?t)) { ret t; }
             case (_) { fail; }
         }
     }
@@ -77,7 +77,7 @@ fn create[T]() -> t[T] {
                     hi = nelts;
                 }
 
-                elts.(lo) = util.some[T](t);
+                elts.(lo) = option.some[T](t);
                 nelts += 1u;
             }
 
@@ -88,7 +88,7 @@ fn create[T]() -> t[T] {
                     hi = nelts;
                 }
 
-                elts.(hi) = util.some[T](t);
+                elts.(hi) = option.some[T](t);
                 hi = (hi + 1u) % _vec.len[cell[T]](elts);
                 nelts += 1u;
             }
@@ -99,7 +99,7 @@ fn create[T]() -> t[T] {
              */
             fn pop_front() -> T {
                 let T t = get[T](elts, lo);
-                elts.(lo) = util.none[T];
+                elts.(lo) = option.none[T];
                 lo = (lo + 1u) % _vec.len[cell[T]](elts);
                 nelts -= 1u;
                 ret t;
@@ -113,7 +113,7 @@ fn create[T]() -> t[T] {
                 }
 
                 let T t = get[T](elts, hi);
-                elts.(hi) = util.none[T];
+                elts.(hi) = option.none[T];
                 nelts -= 1u;
                 ret t;
             }
@@ -132,7 +132,7 @@ fn create[T]() -> t[T] {
             }
 
         }
-    let vec[cell[T]] v = _vec.init_elt[cell[T]](util.none[T],
+    let vec[cell[T]] v = _vec.init_elt[cell[T]](option.none[T],
                                                 initial_capacity);
 
     ret deque[T](0u, 0u, 0u, v);

trunk/src/lib/list.rs

@@ -1,7 +1,7 @@
 
-import util.option;
-import util.some;
-import util.none;
+import option;
+import option.some;
+import option.none;
 
 // FIXME: It would probably be more appealing to define this as
 // type list[T] = rec(T hd, option[@list[T]] tl), but at the moment
@@ -27,7 +27,7 @@ fn foldl[T,U](&list[T] ls, &U u, fn(&T t, U u) -> U f) -> U {
 }
 
 fn find[T,U](&list[T] ls,
-             (fn(&T) -> option[U]) f) -> option[U] {
+             (fn(&T) -> option.t[U]) f) -> option.t[U] {
   alt(ls) {
     case (cons[T](?hd, ?tl)) {
         alt (f(hd)) {

trunk/src/lib/option.rs

@@ -0,0 +1,40 @@
+// lib/option.rs
+
+tag t[T] {
+    none;
+    some(T);
+}
+
+type operator[T, U] = fn(&T) -> U;
+
+fn get[T](&t[T] opt) -> T {
+    alt (opt) {
+        case (some[T](?x)) {
+            ret x;
+        }
+        case (none[T]) {
+            fail;
+        }
+    }
+}
+
+fn map[T, U](&operator[T, U] f, &t[T] opt) -> t[U] {
+    alt (opt) {
+        case (some[T](?x)) {
+            ret some[U](f(x));
+        }
+        case (none[T]) {
+            ret none[U];
+        }
+    }
+}
+
+// Local Variables:
+// mode: rust;
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
+

trunk/src/lib/std.rc

@@ -20,6 +20,7 @@ mod _task;
 
 // Utility modules.
 
+mod option;
 mod util;
 
 // Authorize various rule-bendings.

trunk/src/lib/util.rs

@@ -1,21 +1,3 @@
-tag option[T] {
-    none;
-    some(T);
-}
-
-type operator[T, U] = fn(&T) -> U;
-
-fn option_map[T, U](&operator[T, U] f, &option[T] opt) -> option[U] {
-    alt (opt) {
-        case (some[T](?x)) {
-            ret some[U](f(x));
-        }
-        case (none[T]) {
-            ret none[U];
-        }
-    }
-}
-
 fn id[T](&T x) -> T {
     ret x;
 }