(fn slice (list idx) (do
    (let list_len (len list))
    (let elems (list))
    (let i idx)
    (loop (do
        (if (>= i list_len) (break))
        (push elems (at list i))
        (+= i 1)
    ))
    (return elems)
))

(fn slice_eq (str slice_idx substr) (do
    (let str_len (len str))
    (let substr_len (len substr))
    (let i 0)
    (loop (do
        (if (>= i substr_len)
            (return true))
        (if (>= (+ slice_idx i) str_len)
            (return false))
        (if (!= (at str (+ slice_idx i)) (at substr i))
            (return false))
        (+= i 1)
    ))
    (return true)
))


(fn contains (text ch) (do
    (let text_len (len text))
    (let i 0)
    (loop (do
        (if (>= i text_len) (break))
        (if (== (at text i) ch) (do
            (return true)
        ))
        (+= i 1)
    ))
    (return false)
))

(fn indent (depth) (do
    (let space "")
    (let i 0)
    (loop (do
        (if (>= i depth) (break))
        (+= space "  ")
        (+= i 1)
    ))
    (return space)    
))

(fn list_push (list_ value) (do
    (let list_len (len list_))
    (let i 0)
    (loop (do
        (if (>= i list_len) (break))
        (if (== (at list_ i) null) (do
            (set list_ i value)
            (return)
        ))
        (+= i 1)
    ))
    (push list_ value)
))

(fn list_pop (list_) (do
    (let i (- (len list_) 1))
    (loop (do
        (if (< i 0) (break))
        (let value (at list_ i))
        (if (!= value null) (do
            (set list_ i null)
            (return value)
        ))
        (-= i 1)
    ))
    (return null)
))

(fn list_contains (list_ value) (do
    (for elem list_ (do
        (if (== elem value) (do
            (return true)
        ))
    ))
    (return false)
))

(fn map () (do
    (return (list))
))

(fn map_has (map key) (do
    (for (m_key _) map (do
        (if (== m_key key) (do
            (return true)
        ))
    ))
    (return false)
))

(fn map_get (map key) (do
    (for (m_key value) map (do
        (if (== m_key key) (do
            (return value)
        ))
    ))
    (return null)
))

(fn map_set (map key value) (do
    (for entry map (do
        (let (entry_key _) entry)
        (if (== entry_key key) (do
            (set entry 1 value)
            (return)
        ))
    ))
    (push map (list key value))
))