---

yaml
---
r: 80714
b: refs/heads/try
c: 2b5f4b5
h: refs/heads/master
v: v3

Author: fhahn

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 0c89183e8080430b49f45ddaae9b8e2775034d5e
+refs/heads/try: 2b5f4b55c0238932ee991102b612858d4b3deb6c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rust.md

@@ -2459,12 +2459,25 @@ do k(3) |j| {
 ### For expressions
 
 ~~~~~~~~{.ebnf .gram}
-for_expr : "for" pat "in" expr '{' block '}' ;
+for_expr : "for" expr [ '|' ident_list '|' ] ? '{' block '}' ;
 ~~~~~~~~
 
-A `for` expression is a syntactic construct for looping
-over elements provided by an implementation of
-`std::iterator::Iterator`.
+A _for expression_ is similar to a [`do` expression](#do-expressions),
+in that it provides a special block-form of lambda expression,
+suited to passing the `block` function to a higher-order function implementing a loop.
+
+In contrast to a `do` expression, a `for` expression is designed to work
+with methods such as `each` and `times`, that require the body block to
+return a boolean. The `for` expression accommodates this by implicitly
+returning `true` at the end of each block, unless a `break` expression
+is evaluated.
+
+In addition, [`break`](#break-expressions) and [`loop`](#loop-expressions) expressions
+are rewritten inside `for` expressions in the same way that `return` expressions are,
+with a combination of local flag variables,
+and early boolean-valued returns from the `block` function,
+such that the meaning of `break` and `loop` is preserved in a primitive loop
+when rewritten as a `for` loop controlled by a higher order function.
 
 An example of a for loop over the contents of a vector:
 

branches/try/mk/rt.mk

@@ -75,7 +75,6 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/rust_rng.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \
-              rt/rust_crate_map.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
               rt/memory_region.cpp \

branches/try/src/libextra/comm.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -90,55 +90,9 @@ pub fn DuplexStream<T:Send,U:Send>()
      })
 }
 
-/// An extension of `pipes::stream` that provides synchronous message sending.
-pub struct SyncChan<T> { priv duplex_stream: DuplexStream<T, ()> }
-/// An extension of `pipes::stream` that acknowledges each message received.
-pub struct SyncPort<T> { priv duplex_stream: DuplexStream<(), T> }
-
-impl<T: Send> GenericChan<T> for SyncChan<T> {
-    fn send(&self, val: T) {
-        assert!(self.try_send(val), "SyncChan.send: receiving port closed");
-    }
-}
-
-impl<T: Send> GenericSmartChan<T> for SyncChan<T> {
-    /// Sends a message, or report if the receiver has closed the connection before receiving.
-    fn try_send(&self, val: T) -> bool {
-        self.duplex_stream.try_send(val) && self.duplex_stream.try_recv().is_some()
-    }
-}
-
-impl<T: Send> GenericPort<T> for SyncPort<T> {
-    fn recv(&self) -> T {
-        self.try_recv().expect("SyncPort.recv: sending channel closed")
-    }
-
-    fn try_recv(&self) -> Option<T> {
-        do self.duplex_stream.try_recv().map_move |val| {
-            self.duplex_stream.try_send(());
-            val
-        }
-    }
-}
-
-impl<T: Send> Peekable<T> for SyncPort<T> {
-    fn peek(&self) -> bool {
-        self.duplex_stream.peek()
-    }
-}
-
-/// Creates a stream whose channel, upon sending a message, blocks until the message is received.
-pub fn rendezvous<T: Send>() -> (SyncPort<T>, SyncChan<T>) {
-    let (chan_stream, port_stream) = DuplexStream();
-    (SyncPort { duplex_stream: port_stream }, SyncChan { duplex_stream: chan_stream })
-}
-
 #[cfg(test)]
 mod test {
-    use comm::{DuplexStream, rendezvous};
-    use std::rt::test::run_in_newsched_task;
-    use std::task::spawn_unlinked;
-
+    use comm::DuplexStream;
 
     #[test]
     pub fn DuplexStream1() {
@@ -150,58 +104,4 @@ mod test {
         assert!(left.recv() == 123);
         assert!(right.recv() == ~"abc");
     }
-
-    #[test]
-    pub fn basic_rendezvous_test() {
-        let (port, chan) = rendezvous();
-
-        do spawn {
-            chan.send("abc");
-        }
-
-        assert!(port.recv() == "abc");
-    }
-
-    #[test]
-    fn recv_a_lot() {
-        // Rendezvous streams should be able to handle any number of messages being sent
-        do run_in_newsched_task {
-            let (port, chan) = rendezvous();
-            do spawn {
-                do 1000000.times { chan.send(()) }
-            }
-            do 1000000.times { port.recv() }
-        }
-    }
-
-    #[test]
-    fn send_and_fail_and_try_recv() {
-        let (port, chan) = rendezvous();
-        do spawn_unlinked {
-            chan.duplex_stream.send(()); // Can't access this field outside this module
-            fail!()
-        }
-        port.recv()
-    }
-
-    #[test]
-    fn try_send_and_recv_then_fail_before_ack() {
-        let (port, chan) = rendezvous();
-        do spawn_unlinked {
-            port.duplex_stream.recv();
-            fail!()
-        }
-        chan.try_send(());
-    }
-
-    #[test]
-    #[should_fail]
-    fn send_and_recv_then_fail_before_ack() {
-        let (port, chan) = rendezvous();
-        do spawn_unlinked {
-            port.duplex_stream.recv();
-            fail!()
-        }
-        chan.send(());
-    }
 }

branches/try/src/libextra/glob.rs

@@ -147,14 +147,8 @@ enum PatternToken {
     Char(char),
     AnyChar,
     AnySequence,
-    AnyWithin(~[CharSpecifier]),
-    AnyExcept(~[CharSpecifier])
-}
-
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
-enum CharSpecifier {
-    SingleChar(char),
-    CharRange(char, char)
+    AnyWithin(~[char]),
+    AnyExcept(~[char])
 }
 
 #[deriving(Eq)]
@@ -170,15 +164,12 @@ impl Pattern {
      * This function compiles Unix shell style patterns: `?` matches any single character,
      * `*` matches any (possibly empty) sequence of characters and `[...]` matches any character
      * inside the brackets, unless the first character is `!` in which case it matches any
-     * character except those between the `!` and the `]`. Character sequences can also specify
-     * ranges of characters, as ordered by Unicode, so e.g. `[0-9]` specifies any character
-     * between 0 and 9 inclusive.
+     * character except those between the `!` and the `]`.
      *
      * The metacharacters `?`, `*`, `[`, `]` can be matched by using brackets (e.g. `[?]`).
      * When a `]` occurs immediately following `[` or `[!` then it is interpreted as
      * being part of, rather then ending, the character set, so `]` and NOT `]` can be
-     * matched by `[]]` and `[!]]` respectively. The `-` character can be specified inside a
-     * character sequence pattern by placing it at the start or the end, e.g. `[abc-]`.
+     * matched by `[]]` and `[!]]` respectively.
      *
      * When a `[` does not have a closing `]` before the end of the string then the `[` will
      * be treated literally.
@@ -208,8 +199,7 @@ impl Pattern {
                         match chars.slice_from(i + 3).position_elem(&']') {
                             None => (),
                             Some(j) => {
-                                let cs = parse_char_specifiers(chars.slice(i + 2, i + 3 + j));
-                                tokens.push(AnyExcept(cs));
+                                tokens.push(AnyExcept(chars.slice(i + 2, i + 3 + j).to_owned()));
                                 i += j + 4;
                                 loop;
                             }
@@ -219,8 +209,7 @@ impl Pattern {
                         match chars.slice_from(i + 2).position_elem(&']') {
                             None => (),
                             Some(j) => {
-                                let cs = parse_char_specifiers(chars.slice(i + 1, i + 2 + j));
-                                tokens.push(AnyWithin(cs));
+                                tokens.push(AnyWithin(chars.slice(i + 1, i + 2 + j).to_owned()));
                                 i += j + 3;
                                 loop;
                             }
@@ -346,11 +335,15 @@ impl Pattern {
                         AnyChar => {
                             !require_literal(c)
                         }
-                        AnyWithin(ref specifiers) => {
-                            !require_literal(c) && in_char_specifiers(*specifiers, c, options)
+                        AnyWithin(ref chars) => {
+                            !require_literal(c) &&
+                            chars.iter()
+                                .rposition(|&e| chars_eq(e, c, options.case_sensitive)).is_some()
                         }
-                        AnyExcept(ref specifiers) => {
-                            !require_literal(c) && !in_char_specifiers(*specifiers, c, options)
+                        AnyExcept(ref chars) => {
+                            !require_literal(c) &&
+                            chars.iter()
+                                .rposition(|&e| chars_eq(e, c, options.case_sensitive)).is_none()
                         }
                         Char(c2) => {
                             chars_eq(c, c2, options.case_sensitive)
@@ -377,63 +370,6 @@ impl Pattern {
 
 }
 
-fn parse_char_specifiers(s: &[char]) -> ~[CharSpecifier] {
-    let mut cs = ~[];
-    let mut i = 0;
-    while i < s.len() {
-        if i + 3 <= s.len() && s[i + 1] == '-' {
-            cs.push(CharRange(s[i], s[i + 2]));
-            i += 3;
-        } else {
-            cs.push(SingleChar(s[i]));
-            i += 1;
-        }
-    }
-    cs
-}
-
-fn in_char_specifiers(specifiers: &[CharSpecifier], c: char, options: MatchOptions) -> bool {
-
-    for &specifier in specifiers.iter() {
-        match specifier {
-            SingleChar(sc) => {
-                if chars_eq(c, sc, options.case_sensitive) {
-                    return true;
-                }
-            }
-            CharRange(start, end) => {
-
-                // FIXME: work with non-ascii chars properly (issue #1347)
-                if !options.case_sensitive && c.is_ascii() && start.is_ascii() && end.is_ascii() {
-
-                    let start = start.to_ascii().to_lower();
-                    let end = end.to_ascii().to_lower();
-
-                    let start_up = start.to_upper();
-                    let end_up = end.to_upper();
-
-                    // only allow case insensitive matching when
-                    // both start and end are within a-z or A-Z
-                    if start != start_up && end != end_up {
-                        let start = start.to_char();
-                        let end = end.to_char();
-                        let c = c.to_ascii().to_lower().to_char();
-                        if c >= start && c <= end {
-                            return true;
-                        }
-                    }
-                }
-
-                if c >= start && c <= end {
-                    return true;
-                }
-            }
-        }
-    }
-
-    false
-}
-
 /// A helper function to determine if two chars are (possibly case-insensitively) equal.
 fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool {
     if cfg!(windows) && path::windows::is_sep(a) && path::windows::is_sep(b) {
@@ -736,54 +672,6 @@ mod test {
         glob("/*/*/*/*").skip(10000).next();
     }
 
-    #[test]
-    fn test_range_pattern() {
-
-        let pat = Pattern::new("a[0-9]b");
-        for i in range(0, 10) {
-            assert!(pat.matches(fmt!("a%db", i)));
-        }
-        assert!(!pat.matches("a_b"));
-
-        let pat = Pattern::new("a[!0-9]b");
-        for i in range(0, 10) {
-            assert!(!pat.matches(fmt!("a%db", i)));
-        }
-        assert!(pat.matches("a_b"));
-
-        let pats = ["[a-z123]", "[1a-z23]", "[123a-z]"];
-        for &p in pats.iter() {
-            let pat = Pattern::new(p);
-            for c in "abcdefghijklmnopqrstuvwxyz".iter() {
-                assert!(pat.matches(c.to_str()));
-            }
-            for c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ".iter() {
-                let options = MatchOptions {case_sensitive: false, .. MatchOptions::new()};
-                assert!(pat.matches_with(c.to_str(), options));
-            }
-            assert!(pat.matches("1"));
-            assert!(pat.matches("2"));
-            assert!(pat.matches("3"));
-        }
-
-        let pats = ["[abc-]", "[-abc]", "[a-c-]"];
-        for &p in pats.iter() {
-            let pat = Pattern::new(p);
-            assert!(pat.matches("a"));
-            assert!(pat.matches("b"));
-            assert!(pat.matches("c"));
-            assert!(pat.matches("-"));
-            assert!(!pat.matches("d"));
-        }
-
-        let pat = Pattern::new("[2-1]");
-        assert!(!pat.matches("1"));
-        assert!(!pat.matches("2"));
-
-        assert!(Pattern::new("[-]").matches("-"));
-        assert!(!Pattern::new("[!-]").matches("-"));
-    }
-
     #[test]
     fn test_unclosed_bracket() {
         // unclosed `[` should be treated literally