I think the idiom is to use symbolic expressions with clear meaning, but lisp does famously provide a lisp-powered macro system, so we could make an iterative "slicer".

```
(defun iteratively-slice (s c n)
  "#step[(&optional start stop) seq]⮕ slice, inclusive limits"
  (declare (ignore c))
  (destructuring-bind
      (start stop)
      (read s)
    (let* ((input (read s))
	   (step (or n 1))
	   (start (or start 0))
	   (stop (or stop (length input))))
      (peek-char #\\] s nil nil t)
      (read-char s nil nil t)
      `(loop :with new-vector
	       := (make-array 0 :adjustable t
				:fill-pointer 0)
	     :with input-sequence := ,input
	     :for idx :from ,start
	     ,(if (> stop start) :to :downto) ,stop
	     :by ,step
	     :do (vector-push-extend (elt input-sequence idx)
				     new-vector)
	     :finally (return new-vector)))))
(set-dispatch-macro-character #\\# #\\[ #'iteratively-slice)
#2[(6 2) "hello there" ]
```
Elliding the `defun`,

```
CL-USER> (set-dispatch-macro-character #\\# #\\[ #'iteratively-slice)
T
CL-USER> #2[(6 2) "hello there" ]
#(#\\t #\\o #\\l)
CL-USER> 
```

where I guess my lisp `#2[(6 2) "hello there" ]` would be `"hello there"[6:2:-2]` in python.

We need to tell lisp to coerce it to a string: `(coerce #(#\\t #\\o #\\l) 'string)` ⮕ `"tol"`.