;;; dputs
;; a -> a
;; Duplicates and prints (with newline) the top item on the stack.
(dup puts) "dputs" ::

;;; when
;; q1 q2 -> *
;; If %:q1%% pushes 0x1 on the stack, dequotes %:q2%%.
(
  ()
  if
) "when" ::

;;; unless
;; q1 q2 -> *
;; If %:q1%% pushes 0x0 on the stack, dequotes %:q2%%.
(
  ()
  swap
  if
) "unless" ::

;;; push
;; q1 a -> q2
;; Appends %:a%% to the end of %:q1%%.
(
  ' cat
) "push" ::

;;; pop
;; q1 -> q2
;; Removes the last item at the end of %:q1%%.
(
  "_pop_q" :
  () "_pop_res" :
  0x0 "_pop_c" :
  (_pop_c _pop_q len 0x1 - <)
    (
      _pop_res _pop_q _pop_c get push "_pop_res" :
      _pop_c 0x1 + "_pop_c" :
    )
  while
  _pop_res
  "_pop_q"   #
  "_pop_res" #
  "_pop_c"   #
) "pop" ::

;;; cons
;; a q1 -> q2
;; Prepends %:a%% to the beginning of %:q1%%.
(
  swap ' swap cat
) "cons" ::

;;; uncons
;; q1 -> a q2
;; Removes the first item from %:q1%% and pushes it on the stack along with %:q2%% containing the rest of the items of %:q1%%.
(
  "_uncons_list" :
  () "_uncons_result" :
  0x1 "_uncons_c" :
  (_uncons_c _uncons_list len <)
    (
      _uncons_result _uncons_list _uncons_c get push "_uncons_result" :
      _uncons_c 0x1 + "_uncons_c" :
    )
  while
  _uncons_list 0x0 get ; Push the first item
  _uncons_result ; Push the rest of the items
  "_uncons_list"   #
  "_uncons_result" #
  "_uncons_c"      #
) "uncons" ::

;;; swons
;; q1 a -> q2
;; Prepends %:a%% to the beginning of %:q1%%.
(
  ' swap cat
) "swons" ::

;;; unswons
;; q1 -> q2 a
;; Removes the first item from %:q1%% and pushes it on the stack along with %:q2%% containing the rest of the items of %:q1%%.
(
  "_unswons_list" :
  () "_unswons_result" :
  0x1 "_unswons_c" :
  (_unswons_c _unswons_list len <)
    (
      _unswons_result _unswons_list _unswons_c get push "_unswons_result" :
      _unswons_c 0x1 + "_unswons_c" :
    )
  while
  _unswons_result ; Push the rest of the items
  _unswons_list 0x0 get ; Push the first item
  "_unswons_list"   #
  "_unswons_result" #
  "_unswons_c"      #
) "unswons" ::

;;; over
;; a1 a2 -> a1 a2 a1
;; Copies the second item on the stack and pushes it on top
(
  "_over_a" :
  dup _over_a swap
  "_over_a" #
) "over" ::

;;; dip
;; a1 (a2) -> a2 a1
;; Dequotes the first item on the stack and restores the second item on top.
(
  swap ' cat .
) "dip" ::

;;; begins
;; s1 s2 -> s3
;; Pushes $0x1$$ on the stack if %:s1%% begins with %:s2%%, or $0x0$$ otherwise.
(
  index 0x0 ==
) "begins" ::

;;; ends
;; s1 s2 -> s3
;; Pushes $0x1$$ on the stack if %:s1%% ends with %:s2%%, or $0x0$$ otherwise.
(
  "_ends_suffix" :
  "_ends_s"      :
  _ends_s _ends_suffix index 
  _ends_s len _ends_suffix len -
  ==
  "_ends_suffix" #
  "_ends_s"      #
) "ends" ::

;; insert
;; q1 a i -> q2
;; Inserts item %:a%% before position %:i%% within a quotation.
(
  "_insert_index" :
  "_insert_item" :
  "_insert_list" :
  0x0 "_insert_c" :
  () "_insert_result" :
  _insert_list len "_insert_len" :
  (_insert_index _insert_len >= _insert_index 0x0 < or)
    ("[symbol insert] Index out of bounds" throw)
  when
  (_insert_c _insert_len <)
    (
      (_insert_c _insert_index ==)
        (_insert_result _insert_item ' cat "_insert_result" :)
      when
      _insert_result _insert_list  _insert_c get ' cat "_insert_result" :
      _insert_c 0x1 + "_insert_c" :
    )
  while
  _insert_result
  "_insert_index"   #
  "_insert_item"    #
  "_insert_list"    #
  "_insert_c"       #
  "_insert_result"  #
  "_insert_len"     #
) "insert" ::

;;; reverse
;; q1 -> q2
;; Reverses the order of the items in a quotation.
(
  "_reverse_list" :
  _reverse_list len 0x1 - "_reverse_c" : 
  () "_reverse_result" :
  (_reverse_c 0x0 >=)
    (
       _reverse_result _reverse_list _reverse_c get ' cat "_reverse_result" :
       _reverse_c 0x1 - "_reverse_c" :
    )
  while
  _reverse_result
  "_reverse_list"   #
  "_reverse_c"      # 
  "_reverse_result" # 
) "reverse" ::

;;; set
;; q1 a i -> q2
;; Sets the item at index %:i%% of %:q1%% to %:a%%.
(
  "_set_index" :
  "_set_item"  :
  "_set_list"  :
  () "_set_result" :
  (_set_index _set_list len >= dputs _set_index 0x0 < or)
    ("[symbol set] Index out of bounds" throw)
  when
  0x0 "_set_c" :
  (_set_c _set_list len <)
    (
      (_set_c _set_index ==)
        (_set_result _set_item ' cat "_set_result" :)
        (_set_result _set_list  _set_c get ' cat "_set_result" :)
      if
      _set_c 0x1 + "_set_c" :
    )
  while
  _set_result
  "_set_index"   #
  "_set_c"       #
  "_set_item"    #
  "_set_list"    #
  "_set_result"  #
) "set" ::

;;; sort
;; q1 q2 -> q3
;; Sorts the items of q1 based on q2.
(
  "_sort_check" :
  "_sort_list" :
  0x0 "_sort_i" :
  0x0 "_sort_j" :
  0x0 "_sort_current" :
  0x0 "_sort_next" :
  (_sort_i _sort_list len 0x1 - <=)
    (
      (_sort_j _sort_list len _sort_i - 0x1 - <=)
        (
          _sort_list _sort_j get "_sort_current" :
          _sort_list _sort_j 0x1 + get "_sort_next" :
          (_sort_current _sort_next _sort_check 0x1 ==)
            (
              _sort_list 
                _sort_current _sort_j 0x1 + set
                _sort_next _sort_j set
              "_sort_list" :
            )
          when
          _sort_j 0x1 + "_sort_j" :
        )
      while
      _sort_i 0x1 + "_sort_i" :
    )
  while
  _sort_list
  "_sort_list" #
  "_sort_check" #
  "_sort_j" #
  "_sort_current" #
  "_sort_next" #
  "_sort_i" #

) "sort" ::

;;; gsub
;; s1 s2 s3 -> s4
;; Replaces all occurrences of %:s2%% with %%s3%% in %:s1%%.
(
  "_gsub_rep"  :
  "_gsub_src"  :
  "_gsub_text" :
  (_gsub_text _gsub_src index 0x0 >=)
    (_gsub_text _gsub_src _gsub_rep replace "_gsub_text" :)
  while
  _gsub_text
  "_gsub_rep"  #
  "_gsub_src"  #
  "_gsub_text" #
) "gsub" :

;;; min
;; q -> a
;; Pushes the minimum item in a quotation on the stack.
(
  "_min_list" :
  () "_min_result" :
  0x0 get "_min_result" :
  0x1 "_min_c" :
  (_min_c len <)
    (
      (_min_result _min_list _min_c get <)
        (_min_list _min_c get "_min_result" :)
      when
    )
  while
  _min_result
  "_min_list"   #
  "_min_result" #
  "_min_result" #
  "_min_c"      #
) "min" ::

;;; max
;; q -> a
;; Pushes the maximum item in a quotation on the stack.
(
  "_max_list" :
  () "_max_result" :
  0x0 get "_max_result" :
  0x1 "_max_c" :
  (_max_c len <)
    (
      (_max_result _max_list _max_c get >)
        (_max_list _max_c get "_max_result" :)
      when
    )
  while
  _max_result
  "_max_list"   #
  "_max_result" #
  "_max_result" #
  "_max_c"      #
) "max" ::

;;; intpl
;; s1 q -> s2
;; Substitutes %:$0%% to %%$9%% placeholders in %:s1%% with items in %:q%%.
(
  "_intpl_s" :
  "_intpl_q" :
  0x0 "_intpl_c" :
  (_intpl_c _intpl_s len <)
     (
       _intpl_s "$" _intpl_c str cat _intpl_list _intpl_c get cat gsub "_intpl_s" :
       _intpl_c 0x1 + "_intpl_c" :
     )
   while
  "_intpl_s" #
  "_intpl_q" #
  "_intpl_c" #
) "intpl" ::

;;; each
;; q1 q2 -> *
;; Applies %:q2%% to each element of %:q1%%.
(
  0x0 ' cat map pop
) "each" ::

;;; filter
;; q1 q2-> q3
;; Returns %:q3%% containing only the elements of %:q1%% that satisfy %:q2%%.
(
  "_filter_fn" :
  "_filter_list" :
  () "_filter_result" :
  _filter_list (
    "_filter_each_item" :
    (_filter_each_item _filter_fn)
      (
        _filter_result _filter_each_item push "_filter_result" :
      ) 
    when
  ) each
  _filter_result
  "_filter_fn"     #
  "_filter_list"   #
  "_filter_result" #
) "filter" ::

;;; slice
;; s1 i1 i2 -> s2
;; Extracts the portion of the string between indices %:i1%% and %:i2%%.
(
  "_slice_end" :
  "_slice_start" :
  "_slice_str" :
  (_slice_start _slice_end <)
    (0x0 "_slice_result" :)
    (
      _slice_str _slice_start get _slice_result : 
      _slice_start 0x1 + "_slice_start" :
    )
  while
  "_slice_end"   #
  "_slice_start" #
  "_slice_str"   #
) "slice" ::