import "Prelude" hiding (length, contains, iter, for)
import "Prelude" as Prelude
import "JavaBuiltin" as Java

importJava "java.util.ArrayList" where
    "Type of lists."
    data T a
    
    "Constructs a new list."
    @JavaName "<init>"
    new :: () -> <Proc> (T a)
    
    "Constructs a new list with initial capacity."
    @JavaName "<init>"
    newC :: Integer -> <Proc> (T a)
    
    "Adds an element to the list."
    add :: T a -> a -> <Proc> ()
    
    addAll :: T a -> [a] -> <Proc> ()
    
    "Gets the i:th element of the list."
    get :: T a -> Integer -> <Proc> a
    
    "Sets the i:th element of the list."
    set :: T a -> Integer -> a -> <Proc> a
    
    "Removes the i:th element of the list"
    remove :: T a -> Integer -> <Proc> a
    
    "The current length of the list."
    @JavaName size
    length :: T a -> <Proc> Integer
    
contains :: T a -> a -> <Proc> Boolean
contains l a = loop 0
  where
    len = length l
    loop i = if i >= len 
             then False
             else if get l i == a
             then True
             else loop (i+1)

"Converts the mutable list into immutable list. The original list must not be modified anymore."
freeze :: T a -> <Proc> [a]
freeze = Java.unsafeCoerce

"Iterates thru the list. The elements added during the iteration are also iterated."
iter :: (a -> <e> ()) -> T a -> <Proc,e> ()
iter f l = loop 0
  where
    loop i = if i >= length l 
             then ()
             else do f (get l i) ; loop (i+1)

"'iter' with swapped parameter."
for :: T a -> (a -> <e> ()) -> <Proc,e> ()
for l f = iter f l

"Replaces every element of the list by the result of applying the element to the given function."
mapInPlace :: (a -> <e> a) -> T a -> <Proc,e> T a
mapInPlace f l = loop 0
  where
    len = length l
    loop i = if i >= len 
             then l
             else do set l i (f (get l i))
                     loop (i+1)

"Pops the last element of the list until list becomes empty."
popUntilEmpty :: T a -> (a -> <e> ()) -> <Proc,e> ()
popUntilEmpty l f = do
    len = length l
    if len == 0
    then ()
    else do f (remove l (len-1))
            popUntilEmpty l f

fromList :: [a] -> <Proc> T a
fromList l = do
    result = newC (Prelude.length l)
    addAll result l
    result