}
```
-To decode a json string using `Decodable` trait :
+To decode a JSON string using `Decodable` trait :
```rust
extern crate serialize;
{data_int: 1, data_str:~"toto", data_vector:~[2,3,4,5]};
let encoded_str: ~str = json::Encoder::str_encode(&to_encode_object);
- // To unserialize use the `extra::json::from_str` and `extra::json::Decoder`
+ // To deserialize use the `extra::json::from_str` and `extra::json::Decoder`
let json_object = extra::json::from_str(encoded_str);
let mut decoder = json::Decoder::new(json_object.unwrap());
## Using `ToJson`
-This example use the ToJson impl to unserialize the json string.
+This example use the ToJson impl to deserialize the JSON string.
Example of `ToJson` trait implementation for TestStruct1.
```rust
}
fn main() {
- // Seralization using our impl of to_json
+ // Serialization using our impl of to_json
let test2: TestStruct1 = TestStruct1 {data_int: 1, data_str:~"toto", data_vector:~[2,3,4,5]};
let tjson: json::Json = test2.to_json();
let json_str: ~str = tjson.to_str();
- // Unserialize like before.
+ // Deserialize like before.
let mut decoder = json::Decoder::new(json::from_str(json_str).unwrap());
// create the final object
// Benchmarking
-/// A function that is opaque to the optimiser, to allow benchmarks to
+/// A function that is opaque to the optimizer, to allow benchmarks to
/// pretend to use outputs to assist in avoiding dead-code
/// elimination.
///
/// A flag to tell the scheduler loop it needs to do some stealing
/// in order to introduce randomness as part of a yield
steal_for_yield: bool,
- /// Bookeeping for the number of tasks which are currently running around
+ /// Bookkeeping for the number of tasks which are currently running around
/// inside this pool of schedulers
task_state: TaskState,
}
}
- /// Waits for an event on this port set. The returned valus is *not* and
+ /// Waits for an event on this port set. The returned value is *not* an
/// index, but rather an id. This id can be queried against any active
/// `Handle` structures (each one has an `id` method). The handle with
/// the matching `id` will have some sort of event available on it. The
///
/// Since connection attempts can continue forever, this iterator always returns
/// `Some`. The `Some` contains the `IoResult` representing whether the
-/// connection attempt was succesful. A successful connection will be wrapped
+/// connection attempt was successful. A successful connection will be wrapped
/// in `Ok`. A failed connection is represented as an `Err`.
pub struct IncomingConnections<'a, A> {
priv inc: &'a mut A,
/// ```
fn min(&mut self) -> Option<A>;
- /// `min_max` finds the mininum and maximum elements in the iterator.
+ /// `min_max` finds the minimum and maximum elements in the iterator.
///
/// The return type `MinMaxResult` is an enum of three variants:
/// - `NoElements` if the iterator is empty.
ops.deschedule(amt, self, f)
}
- /// Wakes up a previously blocked task, optionally specifiying whether the
+ /// Wakes up a previously blocked task, optionally specifying whether the
/// current task can accept a change in scheduling. This function can only
/// be called on tasks that were previously blocked in `deschedule`.
pub fn reawaken(mut ~self) {
/// The entry point for unwinding with a formatted message.
///
/// This is designed to reduce the amount of code required at the call
-/// site as much as possible (so that `fail!()` has as low an implact
+/// site as much as possible (so that `fail!()` has as low an impact
/// on (e.g.) the inlining of other functions as possible), by moving
/// the actual formatting into this shared place.
#[inline(never)] #[cold]
///
/// Note that the current implementation means that this function cannot
/// return `Option<T>`. It is possible for this queue to be in an
- /// inconsistent state where many pushes have suceeded and completely
+ /// inconsistent state where many pushes have succeeded and completely
/// finished, but pops cannot return `Some(t)`. This inconsistent state
/// happens when a pusher is pre-empted at an inopportune moment.
///
}
}
}
-
/// Acquires a mutex, blocking the current task until it is able to do so.
///
- /// This function will block the local task until it is availble to acquire
+ /// This function will block the local task until it is available to acquire
/// the mutex. Upon returning, the task is the only task with the mutex
/// held. An RAII guard is returned to allow scoped unlock of the lock. When
/// the guard goes out of scope, the mutex will be unlocked.
projects / rust.git / commitdiff