Move the option type to its own module
This commit is contained in:
Patrick Walton
parent
e399926776
commit
adb1754e4d
14 changed files with 115 additions and 93 deletions
|
|
@ -1,5 +1,5 @@
|
|||
import vbuf = rustrt.vbuf;
|
||||
import op = util.operator;
|
||||
import std.option;
|
||||
|
||||
native "rust" mod rustrt {
|
||||
type vbuf;
|
||||
|
|
@ -129,7 +129,7 @@ fn grow[T](&mutable vec[T] v, int n, &T initval) {
|
|||
}
|
||||
}
|
||||
|
||||
fn map[T, U](&op[T,U] f, &vec[T] v) -> vec[U] {
|
||||
fn map[T, U](&option.operator[T,U] f, &vec[T] v) -> vec[U] {
|
||||
let vec[U] u = alloc[U](len[T](v));
|
||||
for (T ve in v) {
|
||||
u += vec(f(ve));
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
* A deque, for fun. Untested as of yet. Likely buggy.
|
||||
*/
|
||||
|
||||
import std.util;
|
||||
import std.option;
|
||||
import std._vec;
|
||||
import std._int;
|
||||
|
||||
|
|
@ -23,7 +23,7 @@ type t[T] = obj {
|
|||
|
||||
fn create[T]() -> t[T] {
|
||||
|
||||
type cell[T] = mutable util.option[T];
|
||||
type cell[T] = mutable option.t[T];
|
||||
|
||||
let uint initial_capacity = 32u; // 2^5
|
||||
|
||||
|
|
@ -39,7 +39,7 @@ fn create[T]() -> t[T] {
|
|||
if (i < nelts) {
|
||||
ret old.((lo + i) % nelts);
|
||||
} else {
|
||||
ret util.none[T];
|
||||
ret option.none[T];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ fn create[T]() -> t[T] {
|
|||
|
||||
fn get[T](vec[cell[T]] elts, uint i) -> T {
|
||||
alt (elts.(i)) {
|
||||
case (util.some[T](?t)) { ret t; }
|
||||
case (option.some[T](?t)) { ret t; }
|
||||
case (_) { fail; }
|
||||
}
|
||||
}
|
||||
|
|
@ -77,7 +77,7 @@ fn create[T]() -> t[T] {
|
|||
hi = nelts;
|
||||
}
|
||||
|
||||
elts.(lo) = util.some[T](t);
|
||||
elts.(lo) = option.some[T](t);
|
||||
nelts += 1u;
|
||||
}
|
||||
|
||||
|
|
@ -88,7 +88,7 @@ fn create[T]() -> t[T] {
|
|||
hi = nelts;
|
||||
}
|
||||
|
||||
elts.(hi) = util.some[T](t);
|
||||
elts.(hi) = option.some[T](t);
|
||||
hi = (hi + 1u) % _vec.len[cell[T]](elts);
|
||||
nelts += 1u;
|
||||
}
|
||||
|
|
@ -99,7 +99,7 @@ fn create[T]() -> t[T] {
|
|||
*/
|
||||
fn pop_front() -> T {
|
||||
let T t = get[T](elts, lo);
|
||||
elts.(lo) = util.none[T];
|
||||
elts.(lo) = option.none[T];
|
||||
lo = (lo + 1u) % _vec.len[cell[T]](elts);
|
||||
nelts -= 1u;
|
||||
ret t;
|
||||
|
|
@ -113,7 +113,7 @@ fn create[T]() -> t[T] {
|
|||
}
|
||||
|
||||
let T t = get[T](elts, hi);
|
||||
elts.(hi) = util.none[T];
|
||||
elts.(hi) = option.none[T];
|
||||
nelts -= 1u;
|
||||
ret t;
|
||||
}
|
||||
|
|
@ -132,7 +132,7 @@ fn create[T]() -> t[T] {
|
|||
}
|
||||
|
||||
}
|
||||
let vec[cell[T]] v = _vec.init_elt[cell[T]](util.none[T],
|
||||
let vec[cell[T]] v = _vec.init_elt[cell[T]](option.none[T],
|
||||
initial_capacity);
|
||||
|
||||
ret deque[T](0u, 0u, 0u, v);
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
import util.option;
|
||||
import util.some;
|
||||
import util.none;
|
||||
import std.option;
|
||||
import option.some;
|
||||
import option.none;
|
||||
|
||||
// FIXME: It would probably be more appealing to define this as
|
||||
// type list[T] = rec(T hd, option[@list[T]] tl), but at the moment
|
||||
|
|
@ -27,7 +27,7 @@ fn foldl[T,U](&list[T] ls, &U u, fn(&T t, U u) -> U f) -> U {
|
|||
}
|
||||
|
||||
fn find[T,U](&list[T] ls,
|
||||
(fn(&T) -> option[U]) f) -> option[U] {
|
||||
(fn(&T) -> option.t[U]) f) -> option.t[U] {
|
||||
alt(ls) {
|
||||
case (cons[T](?hd, ?tl)) {
|
||||
alt (f(hd)) {
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
import std._int;
|
||||
import std.sys;
|
||||
import std.util;
|
||||
import std.option;
|
||||
import std._vec;
|
||||
|
||||
|
||||
|
|
@ -17,8 +17,8 @@ abs state type hashmap[K, V] = state obj {
|
|||
fn insert(&K key, &V val) -> bool;
|
||||
fn contains_key(&K key) -> bool;
|
||||
fn get(&K key) -> V;
|
||||
fn find(&K key) -> util.option[V];
|
||||
fn remove(&K key) -> util.option[V];
|
||||
fn find(&K key) -> option.t[V];
|
||||
fn remove(&K key) -> option.t[V];
|
||||
fn rehash();
|
||||
iter items() -> tup(K,V);
|
||||
};
|
||||
|
|
@ -103,7 +103,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
|
|||
vec[mutable bucket[K, V]] bkts,
|
||||
uint nbkts,
|
||||
&K key)
|
||||
-> util.option[V]
|
||||
-> option.t[V]
|
||||
{
|
||||
let uint i = 0u;
|
||||
while (i < nbkts) {
|
||||
|
|
@ -111,17 +111,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
|
|||
alt (bkts.(j)) {
|
||||
case (some[K, V](?k, ?v)) {
|
||||
if (eqer(key, k)) {
|
||||
ret util.some[V](v);
|
||||
ret option.some[V](v);
|
||||
}
|
||||
}
|
||||
case (nil[K, V]) {
|
||||
ret util.none[V];
|
||||
ret option.none[V];
|
||||
}
|
||||
case (deleted[K, V]) { }
|
||||
}
|
||||
i += 1u;
|
||||
}
|
||||
ret util.none[V];
|
||||
ret option.none[V];
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -173,25 +173,25 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
|
|||
|
||||
fn contains_key(&K key) -> bool {
|
||||
alt (find_common[K, V](hasher, eqer, bkts, nbkts, key)) {
|
||||
case (util.some[V](_)) { ret true; }
|
||||
case (option.some[V](_)) { ret true; }
|
||||
case (_) { ret false; }
|
||||
}
|
||||
}
|
||||
|
||||
fn get(&K key) -> V {
|
||||
alt (find_common[K, V](hasher, eqer, bkts, nbkts, key)) {
|
||||
case (util.some[V](?val)) { ret val; }
|
||||
case (option.some[V](?val)) { ret val; }
|
||||
case (_) { fail; }
|
||||
}
|
||||
}
|
||||
|
||||
fn find(&K key) -> util.option[V] {
|
||||
fn find(&K key) -> option.t[V] {
|
||||
// FIXME: should be 'be' but parametric tail-calls don't
|
||||
// work at the moment.
|
||||
ret find_common[K, V](hasher, eqer, bkts, nbkts, key);
|
||||
}
|
||||
|
||||
fn remove(&K key) -> util.option[V] {
|
||||
fn remove(&K key) -> option.t[V] {
|
||||
let uint i = 0u;
|
||||
while (i < nbkts) {
|
||||
let uint j = (hash[K](hasher, nbkts, key, i));
|
||||
|
|
@ -200,17 +200,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
|
|||
if (eqer(key, k)) {
|
||||
bkts.(j) = deleted[K, V];
|
||||
nelts -= 1u;
|
||||
ret util.some[V](v);
|
||||
ret option.some[V](v);
|
||||
}
|
||||
}
|
||||
case (deleted[K, V]) { }
|
||||
case (nil[K, V]) {
|
||||
ret util.none[V];
|
||||
ret option.none[V];
|
||||
}
|
||||
}
|
||||
i += 1u;
|
||||
}
|
||||
ret util.none[V];
|
||||
ret option.none[V];
|
||||
}
|
||||
|
||||
fn rehash() {
|
||||
|
|
|
|||
40
src/lib/option.rs
Normal file
40
src/lib/option.rs
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
// lib/option.rs
|
||||
|
||||
tag t[T] {
|
||||
none;
|
||||
some(T);
|
||||
}
|
||||
|
||||
type operator[T, U] = fn(&T) -> U;
|
||||
|
||||
fn get[T](&t[T] opt) -> T {
|
||||
alt (opt) {
|
||||
case (some[T](?x)) {
|
||||
ret x;
|
||||
}
|
||||
case (none[T]) {
|
||||
fail;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn map[T, U](&operator[T, U] f, &t[T] opt) -> t[U] {
|
||||
alt (opt) {
|
||||
case (some[T](?x)) {
|
||||
ret some[U](f(x));
|
||||
}
|
||||
case (none[T]) {
|
||||
ret none[U];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Local Variables:
|
||||
// mode: rust;
|
||||
// fill-column: 78;
|
||||
// indent-tabs-mode: nil
|
||||
// c-basic-offset: 4
|
||||
// buffer-file-coding-system: utf-8-unix
|
||||
// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
|
||||
// End:
|
||||
|
||||
|
|
@ -20,6 +20,7 @@ mod _task;
|
|||
|
||||
// Utility modules.
|
||||
|
||||
mod option;
|
||||
mod util;
|
||||
|
||||
// Authorize various rule-bendings.
|
||||
|
|
|
|||
|
|
@ -1,21 +1,3 @@
|
|||
tag option[T] {
|
||||
none;
|
||||
some(T);
|
||||
}
|
||||
|
||||
type operator[T, U] = fn(&T) -> U;
|
||||
|
||||
fn option_map[T, U](&operator[T, U] f, &option[T] opt) -> option[U] {
|
||||
alt (opt) {
|
||||
case (some[T](?x)) {
|
||||
ret some[U](f(x));
|
||||
}
|
||||
case (none[T]) {
|
||||
ret none[U];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn id[T](&T x) -> T {
|
||||
ret x;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue