diff --git a/jscomp/others/bs_List.ml b/jscomp/others/bs_List.ml
index ef8980549d..acf40f5515 100644
--- a/jscomp/others/bs_List.ml
+++ b/jscomp/others/bs_List.ml
@@ -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
@@ -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
@@ -433,7 +493,7 @@ let partition p l =
       unsafeTail nextX, nextY 
 
 
-let rec split xs = 
+let rec unzip xs = 
   match xs with 
   | [] -> ([], [])
   | (x,y)::l ->
@@ -441,7 +501,7 @@ let rec split xs =
     let cellY = mutableCell y [] in 
     splitAux l cellX cellY ; 
     cellX, cellY
-    
+
 
 let rec zip l1 l2 =
   match (l1, l2) with
@@ -451,4 +511,3 @@ let rec zip l1 l2 =
     zipAux l1 l2 cell; 
     cell
 
-(* TODO: add take/drop*)
\ No newline at end of file
diff --git a/jscomp/others/bs_List.mli b/jscomp/others/bs_List.mli
index 4616abb5c3..9e822dbc3c 100644
--- a/jscomp/others/bs_List.mli
+++ b/jscomp/others/bs_List.mli
@@ -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
diff --git a/lib/js/bs_List.js b/lib/js/bs_List.js
index 5d19959626..88561d17f5 100644
--- a/lib/js/bs_List.js
+++ b/lib/js/bs_List.js
@@ -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 = /* :: */[
@@ -904,7 +1033,7 @@ function partition(p, l) {
   }
 }
 
-function split(xs) {
+function unzip(xs) {
   if (xs) {
     var match = xs[0];
     var cellX = /* :: */[
@@ -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;
@@ -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 */