Operations and constants for i64

Const max_value

T

Const min_value

T

Interface eq

Method eq

fn eq(&&other: self) -> bool

Interface ord

Interfaces used for comparison.

Method lt

fn lt(&&other: self) -> bool

Implementation eq of eq for T

Method eq

fn eq(&&other: T) -> bool

Implementation num of num::num for T

Method add

fn add(&&other: T) -> T

Method sub

fn sub(&&other: T) -> T

Method mul

fn mul(&&other: T) -> T

Method div

fn div(&&other: T) -> T

Method modulo

fn modulo(&&other: T) -> T

Method neg

fn neg() -> T

Method to_int

fn to_int() -> int

Method from_int

fn from_int(n: int) -> T

Implementation ord of ord for T

Method lt

fn lt(&&other: T) -> bool

Implementation times of iter::times for T

Method times

fn times(it: fn() -> bool)

A convenience form for basic iteration. Given a variable x of any numeric type, the expression for x.times { /* anything */ } will execute the given function exactly x times. If we assume that x is an int, this is functionally equivalent to for int::range(0, x) |_i| { /* anything */ }.

Function abs

pure fn abs(i: T) -> T

Computes the absolute value

Function add

pure fn add(&&x: T, &&y: T) -> T

Function compl

pure fn compl(i: T) -> T

Computes the bitwise complement

Function div

pure fn div(&&x: T, &&y: T) -> T

Function eq

pure fn eq(&&x: T, &&y: T) -> bool

Function from_str

fn from_str(s: str) -> option<T>

Parse a string to an int

Function ge

pure fn ge(&&x: T, &&y: T) -> bool

Function gt

pure fn gt(&&x: T, &&y: T) -> bool

Function is_negative

pure fn is_negative(x: T) -> bool

Function is_nonnegative

pure fn is_nonnegative(x: T) -> bool

Function is_nonpositive

pure fn is_nonpositive(x: T) -> bool

Function is_positive

pure fn is_positive(x: T) -> bool

Function le

pure fn le(&&x: T, &&y: T) -> bool

Function lt

pure fn lt(&&x: T, &&y: T) -> bool

Function max

pure fn max(&&x: T, &&y: T) -> T

Function min

pure fn min(&&x: T, &&y: T) -> T

Function mul

pure fn mul(&&x: T, &&y: T) -> T

Function ne

pure fn ne(&&x: T, &&y: T) -> bool

Function parse_buf

fn parse_buf(buf: ~[u8], radix: uint) -> option<T>

Parse a buffer of bytes

Arguments

Function range

fn range(lo: T, hi: T, it: fn(T) -> bool)

Iterate over the range [lo..hi)

Function rem

pure fn rem(&&x: T, &&y: T) -> T

Function str

fn str(i: T) -> str

Convert to a string

Function sub

pure fn sub(&&x: T, &&y: T) -> T

Function to_str

fn to_str(n: T, radix: uint) -> str

Convert to a string in a given base

Function to_str_bytes

fn to_str_bytes<U>(n: T, radix: uint, f: fn(v: & [u8]) -> U) -> U