2011-12-20 14:29:59 -06:00
|
|
|
// Top-level, visible-everywhere definitions.
|
|
|
|
|
2012-03-02 19:20:00 -06:00
|
|
|
// Export various ubiquitous types, constructors, methods.
|
2011-12-20 14:29:59 -06:00
|
|
|
|
2012-02-21 11:23:01 -06:00
|
|
|
import option::{some, none};
|
2012-03-13 16:39:28 -05:00
|
|
|
import option = option::option;
|
2012-03-02 19:20:00 -06:00
|
|
|
import path = path::path;
|
2012-03-16 19:35:38 -05:00
|
|
|
import str::extensions;
|
2012-03-17 20:02:45 -05:00
|
|
|
import vec::extensions;
|
2012-03-16 19:49:58 -05:00
|
|
|
import option::extensions;
|
2012-04-11 23:45:18 -05:00
|
|
|
import option_iter::extensions;
|
2012-04-15 23:46:29 -05:00
|
|
|
import ptr::extensions;
|
2012-05-17 13:52:49 -05:00
|
|
|
import rand::extensions;
|
2012-06-22 19:33:53 -05:00
|
|
|
import result::extensions;
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
import int::{num, times};
|
|
|
|
import i8::{num, times};
|
|
|
|
import i16::{num, times};
|
|
|
|
import i32::{num, times};
|
|
|
|
import i64::{num, times};
|
|
|
|
import uint::{num, times};
|
|
|
|
import u8::{num, times};
|
|
|
|
import u16::{num, times};
|
|
|
|
import u32::{num, times};
|
|
|
|
import u64::{num, times};
|
2012-06-25 15:41:13 -05:00
|
|
|
import float::num;
|
|
|
|
import f32::num;
|
|
|
|
import f64::num;
|
2012-03-17 20:02:45 -05:00
|
|
|
|
|
|
|
export path, option, some, none, unreachable;
|
2012-03-16 19:35:38 -05:00
|
|
|
export extensions;
|
2012-06-23 23:05:52 -05:00
|
|
|
// The following exports are the extension impls for numeric types
|
A new `times` method on numeric types
This method is intended to elegantly subsume two common iteration functions.
The first is `iter::range`, which is used identically to the method introduced
in this commit, but currently works only on uints. The second is a common case
of `{int, i8, uint, etc.}::range`, in the case where the inductive variable is
ignored. Compare the usage of the three:
```
for iter::range(100u) {
// do whatever
}
for int::range(0, 100) |_i| {
// do whatever
}
for 100.times {
// do whatever
}
```
I feel that the latter reads much more nicely than the first two approaches,
and unlike the first two the new method allows the user to ignore the specific
type of the number (ineed, if we're throwing away the inductive variable, who
cares what type it is?). A minor benefit is that this new method will be
somewhat familiar to users of Ruby, from which we borrow the name "times".
2012-07-05 21:12:26 -05:00
|
|
|
export num, times;
|
2011-12-20 14:29:59 -06:00
|
|
|
|
|
|
|
// Export the log levels as global constants. Higher levels mean
|
|
|
|
// more-verbosity. Error is the bottom level, default logging level is
|
|
|
|
// warn-and-below.
|
|
|
|
|
2011-12-22 12:30:04 -06:00
|
|
|
export error, warn, info, debug;
|
2012-01-24 02:54:17 -06:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// The error log level
|
2011-12-22 12:30:04 -06:00
|
|
|
const error : u32 = 0_u32;
|
2012-07-04 16:53:12 -05:00
|
|
|
/// The warning log level
|
2011-12-22 12:30:04 -06:00
|
|
|
const warn : u32 = 1_u32;
|
2012-07-04 16:53:12 -05:00
|
|
|
/// The info log level
|
2011-12-22 12:30:04 -06:00
|
|
|
const info : u32 = 2_u32;
|
2012-07-04 16:53:12 -05:00
|
|
|
/// The debug log level
|
2011-12-22 12:30:04 -06:00
|
|
|
const debug : u32 = 3_u32;
|
2011-12-22 16:42:52 -06:00
|
|
|
|
|
|
|
// A curious inner-module that's not exported that contains the binding
|
|
|
|
// 'core' so that macro-expanded references to core::error and such
|
|
|
|
// can be resolved within libcore.
|
|
|
|
mod core {
|
|
|
|
const error : u32 = 0_u32;
|
|
|
|
const warn : u32 = 1_u32;
|
|
|
|
const info : u32 = 2_u32;
|
|
|
|
const debug : u32 = 3_u32;
|
2012-01-17 18:45:22 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Similar to above. Some magic to make core testable.
|
|
|
|
#[cfg(test)]
|
|
|
|
mod std {
|
2012-07-11 11:09:08 -05:00
|
|
|
use std(vers = "0.3");
|
2012-01-17 18:45:22 -06:00
|
|
|
import std::test;
|
2012-01-20 10:12:03 -06:00
|
|
|
}
|
2012-03-08 16:29:17 -06:00
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* A standard function to use to indicate unreachable code. Because the
|
|
|
|
* function is guaranteed to fail typestate will correctly identify
|
|
|
|
* any code paths following the appearance of this function as unreachable.
|
|
|
|
*/
|
2012-03-08 16:29:17 -06:00
|
|
|
fn unreachable() -> ! {
|
|
|
|
fail "Internal error: entered unreachable code";
|
|
|
|
}
|
|
|
|
|