Skip to content

Commit

Permalink
more tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@bobzhang
bobzhang committed Dec 24, 2017
1 parent a6e5631 commit 435a03e
Show file tree
Hide file tree
Showing 3 changed files with 241 additions and 44 deletions.
67 changes: 63 additions & 4 deletions jscomp/others/bs_List.ml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -137,7 +137,7 @@ let rec splitAux cell precX precY =
splitAux t nextA nextB

(* return the tail pointer so it can continue copy other
list
list
*)
let rec copyAuxCont cellX prec =
match cellX with
Expand Down Expand Up @@ -197,6 +197,66 @@ let rec copyAuxWithMapI f i cellX prec =
unsafeMutateTail prec next ;
copyAuxWithMapI f (i + 1) t next

let rec takeAux n cell prec =
if n = 0 then true
else
match cell with
| [] -> false
| x::xs ->
let cell = mutableCell x [] in
unsafeMutateTail prec cell;
takeAux (n - 1) xs cell

let rec splitAtAux n cell prec =
if n = 0 then Some cell
else
match cell with
| [] -> None
| x::xs ->
let cell = mutableCell x [] in
unsafeMutateTail prec cell;
splitAtAux (n - 1) xs cell

(* invarint [n >= 0] *)
let takeOpt lst n =
if n < 0 then None
else
if n = 0 then Some []
else
match lst with
| [] -> None
| x::xs ->
let cell = mutableCell x [] in
let has = takeAux (n-1) xs cell in
if has then Some cell
else None
(* invariant [n >= 0 ] *)
let rec dropAux l n =
if n = 0 then Some l
else
match l with
| _::tl -> dropAux tl (n -1)
| [] -> None

let dropOpt lst n =
if n < 0 then None
else
dropAux lst n

let splitAtOpt lst n =
if n < 0 then None
else
if n = 0 then Some ([],lst)
else
match lst with
| [] -> None
| x::xs ->
let cell = mutableCell x [] in
let rest = splitAtAux (n - 1) xs cell in
match rest with
| Some rest -> Some (cell, rest)
| None -> None

let append xs ys =
match xs with
| [] -> ys
Expand Down Expand Up @@ -433,15 +493,15 @@ let partition p l =
unsafeTail nextX, nextY


let rec split xs =
let rec unzip xs =
match xs with
| [] -> ([], [])
| (x,y)::l ->
let cellX = mutableCell x [] in
let cellY = mutableCell y [] in
splitAux l cellX cellY ;
cellX, cellY


let rec zip l1 l2 =
match (l1, l2) with
Expand All @@ -451,4 +511,3 @@ let rec zip l1 l2 =
zipAux l1 l2 cell;
cell

(* TODO: add take/drop*)
82 changes: 44 additions & 38 deletions jscomp/others/bs_List.mli
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,86 +24,92 @@

type 'a t = 'a list

val headOpt : 'a list -> 'a option
val headOpt : 'a t -> 'a option

val tailOpt : 'a list -> 'a list option
val tailOpt : 'a t -> 'a t option

val nthOpt : 'a list -> int -> 'a option
val nthOpt : 'a t -> int -> 'a option

val nthAssert : 'a list -> int -> 'a
val nthAssert : 'a t -> int -> 'a

val append : 'a list -> 'a t -> 'a t
val dropOpt : 'a t -> int -> 'a t option

val map : 'a list -> ('a -> 'b [@bs]) -> 'b t
val takeOpt : 'a t -> int -> 'a t option

val map2 : ('a -> 'b -> 'c [@bs]) -> 'a list -> 'b list -> 'c t
val splitAtOpt : 'a t -> int -> ('a list * 'a list) option

val mapi : (int -> 'a -> 'b [@bs]) -> 'a list -> 'b t
val append : 'a t -> 'a t -> 'a t

val map : 'a t -> ('a -> 'b [@bs]) -> 'b t

val map2 : ('a -> 'b -> 'c [@bs]) -> 'a t -> 'b t -> 'c t

val mapi : (int -> 'a -> 'b [@bs]) -> 'a t -> 'b t

val init : int -> (int -> 'a [@bs]) -> 'a t

val length : 'a list -> int
val length : 'a t -> int

val toArray : 'a t -> 'a array

val revAppend : 'a list -> 'a list -> 'a list
val revAppend : 'a t -> 'a t -> 'a t

val rev : 'a list -> 'a list
val rev : 'a t -> 'a t


val flatten : 'a list list -> 'a t
val flatten : 'a t t -> 'a t

val mapRev : ('a -> 'b [@bs]) -> 'a list -> 'b list
val mapRev : ('a -> 'b [@bs]) -> 'a t -> 'b t

val iter : ('a -> 'b [@bs]) -> 'a list -> unit
val iter : ('a -> 'b [@bs]) -> 'a t -> unit

val iteri : (int -> 'a -> 'b [@bs]) -> 'a list -> unit
val iteri : (int -> 'a -> 'b [@bs]) -> 'a t -> unit

val foldLeft : ('a -> 'b -> 'a [@bs]) -> 'a -> 'b list -> 'a
val foldLeft : ('a -> 'b -> 'a [@bs]) -> 'a -> 'b t -> 'a

val foldRight : ('a -> 'b -> 'b [@bs]) -> 'a list -> 'b -> 'b
val foldRight : ('a -> 'b -> 'b [@bs]) -> 'a t -> 'b -> 'b

val mapRev2 : ('a -> 'b -> 'c [@bs]) -> 'a list -> 'b list -> 'd list
val mapRev2 : ('a -> 'b -> 'c [@bs]) -> 'a t -> 'b t -> 'd t

val iter2 : ('a -> 'b -> 'c [@bs]) -> 'a list -> 'b list -> unit
val iter2 : ('a -> 'b -> 'c [@bs]) -> 'a t -> 'b t -> unit

val foldLeft2 :
('a -> 'b -> 'c -> 'a [@bs]) -> 'a -> 'b list -> 'c list -> 'a
('a -> 'b -> 'c -> 'a [@bs]) -> 'a -> 'b t -> 'c t -> 'a

val foldRight2 :
('a -> 'b -> 'c -> 'c [@bs]) -> 'a list -> 'b list -> 'c -> 'c
('a -> 'b -> 'c -> 'c [@bs]) -> 'a t -> 'b t -> 'c -> 'c

val forAll : ('a -> bool [@bs]) -> 'a list -> bool
val forAll : ('a -> bool [@bs]) -> 'a t -> bool

val exists : ('a -> bool [@bs]) -> 'a list -> bool
val exists : ('a -> bool [@bs]) -> 'a t -> bool

val forAll2 : ('a -> 'b -> bool [@bs]) -> 'a list -> 'b list -> bool
val forAll2 : ('a -> 'b -> bool [@bs]) -> 'a t -> 'b t -> bool

val exists2 : ('a -> 'b -> bool [@bs]) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool [@bs]) -> 'a t -> 'b t -> bool

val mem : ('a -> 'b -> bool [@bs]) -> 'b -> 'a list -> bool
val mem : ('a -> 'b -> bool [@bs]) -> 'b -> 'a t -> bool

val memq : 'a -> 'a list -> bool
val memq : 'a -> 'a t -> bool

val assocOpt : ('a -> 'b -> bool [@bs]) -> 'b -> ('a * 'c) list -> 'c option
val assocOpt : ('a -> 'b -> bool [@bs]) -> 'b -> ('a * 'c) t -> 'c option

val assqOpt : 'a -> ('a * 'b) list -> 'b option
val assqOpt : 'a -> ('a * 'b) t -> 'b option

val memAssoc : ('a -> 'b -> bool [@bs]) -> 'b -> ('a * 'c) list -> bool
val memAssoc : ('a -> 'b -> bool [@bs]) -> 'b -> ('a * 'c) t -> bool

val memAssq : 'a -> ('a * 'b) list -> bool
val memAssq : 'a -> ('a * 'b) t -> bool

val removeAssoc :
('a -> 'b -> bool [@bs]) -> 'b -> ('a * 'c) list -> ('a * 'c) list
('a -> 'b -> bool [@bs]) -> 'b -> ('a * 'c) t -> ('a * 'c) t

val removeAssq : 'a -> ('a * 'b) list -> ('a * 'b) list
val removeAssq : 'a -> ('a * 'b) t -> ('a * 'b) t

val findOpt : ('a -> bool [@bs]) -> 'a list -> 'a option
val findOpt : ('a -> bool [@bs]) -> 'a t -> 'a option

val filter : ('a -> bool [@bs]) -> 'a list -> 'a t
val filter : ('a -> bool [@bs]) -> 'a t -> 'a t

val partition : ('a -> bool [@bs]) -> 'a list -> 'a t * 'a t
val partition : ('a -> bool [@bs]) -> 'a t -> 'a t * 'a t

val split : ('a * 'b) list -> 'a t * 'b t
val unzip : ('a * 'b) t -> 'a t * 'b t

val zip : 'a list -> 'b list -> ('a * 'b) t
val zip : 'a t -> 'b t -> ('a * 'b) t
136 changes: 134 additions & 2 deletions lib/js/bs_List.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -276,6 +276,135 @@ function copyAuxWithMapI(f, _i, _cellX, _prec) {
};
}

function takeAux(_n, _cell, _prec) {
while(true) {
var prec = _prec;
var cell = _cell;
var n = _n;
if (n) {
if (cell) {
var cell$1 = /* :: */[
cell[0],
/* [] */0
];
prec[1] = cell$1;
_prec = cell$1;
_cell = cell[1];
_n = n - 1 | 0;
continue ;

} else {
return /* false */0;
}
} else {
return /* true */1;
}
};
}

function splitAtAux(_n, _cell, _prec) {
while(true) {
var prec = _prec;
var cell = _cell;
var n = _n;
if (n) {
if (cell) {
var cell$1 = /* :: */[
cell[0],
/* [] */0
];
prec[1] = cell$1;
_prec = cell$1;
_cell = cell[1];
_n = n - 1 | 0;
continue ;

} else {
return /* None */0;
}
} else {
return /* Some */[cell];
}
};
}

function takeOpt(lst, n) {
if (n < 0) {
return /* None */0;
} else if (n) {
if (lst) {
var cell = /* :: */[
lst[0],
/* [] */0
];
var has = takeAux(n - 1 | 0, lst[1], cell);
if (has) {
return /* Some */[cell];
} else {
return /* None */0;
}
} else {
return /* None */0;
}
} else {
return /* Some */[/* [] */0];
}
}

function dropOpt(lst, n) {
if (n < 0) {
return /* None */0;
} else {
var _l = lst;
var _n = n;
while(true) {
var n$1 = _n;
var l = _l;
if (n$1) {
if (l) {
_n = n$1 - 1 | 0;
_l = l[1];
continue ;

} else {
return /* None */0;
}
} else {
return /* Some */[l];
}
};
}
}

function splitAtOpt(lst, n) {
if (n < 0) {
return /* None */0;
} else if (n) {
if (lst) {
var cell = /* :: */[
lst[0],
/* [] */0
];
var rest = splitAtAux(n - 1 | 0, lst[1], cell);
if (rest) {
return /* Some */[/* tuple */[
cell,
rest[0]
]];
} else {
return /* None */0;
}
} else {
return /* None */0;
}
} else {
return /* Some */[/* tuple */[
/* [] */0,
lst
]];
}
}

function append(xs, ys) {
if (xs) {
var cell = /* :: */[
Expand Down Expand Up @@ -904,7 +1033,7 @@ function partition(p, l) {
}
}

function split(xs) {
function unzip(xs) {
if (xs) {
var match = xs[0];
var cellX = /* :: */[
Expand Down Expand Up @@ -952,6 +1081,9 @@ exports.headOpt = headOpt;
exports.tailOpt = tailOpt;
exports.nthOpt = nthOpt;
exports.nthAssert = nthAssert;
exports.dropOpt = dropOpt;
exports.takeOpt = takeOpt;
exports.splitAtOpt = splitAtOpt;
exports.append = append;
exports.map = map;
exports.map2 = map2;
Expand Down Expand Up @@ -986,6 +1118,6 @@ exports.removeAssq = removeAssq;
exports.findOpt = findOpt;
exports.filter = filter;
exports.partition = partition;
exports.split = split;
exports.unzip = unzip;
exports.zip = zip;
/* No side effect */

0 comments on commit 435a03e

Please sign in to comment.