---

yaml
---
r: 12276
b: refs/heads/master
c: 21be137
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e1858882a49bf0666d4ffb3f45989ac9dbe9c843
+refs/heads/master: 21be1379d561b6679a8a2ea47dce88f948c5acca
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/tutorial.md

@@ -919,7 +919,7 @@ for the parameter list, as in `{|| ...}`.
 Partial application is done using the `bind` keyword in Rust.
 
 ~~~~
-let daynum = bind vec::position_elem(["mo", "tu", "we", "do",
+let daynum = bind vec::position_elem(["mo", "tu", "we", "th",
                                       "fr", "sa", "su"], _);
 ~~~~
 
@@ -1551,7 +1551,7 @@ programs that just can't be typed.
 
 ~~~~
 let n = option::none;
-# option::may(n, fn&(&&x:int) {})
+# option::with_option_do(n, fn&(&&x:int) {})
 ~~~~
 
 If you never do anything else with `n`, the compiler will not be able

trunk/mk/rt.mk

@@ -64,7 +64,6 @@ RUNTIME_CS_$(1) := \
               rt/rust_port_selector.cpp \
               rt/circular_buffer.cpp \
               rt/isaac/randport.cpp \
-              rt/rust_srv.cpp \
               rt/rust_kernel.cpp \
               rt/rust_shape.cpp \
               rt/rust_abi.cpp \

trunk/src/compiletest/header.rs

@@ -40,7 +40,7 @@ fn load_props(testfile: str) -> test_props {
             pp_exact = parse_pp_exact(ln, testfile);
         }
 
-        option::may(parse_aux_build(ln)) {|ab|
+        option::with_option_do(parse_aux_build(ln)) {|ab|
             aux_builds += [ab];
         }
     };

trunk/src/libcore/iter.rs

@@ -29,7 +29,7 @@ impl<A> of iterable<A> for [A] {
 
 impl<A> of iterable<A> for option<A> {
     fn iter(blk: fn(A)) {
-        option::may(self, blk)
+        option::with_option_do(self, blk)
     }
 }
 

trunk/src/libcore/option.rs

@@ -52,19 +52,19 @@ pure fn is_some<T>(opt: option<T>) -> bool {
     !is_none(opt)
 }
 
-pure fn from_maybe<T: copy>(opt: option<T>, def: T) -> T {
+pure fn get_or_default<T: copy>(opt: option<T>, def: T) -> T {
     #[doc = "Returns the contained value or a default"];
 
     alt opt { some(x) { x } none { def } }
 }
 
-fn maybe<T, U: copy>(opt: option<T>, def: U, f: fn(T) -> U) -> U {
+fn with_option<T, U: copy>(opt: option<T>, def: U, f: fn(T) -> U) -> U {
     #[doc = "Applies a function to the contained value or returns a default"];
 
     alt opt { none { def } some(t) { f(t) } }
 }
 
-fn may<T>(opt: option<T>, f: fn(T)) {
+fn with_option_do<T>(opt: option<T>, f: fn(T)) {
     #[doc = "Performs an operation on the contained value or does nothing"];
 
     alt opt { none { } some(t) { f(t); } }
@@ -94,11 +94,12 @@ impl extensions<T:copy> for option<T> {
     "]
     fn chain<U>(f: fn(T) -> option<U>) -> option<U> { chain(self, f) }
     #[doc = "Returns the contained value or a default"]
-    fn from_maybe(def: T) -> T { from_maybe(self, def) }
+    fn get_or_default(def: T) -> T { get_or_default(self, def) }
     #[doc = "Applies a function to the contained value or returns a default"]
-    fn maybe<U: copy>(def: U, f: fn(T) -> U) -> U { maybe(self, def, f) }
+    fn with_option<U: copy>(def: U, f: fn(T) -> U) -> U
+        { with_option(self, def, f) }
     #[doc = "Performs an operation on the contained value or does nothing"]
-    fn may(f: fn(T)) { may(self, f) }
+    fn with_option_do(f: fn(T)) { with_option_do(self, f) }
     #[doc = "
     Gets the value out of an option
 

trunk/src/libcore/os.rs

@@ -702,7 +702,7 @@ mod tests {
         setenv("HOME", "");
         assert os::homedir() == none;
 
-        option::may(oldhome, {|s| setenv("HOME", s)});
+        option::with_option_do(oldhome, {|s| setenv("HOME", s)});
     }
 
     #[test]
@@ -732,8 +732,9 @@ mod tests {
         setenv("USERPROFILE", "/home/PaloAlto");
         assert os::homedir() == some("/home/MountainView");
 
-        option::may(oldhome, {|s| setenv("HOME", s)});
-        option::may(olduserprofile, {|s| setenv("USERPROFILE", s)});
+        option::with_option_do(oldhome, {|s| setenv("HOME", s)});
+        option::with_option_do(olduserprofile,
+                               {|s| setenv("USERPROFILE", s)});
     }
 
     // Issue #712

trunk/src/libcore/result.rs

@@ -20,10 +20,9 @@ If the result is an error
 pure fn get<T: copy, U>(res: result<T, U>) -> T {
     alt res {
       ok(t) { t }
-      err(_) {
-        // FIXME: Serialize the error value
-        // and include it in the fail message (maybe just note it)
-        fail "get called on error result";
+      err(the_err) {
+        // FIXME: have a run-fail test for this
+        unchecked{ fail #fmt("get called on error result: %?", the_err); }
       }
     }
 }

trunk/src/libcore/task.rs

@@ -498,7 +498,7 @@ fn spawn_raw(opts: task_opts, +f: fn~()) unsafe {
       }
     };
 
-    option::may(opts.notify_chan) {|c|
+    option::with_option_do(opts.notify_chan) {|c|
         // FIXME (1087): Would like to do notification in Rust
         rustrt::rust_task_config_notify(new_task, c);
     }

trunk/src/librustsyntax/diagnostic.rs

@@ -243,8 +243,8 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
 }
 
 fn print_macro_backtrace(cm: codemap::codemap, sp: span) {
-    option::may (sp.expn_info) {|ei|
-        let ss = option::maybe(ei.callie.span, "",
+    option::with_option_do (sp.expn_info) {|ei|
+        let ss = option::with_option(ei.callie.span, "",
                                bind codemap::span_to_str(_, cm));
         print_diagnostic(ss, note,
                          #fmt("in expansion of #%s", ei.callie.name));

trunk/src/librustsyntax/ext/qquote.rs

@@ -135,7 +135,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
     -> @ast::expr
 {
     let mut what = "expr";
-    option::may(arg) {|arg|
+    option::with_option_do(arg) {|arg|
         let args: [@ast::expr] =
             alt arg.node {
               ast::expr_vec(elts, _) { elts }

trunk/src/librustsyntax/parse/eval.rs

@@ -23,7 +23,7 @@ fn eval_crate_directives_to_mod(cx: ctx, cdirs: [@ast::crate_directive],
     -> (ast::_mod, [ast::attribute]) {
     #debug("eval crate prefix: %s", prefix);
     #debug("eval crate suffix: %s",
-           option::from_maybe(suffix, "none"));
+           option::get_or_default(suffix, "none"));
     let (cview_items, citems, cattrs)
         = parse_companion_mod(cx, prefix, suffix);
     let mut view_items: [@ast::view_item] = [];

trunk/src/librustsyntax/print/pprust.rs

@@ -792,7 +792,7 @@ fn print_mac(s: ps, m: ast::mac) {
           some(@{node: ast::expr_vec(_, _), _}) { }
           _ { word(s.s, " "); }
         }
-        option::may(arg, bind print_expr(s, _));
+        option::with_option_do(arg, bind print_expr(s, _));
         // FIXME: extension 'body'
       }
       ast::mac_embed_type(ty) {

trunk/src/librustsyntax/visit.rs

@@ -225,7 +225,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
       }
       pat_ident(path, inner) {
           visit_path(path, e, v);
-          option::may(inner, {|subpat| v.visit_pat(subpat, e, v)});
+          option::with_option_do(inner, {|subpat| v.visit_pat(subpat, e, v)});
       }
       pat_lit(ex) { v.visit_expr(ex, e, v); }
       pat_range(e1, e2) { v.visit_expr(e1, e, v); v.visit_expr(e2, e, v); }

trunk/src/rt/circular_buffer.cpp

@@ -12,26 +12,26 @@ circular_buffer::circular_buffer(rust_kernel *kernel, size_t unit_sz) :
     _unread(0),
     _buffer((uint8_t *)kernel->malloc(_buffer_sz, "circular_buffer")) {
 
-    A(kernel, unit_sz, "Unit size must be larger than zero.");
+    assert(unit_sz && "Unit size must be larger than zero.");
 
     KLOG(kernel, mem, "new circular_buffer(buffer_sz=%d, unread=%d)"
          "-> circular_buffer=0x%" PRIxPTR,
          _buffer_sz, _unread, this);
 
-    A(kernel, _buffer, "Failed to allocate buffer.");
+    assert(_buffer && "Failed to allocate buffer.");
 }
 
 circular_buffer::~circular_buffer() {
     KLOG(kernel, mem, "~circular_buffer 0x%" PRIxPTR, this);
-    I(kernel, _buffer);
-    W(kernel, _unread == 0,
-      "freeing circular_buffer with %d unread bytes", _unread);
+    assert(_buffer);
+    assert(_unread == 0 && "didn't expect bytes in the circular buffer");
+
     kernel->free(_buffer);
 }
 
 size_t
 circular_buffer::initial_size() {
-    I(kernel, unit_sz > 0);
+    assert(unit_sz > 0);
     return INITIAL_CIRCULAR_BUFFER_SIZE_IN_UNITS * unit_sz;
 }
 
@@ -40,8 +40,8 @@ circular_buffer::initial_size() {
  */
 void
 circular_buffer::transfer(void *dst) {
-    I(kernel, dst);
-    I(kernel, _unread <= _buffer_sz);
+    assert(dst);
+    assert(_unread <= _buffer_sz);
 
     uint8_t *ptr = (uint8_t *) dst;
 
@@ -53,13 +53,13 @@ circular_buffer::transfer(void *dst) {
     } else {
         head_sz = _buffer_sz - _next;
     }
-    I(kernel, _next + head_sz <= _buffer_sz);
+    assert(_next + head_sz <= _buffer_sz);
     memcpy(ptr, _buffer + _next, head_sz);
 
     // Then copy any other items from the beginning of the buffer
-    I(kernel, _unread >= head_sz);
+    assert(_unread >= head_sz);
     size_t tail_sz = _unread - head_sz;
-    I(kernel, head_sz + tail_sz <= _buffer_sz);
+    assert(head_sz + tail_sz <= _buffer_sz);
     memcpy(ptr + head_sz, _buffer, tail_sz);
 }
 
@@ -69,9 +69,9 @@ circular_buffer::transfer(void *dst) {
  */
 void
 circular_buffer::enqueue(void *src) {
-    I(kernel, src);
-    I(kernel, _unread <= _buffer_sz);
-    I(kernel, _buffer);
+    assert(src);
+    assert(_unread <= _buffer_sz);
+    assert(_buffer);
 
     // Grow if necessary.
     if (_unread == _buffer_sz) {
@@ -82,20 +82,20 @@ circular_buffer::enqueue(void *src) {
          "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
          _unread, _next, _buffer_sz, unit_sz);
 
-    I(kernel, _unread < _buffer_sz);
-    I(kernel, _unread + unit_sz <= _buffer_sz);
+    assert(_unread < _buffer_sz);
+    assert(_unread + unit_sz <= _buffer_sz);
 
     // Copy data
     size_t dst_idx = _next + _unread;
-    I(kernel, dst_idx >= _buffer_sz || dst_idx + unit_sz <= _buffer_sz);
+    assert(dst_idx >= _buffer_sz || dst_idx + unit_sz <= _buffer_sz);
     if (dst_idx >= _buffer_sz) {
         dst_idx -= _buffer_sz;
 
-        I(kernel, _next >= unit_sz);
-        I(kernel, dst_idx <= _next - unit_sz);
+        assert(_next >= unit_sz);
+        assert(dst_idx <= _next - unit_sz);
     }
 
-    I(kernel, dst_idx + unit_sz <= _buffer_sz);
+    assert(dst_idx + unit_sz <= _buffer_sz);
     memcpy(&_buffer[dst_idx], src, unit_sz);
     _unread += unit_sz;
 
@@ -109,17 +109,17 @@ circular_buffer::enqueue(void *src) {
  */
 void
 circular_buffer::dequeue(void *dst) {
-    I(kernel, unit_sz > 0);
-    I(kernel, _unread >= unit_sz);
-    I(kernel, _unread <= _buffer_sz);
-    I(kernel, _buffer);
+    assert(unit_sz > 0);
+    assert(_unread >= unit_sz);
+    assert(_unread <= _buffer_sz);
+    assert(_buffer);
 
     KLOG(kernel, mem,
              "circular_buffer dequeue "
              "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
              _unread, _next, _buffer_sz, unit_sz);
 
-    I(kernel, _next + unit_sz <= _buffer_sz);
+    assert(_next + unit_sz <= _buffer_sz);
     if (dst != NULL) {
         memcpy(dst, &_buffer[_next], unit_sz);
     }
@@ -153,7 +153,7 @@ circular_buffer::grow() {
 void
 circular_buffer::shrink() {
     size_t new_buffer_sz = _buffer_sz / 2;
-    I(kernel, initial_size() <= new_buffer_sz);
+    assert(initial_size() <= new_buffer_sz);
     KLOG(kernel, mem, "circular_buffer is shrinking to %d bytes",
          new_buffer_sz);
     void *new_buffer = kernel->malloc(new_buffer_sz,