Change option::t to option

Now that core exports "option" as a synonym for option::t, search-and-
replace option::t with option.

The only place that still refers to option::t are the modules in libcore
that use option, because fixing this requires a new snapshot
(forthcoming).

20 files changed, 59 insertions, 59 deletions

diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index b2154bc61b4..53dccda3f15 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -46,7 +46,7 @@ enum t<T> {
     t({ base: *mutable T, len: uint, rsrc: @dtor_res})
 }
 
-resource dtor_res(dtor: option::t<fn@()>) {
+resource dtor_res(dtor: option<fn@()>) {
     alt dtor {
       option::none { }
       option::some(f) { f(); }
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 290b981306f..e6c30f67302 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -38,7 +38,7 @@ Function: create
 // FIXME eventually, a proper datatype plus an exported impl would be
 // preferrable
 fn create<T: copy>() -> t<T> {
-    type cell<T> = option::t<T>;
+    type cell<T> = option<T>;
 
     let initial_capacity: uint = 32u; // 2^5
      /**
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index b76ba4ad9b8..19cf97624ab 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -50,7 +50,7 @@ fn doc_at(data: @[u8], start: uint) -> doc {
     ret {data: data, start: elt_size.next, end: end};
 }
 
-fn maybe_get_doc(d: doc, tg: uint) -> option::t<doc> {
+fn maybe_get_doc(d: doc, tg: uint) -> option<doc> {
     let pos = d.start;
     while pos < d.end {
         let elt_tag = vint_at(*d.data, pos);
diff --git a/src/libstd/freebsd_os.rs b/src/libstd/freebsd_os.rs
index 89aad5d7777..77db136dc25 100644
--- a/src/libstd/freebsd_os.rs
+++ b/src/libstd/freebsd_os.rs
@@ -127,7 +127,7 @@ fn dylib_filename(base: str) -> str { ret "lib" + base + ".so"; }
 
 /// Returns the directory containing the running program
 /// followed by a path separator
-fn get_exe_path() -> option::t<fs::path> unsafe {
+fn get_exe_path() -> option<fs::path> unsafe {
     let bufsize = 1023u;
     // FIXME: path "strings" will likely need fixing...
     let path = str::from_bytes(vec::init_elt(bufsize, 0u8));
diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs
index 4a98bf5c661..d497b2a4963 100644
--- a/src/libstd/fun_treemap.rs
+++ b/src/libstd/fun_treemap.rs
@@ -13,7 +13,7 @@ of features.
 */
 
 import option::{some, none};
-import option = option::t;
+import option = option;
 
 export treemap;
 export init;
diff --git a/src/libstd/generic_os.rs b/src/libstd/generic_os.rs
index 934352e7788..f41e83fa5fb 100644
--- a/src/libstd/generic_os.rs
+++ b/src/libstd/generic_os.rs
@@ -16,7 +16,7 @@ Function: getenv
 
 Get the value of an environment variable
 */
-fn getenv(n: str) -> option::t<str> { }
+fn getenv(n: str) -> option<str> { }
 
 #[cfg(bogus)]
 /*
@@ -29,7 +29,7 @@ fn setenv(n: str, v: str) { }
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
-fn getenv(n: str) -> option::t<str> unsafe {
+fn getenv(n: str) -> option<str> unsafe {
     let s = str::as_buf(n, {|buf| os::libc::getenv(buf) });
     ret if unsafe::reinterpret_cast(s) == 0 {
             option::none::<str>
@@ -55,7 +55,7 @@ fn setenv(n: str, v: str) {
 }
 
 #[cfg(target_os = "win32")]
-fn getenv(n: str) -> option::t<str> {
+fn getenv(n: str) -> option<str> {
     let nsize = 256u;
     while true {
         let v: [u8] = [];
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index b870dde34c6..585ea48725f 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -148,7 +148,7 @@ fn name_str(nm: name) -> str {
     ret alt nm { short(ch) { str::from_char(ch) } long(s) { s } };
 }
 
-fn find_opt(opts: [opt], nm: name) -> option::t<uint> {
+fn find_opt(opts: [opt], nm: name) -> option<uint> {
     vec::position_pred(opts, { |opt| opt.name == nm })
 }
 
@@ -354,7 +354,7 @@ Function: opt_str
 
 Returns the string argument supplied to a matching option or none
 */
-fn opt_maybe_str(m: match, nm: str) -> option::t<str> {
+fn opt_maybe_str(m: match, nm: str) -> option<str> {
     let vals = opt_vals(m, nm);
     if vec::len::<optval>(vals) == 0u { ret none::<str>; }
     ret alt vals[0] { val(s) { some::<str>(s) } _ { none::<str> } };
@@ -370,7 +370,7 @@ Returns none if the option was not present, `def` if the option was
 present but no argument was provided, and the argument if the option was
 present and an argument was provided.
 */
-fn opt_default(m: match, nm: str, def: str) -> option::t<str> {
+fn opt_default(m: match, nm: str, def: str) -> option<str> {
     let vals = opt_vals(m, nm);
     if vec::len::<optval>(vals) == 0u { ret none::<str>; }
     ret alt vals[0] { val(s) { some::<str>(s) } _ { some::<str>(def) } }
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 5cc08813d6a..ba8f1e62fc6 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -525,13 +525,13 @@ mod fsync {
 
     type arg<t> = {
         val: t,
-        opt_level: option::t<level>,
+        opt_level: option<level>,
         fsync_fn: fn@(t, level) -> int
     };
 
     // fsync file after executing blk
     // FIXME find better way to create resources within lifetime of outer res
-    fn FILE_res_sync(&&file: FILE_res, opt_level: option::t<level>,
+    fn FILE_res_sync(&&file: FILE_res, opt_level: option<level>,
                   blk: fn(&&res<os::libc::FILE>)) {
         blk(res({
             val: *file, opt_level: opt_level,
@@ -542,7 +542,7 @@ mod fsync {
     }
 
     // fsync fd after executing blk
-    fn fd_res_sync(&&fd: fd_res, opt_level: option::t<level>,
+    fn fd_res_sync(&&fd: fd_res, opt_level: option<level>,
                    blk: fn(&&res<fd_t>)) {
         blk(res({
             val: *fd, opt_level: opt_level,
@@ -556,7 +556,7 @@ mod fsync {
     iface t { fn fsync(l: level) -> int; }
 
     // Call o.fsync after executing blk
-    fn obj_sync(&&o: t, opt_level: option::t<level>, blk: fn(&&res<t>)) {
+    fn obj_sync(&&o: t, opt_level: option<level>, blk: fn(&&res<t>)) {
         blk(res({
             val: o, opt_level: opt_level,
             fsync_fn: fn@(&&o: t, l: level) -> int { ret o.fsync(l); }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 0229b4d1b22..306bcf6e16a 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -74,7 +74,7 @@ fn rest(s: str) -> str {
     str::char_slice(s, 1u, str::char_len(s))
 }
 
-fn from_str_str(s: str) -> (option::t<json>, str) {
+fn from_str_str(s: str) -> (option<json>, str) {
     let pos = 0u;
     let len = str::byte_len(s);
     let escape = false;
@@ -107,7 +107,7 @@ fn from_str_str(s: str) -> (option::t<json>, str) {
     ret (none, s);
 }
 
-fn from_str_list(s: str) -> (option::t<json>, str) {
+fn from_str_list(s: str) -> (option<json>, str) {
     if str::char_at(s, 0u) != '[' { ret (none, s); }
     let s0 = str::trim_left(rest(s));
     let vals = [];
@@ -133,7 +133,7 @@ fn from_str_list(s: str) -> (option::t<json>, str) {
     ret (none, s0);
 }
 
-fn from_str_dict(s: str) -> (option::t<json>, str) {
+fn from_str_dict(s: str) -> (option<json>, str) {
     if str::char_at(s, 0u) != '{' { ret (none, s); }
     let s0 = str::trim_left(rest(s));
     let vals = map::new_str_hash::<json>();
@@ -170,7 +170,7 @@ fn from_str_dict(s: str) -> (option::t<json>, str) {
     (none, s)
 }
 
-fn from_str_float(s: str) -> (option::t<json>, str) {
+fn from_str_float(s: str) -> (option<json>, str) {
     let pos = 0u;
     let len = str::byte_len(s);
     let res = 0f;
@@ -226,7 +226,7 @@ fn from_str_float(s: str) -> (option::t<json>, str) {
     ret (some(num(neg * res)), str::char_slice(s, pos, str::char_len(s)));
 }
 
-fn from_str_bool(s: str) -> (option::t<json>, str) {
+fn from_str_bool(s: str) -> (option<json>, str) {
     if (str::starts_with(s, "true")) {
         (some(boolean(true)), str::slice(s, 4u, str::byte_len(s)))
     } else if (str::starts_with(s, "false")) {
@@ -236,7 +236,7 @@ fn from_str_bool(s: str) -> (option::t<json>, str) {
     }
 }
 
-fn from_str_null(s: str) -> (option::t<json>, str) {
+fn from_str_null(s: str) -> (option<json>, str) {
     if (str::starts_with(s, "null")) {
         (some(null), str::slice(s, 4u, str::byte_len(s)))
     } else {
@@ -244,7 +244,7 @@ fn from_str_null(s: str) -> (option::t<json>, str) {
     }
 }
 
-fn from_str_helper(s: str) -> (option::t<json>, str) {
+fn from_str_helper(s: str) -> (option<json>, str) {
     let s = str::trim_left(s);
     if str::is_empty(s) { ret (none, s); }
     let start = str::char_at(s, 0u);
@@ -264,7 +264,7 @@ Function: from_str
 
 Deserializes a json value from a string.
 */
-fn from_str(s: str) -> option::t<json> {
+fn from_str(s: str) -> option<json> {
     let (j, _) = from_str_helper(s);
     j
 }
diff --git a/src/libstd/linux_os.rs b/src/libstd/linux_os.rs
index 82b1197a51f..378186c7850 100644
--- a/src/libstd/linux_os.rs
+++ b/src/libstd/linux_os.rs
@@ -123,7 +123,7 @@ fn dylib_filename(base: str) -> str { ret "lib" + base + ".so"; }
 
 /// Returns the directory containing the running program
 /// followed by a path separator
-fn get_exe_path() -> option::t<fs::path> {
+fn get_exe_path() -> option<fs::path> {
     let bufsize = 1023u;
     // FIXME: path "strings" will likely need fixing...
     let path = str::from_bytes(vec::init_elt(bufsize, 0u8));
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index e393b42b9f2..be6ce7338a3 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -61,8 +61,8 @@ Apply function `f` to each element of `v`, starting from the first.
 When function `f` returns true then an option containing the element
 is returned. If `f` matches no elements then none is returned.
 */
-fn find<T: copy, U: copy>(ls: list<T>, f: fn(T) -> option::t<U>)
-    -> option::t<U> {
+fn find<T: copy, U: copy>(ls: list<T>, f: fn(T) -> option<U>)
+    -> option<U> {
     let ls = ls;
     while true {
         alt ls {
@@ -259,7 +259,7 @@ mod tests {
 
     #[test]
     fn test_find_success() {
-        fn match(&&i: int) -> option::t<int> {
+        fn match(&&i: int) -> option<int> {
             ret if i == 2 { option::some(i) } else { option::none::<int> };
         }
         let l = from_vec([0, 1, 2]);
@@ -268,7 +268,7 @@ mod tests {
 
     #[test]
     fn test_find_fail() {
-        fn match(&&_i: int) -> option::t<int> { ret option::none::<int>; }
+        fn match(&&_i: int) -> option<int> { ret option::none::<int>; }
         let l = from_vec([0, 1, 2]);
         let empty = list::nil::<int>;
         assert (list::find(l, match) == option::none::<int>);
diff --git a/src/libstd/macos_os.rs b/src/libstd/macos_os.rs
index cd984870781..eb2efddc35b 100644
--- a/src/libstd/macos_os.rs
+++ b/src/libstd/macos_os.rs
@@ -131,7 +131,7 @@ fn target_os() -> str { ret "macos"; }
 
 fn dylib_filename(base: str) -> str { ret "lib" + base + ".dylib"; }
 
-fn get_exe_path() -> option::t<fs::path> {
+fn get_exe_path() -> option<fs::path> {
     // FIXME: This doesn't handle the case where the buffer is too small
     // FIXME: path "strings" will likely need fixing...
     let bufsize = 1023u32;
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index ed37318246b..3f53270ed10 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -75,14 +75,14 @@ iface map<K: copy, V: copy> {
     Get the value for the specified key. If the key does not exist
     in the map then returns none.
     */
-    fn find(K) -> option::t<V>;
+    fn find(K) -> option<V>;
     /*
     Method: remove
 
     Remove and return a value from the map. If the key does not exist
     in the map then returns none.
     */
-    fn remove(K) -> option::t<V>;
+    fn remove(K) -> option<V>;
     /*
     Method: items
 
@@ -205,7 +205,7 @@ mod chained {
         }
     }
 
-    fn get<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option::t<V> {
+    fn get<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option<V> {
         alt search_tbl(tbl, k, tbl.hasher(k)) {
           not_found {
             ret core::option::none;
@@ -221,7 +221,7 @@ mod chained {
         }
     }
 
-    fn remove<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option::t<V> {
+    fn remove<K: copy, V: copy>(tbl: t<K,V>, k: K) -> core::option<V> {
         alt search_tbl(tbl, k, tbl.hasher(k)) {
           not_found {
             ret core::option::none;
@@ -306,9 +306,9 @@ mod chained {
 
         fn get(k: K) -> V { option::get(get(self, k)) }
 
-        fn find(k: K) -> option::t<V> { get(self, k) }
+        fn find(k: K) -> option<V> { get(self, k) }
 
-        fn remove(k: K) -> option::t<V> { remove(self, k) }
+        fn remove(k: K) -> option<V> { remove(self, k) }
 
         fn items(blk: fn(K, V)) { items(self, blk); }
 
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index b181ba7475c..28cdbfa3d40 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -481,7 +481,7 @@ mod iterator {
               node::content(x) { ret node::leaf_iterator::start(x) }
             }
         }
-        fn next(it: node::leaf_iterator::t) -> option::t<node::leaf> {
+        fn next(it: node::leaf_iterator::t) -> option<node::leaf> {
             ret node::leaf_iterator::next(it);
         }
     }
@@ -492,7 +492,7 @@ mod iterator {
               node::content(x) { ret node::char_iterator::start(x) }
             }
         }
-        fn next(it: node::char_iterator::t) -> option::t<char> {
+        fn next(it: node::char_iterator::t) -> option<char> {
             ret node::char_iterator::next(it)
         }
     }
@@ -952,7 +952,7 @@ mod node {
     - `option::some(x)` otherwise, in which case `x` has the same contents
        as `node` bot lower height and/or fragmentation.
     */
-    fn bal(node: @node) -> option::t<@node> {
+    fn bal(node: @node) -> option<@node> {
         if height(node) < hint_max_node_height { ret option::none; }
         //1. Gather all leaves as a forest
         let forest = [mutable];
@@ -1230,7 +1230,7 @@ mod node {
             }
         }
 
-        fn next(it: t) -> option::t<leaf> {
+        fn next(it: t) -> option<leaf> {
             if it.stackpos < 0 { ret option::none; }
             while true {
                 let current = it.stack[it.stackpos];
@@ -1254,7 +1254,7 @@ mod node {
     mod char_iterator {
         type t = {
             leaf_iterator: leaf_iterator::t,
-            mutable leaf:  option::t<leaf>,
+            mutable leaf:  option<leaf>,
             mutable leaf_byte_pos: uint
         };
 
@@ -1274,7 +1274,7 @@ mod node {
             }
         }
 
-        fn next(it: t) -> option::t<char> {
+        fn next(it: t) -> option<char> {
             while true {
                 alt(get_current_or_next_leaf(it)) {
                   option::none { ret option::none; }
@@ -1294,7 +1294,7 @@ mod node {
             fail;//unreachable
         }
 
-        fn get_current_or_next_leaf(it: t) -> option::t<leaf> {
+        fn get_current_or_next_leaf(it: t) -> option<leaf> {
             alt(it.leaf) {
               option::some(_) { ret it.leaf }
               option::none {
@@ -1311,7 +1311,7 @@ mod node {
             }
         }
 
-        fn get_next_char_in_leaf(it: t) -> option::t<char> {
+        fn get_next_char_in_leaf(it: t) -> option<char> {
             alt(it.leaf) {
               option::none { ret option::none }
               option::some(aleaf) {
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index dada53f355b..d76e37e5071 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -12,7 +12,7 @@ import core::option::{some, none};
 /*
 Type: smallintmap
 */
-type smallintmap<T> = @{mutable v: [mutable option::t<T>]};
+type smallintmap<T> = @{mutable v: [mutable option<T>]};
 
 /*
 Function: mk
@@ -20,7 +20,7 @@ Function: mk
 Create a smallintmap
 */
 fn mk<T>() -> smallintmap<T> {
-    let v: [mutable option::t<T>] = [mutable];
+    let v: [mutable option<T>] = [mutable];
     ret @{mutable v: v};
 }
 
@@ -31,7 +31,7 @@ Add a value to the map. If the map already contains a value for
 the specified key then the original value is replaced.
 */
 fn insert<T: copy>(m: smallintmap<T>, key: uint, val: T) {
-    vec::grow_set::<option::t<T>>(m.v, key, none::<T>, some::<T>(val));
+    vec::grow_set::<option<T>>(m.v, key, none::<T>, some::<T>(val));
 }
 
 /*
@@ -40,8 +40,8 @@ Function: find
 Get the value for the specified key. If the key does not exist
 in the map then returns none
 */
-fn find<T: copy>(m: smallintmap<T>, key: uint) -> option::t<T> {
-    if key < vec::len::<option::t<T>>(m.v) { ret m.v[key]; }
+fn find<T: copy>(m: smallintmap<T>, key: uint) -> option<T> {
+    if key < vec::len::<option<T>>(m.v) { ret m.v[key]; }
     ret none::<T>;
 }
 
@@ -73,11 +73,11 @@ fn contains_key<T: copy>(m: smallintmap<T>, key: uint) -> bool {
 // FIXME: Are these really useful?
 
 fn truncate<T: copy>(m: smallintmap<T>, len: uint) {
-    m.v = vec::slice_mut::<option::t<T>>(m.v, 0u, len);
+    m.v = vec::slice_mut::<option<T>>(m.v, 0u, len);
 }
 
 fn max_key<T>(m: smallintmap<T>) -> uint {
-    ret vec::len::<option::t<T>>(m.v);
+    ret vec::len::<option<T>>(m.v);
 }
 
 /*
@@ -98,7 +98,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         insert(self, key, value);
         ret !exists;
     }
-    fn remove(&&key: uint) -> option::t<V> {
+    fn remove(&&key: uint) -> option<V> {
         if key >= vec::len(self.v) { ret none; }
         let old = self.v[key];
         self.v[key] = none;
@@ -108,7 +108,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         contains_key(self, key)
     }
     fn get(&&key: uint) -> V { get(self, key) }
-    fn find(&&key: uint) -> option::t<V> { find(self, key) }
+    fn find(&&key: uint) -> option<V> { find(self, key) }
     fn rehash() { fail }
     fn items(it: fn(&&uint, V)) {
         let idx = 0u;
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index 197c1a71cb0..eaf1409da1d 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -12,7 +12,7 @@ import rand;
 /*
 Function: mkdtemp
 */
-fn mkdtemp(prefix: str, suffix: str) -> option::t<str> {
+fn mkdtemp(prefix: str, suffix: str) -> option<str> {
     let r = rand::mk_rng();
     let i = 0u;
     while (i < 1000u) {
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 10b3545fc40..072850a6a65 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -56,7 +56,7 @@ fn test_main(args: [str], tests: [test_desc]) {
     if !run_tests_console(opts, tests) { fail "Some tests failed"; }
 }
 
-type test_opts = {filter: option::t<str>, run_ignored: bool};
+type test_opts = {filter: option<str>, run_ignored: bool};
 
 type opt_res = either::t<test_opts, str>;
 
@@ -248,7 +248,7 @@ fn filter_tests(opts: test_opts,
         };
 
         fn filter_fn(test: test_desc, filter_str: str) ->
-            option::t<test_desc> {
+            option<test_desc> {
             if str::find(test.name, filter_str) >= 0 {
                 ret option::some(test);
             } else { ret option::none; }
@@ -263,7 +263,7 @@ fn filter_tests(opts: test_opts,
     filtered = if !opts.run_ignored {
         filtered
     } else {
-        fn filter(test: test_desc) -> option::t<test_desc> {
+        fn filter(test: test_desc) -> option<test_desc> {
             if test.ignore {
                 ret option::some({name: test.name,
                                   fn: test.fn,
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 1c711952e0b..bcea14df377 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -10,7 +10,7 @@ red-black tree or something else.
 */
 
 import core::option::{some, none};
-import option = core::option::t;
+import option = core::option;
 
 export treemap;
 export init;
diff --git a/src/libstd/ufind.rs b/src/libstd/ufind.rs
index 322e3bf40c2..eee4c836277 100644
--- a/src/libstd/ufind.rs
+++ b/src/libstd/ufind.rs
@@ -6,7 +6,7 @@ import option::{some, none};
 // A very naive implementation of union-find with unsigned integer nodes.
 // Maintains the invariant that the root of a node is always equal to or less
 // than the node itself.
-type node = option::t<uint>;
+type node = option<uint>;
 
 type ufind = {mutable nodes: [mutable node]};
 
diff --git a/src/libstd/win32_os.rs b/src/libstd/win32_os.rs
index 83306c757a4..0d874da458a 100644
--- a/src/libstd/win32_os.rs
+++ b/src/libstd/win32_os.rs
@@ -111,7 +111,7 @@ fn waitpid(pid: pid_t) -> i32 { ret rustrt::rust_process_wait(pid); }
 
 fn getcwd() -> str { ret rustrt::rust_getcwd(); }
 
-fn get_exe_path() -> option::t<fs::path> {
+fn get_exe_path() -> option<fs::path> {
     // FIXME: This doesn't handle the case where the buffer is too small
     // FIXME: path "strings" will likely need fixing...
     let bufsize = 1023u;