;;; 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" ::

;;; cons
;; a q1 -> q2
;; Prepends %:a%% to %:q1%%.
(
  swap quote swap cat
) "cons" ::

;;; 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" ::

;;; begins
;; s1 s2 -> s3
;; Pushes $0x1$$ on the stack if %:s1%% begins with %:s2%%, or $0x0$$ otherwise.
(
  "_begins_prefix" :
  "_begins_s"      :
  0x1 "_begins_result" :
  0x0 "_begins_c" :
  (_begins_s len _begins_prefix len <)
    (0x0 "_begins_result" :)
    (
      (
        _begins_c _begins_prefix len <
        _begins_result and
      )
        (
          (
            _begins_prefix _begins_c get
            _begins_s _begins_c get ==
          )
            (_begins_c 0x1 + "_begins_c" :)
            (0x0 "_begins_result" :)
          if  
        )
      while
    )
  if
  _begins_result
  "_begins_result" #
  "_begins_prefix" #
  "_begins_s"      #
  "_begins_c"      # 
) "begins" ::

;;; ends
;; s1 s2 -> s3
;; Pushes $0x1$$ on the stack if %:s1%% ends with %:s2%%, or $0x0$$ otherwise.
(
  "_ends_suffix" :
  "_ends_s"      :
  0x1 "_ends_result" :
  _ends_suffix len 0x1 - "_ends_c" :
  (_ends_s len _ends_suffix len <)
    (0x0 "_ends_result" :)
    (
      _ends_s len _ends_suffix len - "_ends_offset" :
      (
        _ends_c 0x0 >=
        _ends_result and
      )
        (
          (
            _ends_suffix _ends_c get
            _ends_s _ends_offset _ends_c + get ==
          )
            (_ends_c 0x1 - "_ends_c" :)
            (0x0 "_ends_result" :)
          if  
        )
      while
    )
  if
  _ends_result
  "_ends_suffix" #
  "_ends_s"      #
  "_ends_c"      # 
  "_ends_offset" #
) "ends" ::

;;; cleanup
;; s ->
;; Frees all symbols starting with %:s%%.
(
  "_cleanup_prefix" :
  0x0 "_cleanup_c" :
  (_cleanup_c symbols len <)
    (
      symbols _cleanup_c get "_cleanup_item" :
      (_cleanup_item _cleanup_prefix begins)
        (_cleanup_item #)
      when 
      _cleanup_c 0x1 + "_cleanup_c" :
    )
  while
  "_cleanup_prefix" #
  "_cleanup_item"   #
  "_cleanup_c"      #
) "cleanup" ::

;; insert
;; q1 a i -> q2
;; Inserts item %:a%% at position %:i%% within a quotation.
(
  i "_insert_index" :
  "_insert_item" :
  i "_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" ::


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

;;; 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" ::

;;; sort
;; q1 q2 -> q3
;; Sorts the items of a quotation.
(
  "_sort_check" :
  "_sort_list" :
  () "_sort_result" :
  _sort_list _len 0x1 - "_sort_pivot" :
  0x0 "_sort_c" :
  () "_sort_left" :
  () "_sort_right" :
  (0x1 _sort_list len <=)
    (_sort_list)
    (
      (_sort_c len <)
        (
          (_sort_list _sort_c get _sort_pivot _sort_check .)
            (_sort_left _sort_item push "_sort_left" :)
            (_sort_right _sort_item push "_sort_right" :)
          if
          _sort_c 0x1 + "_sort_c" :
        )
      while
      _sort_left sort _sort_pivot ' _sort_right sort 
      cat cat "_sort_result" :
    )
  if
  _sort_result
  "_sort_check"  #
  "_sort_list"   #
  "_sort_result" #
  "_sort_pivot"  #
  "_sort_c"      #
  "_sort_left"   #
  "_sort_right"  #
) "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_" cleanup
  "_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" ::