Changing data within bytes...

Tends to sometimes be rather hard when it shouldn't be. You may be able to note this especially well when working with bits and strings, where you have to modify characters yourself.

Or if you're a LISPer and is really annoyed by the fact that there's no general function for any sequence (Though there is, elt, but it's slower compared to other specialized functions).

So yeah, I got bored and modified some setf-functions and made a macro character which works like array-refering or hash-refering in python.

 Spoiler

Code:

(define-setf-expander logbitp (bit n &environment env)
  (multiple-value-bind (%vals-temps %vals %newvals %setter %getter)
    (get-setf-expansion n env)
    (let ((bit-temp (gensym))
          (newval (gensym))
          (%newval (first %newvals)))
      (values (cons bit-temp %vals-temps)
              (cons bit %vals)
              (list newval)
              `(let ((,%newval (dpb (if (or
                                          (eq ,newval t)
                                          (eq ,newval 1))
                                          1 0)
                                    (byte 1 ,bit-temp)
                                    ,%getter)))
                 ,%setter ; The %setter form will do the dirty work if %newval is bound.
                 ,newval)
              `(logbitp ,bit-temp ,%vals-temps)))))

(define-setf-expander char-int (char &environment env)
  (multiple-value-bind (%vals-temps %vals %newvals %setter %getter)
      (get-setf-expansion char env)
    (let ((newval (gensym)))
      (values %vals-temps
              %vals
              (list newval)
              `(progn (setf ,%getter (int-char ,newval)) ,newval)
              `(char-int ,%getter)))))

(set-macro-character #\] (get-macro-character #\)))

(set-dispatch-macro-character #\# #\[
  #'(lambda (stream char1 char2)
      (let ((lst (read-delimited-list #\] stream t)))
        (labels ((make-expression (expr points)
                   (if points
                      (typecase (eval expr)
                        (list   (make-expression `(nth ,(car points) ,expr) (cdr points)))
                        (string (make-expression `(schar ,expr ,(car points)) (cdr points)))
                        (vector (make-expression `(svref ,expr ,(car points)) (cdr points)))
                        (hash-table (make-expression `(gethash ,(car points) ,expr) (cdr points)))
                        (array `(aref ,expr ,@points))
                        (integer `(logbitp ,@points ,expr))
                        (character `(logbitp ,@points (char-int ,expr)))
                        (t (make-expression `(elt ,expr ,(car points)) (cdr points))))
                      expr)))
          (make-expression (car lst) (cdr lst))))))

Simply saying, one can refer to any sequence or array, including characters and integers by this #[]-macro:

Code:

> #[3 1] ; Second bit in the integer 3
T
> #[#\d 0] ; First bit in the character d
NIL
> (setf x #\d)
> (setf #[x 0] 1) ; Changing first bit from 0 to 1
1
> x ; x is now modified
#\e
> (setf x (make-hash-table)
        #[x 55] #("A vector" "consisting of" "strings")))
> #[x 55]
#("A vector" "consisting of" "strings")
> #[x 55 2]
"strings"
> #[x 55 2 2]
#\r
> #[x 55 2 2 1] ; Equals to (logbitp (char-int (schar (svref (gethash 55 x) 2) 2)) 1), or the second bit in #\r
T
> (setf #[x 55 2 2 1] nil)
NIL
> #[x 55 2]
"stpings"

Can't make things like this in C, python, perl or anything else, eh?

I'm working on making it able to make dispatched arrays and such, so you can modify strings, arrays and whatever else destructively. Kinda like Python's [1:2:3] way of dealing with arrays, just through '(1 2 3) instead.

A destructive string-xoring in lisp, through one change in the #[-macro and adding in a (setf logxor)-function would be like this:

Code:

(defun string-xor (string1 string2)
  (let ((lst (coerce string2 'list)))
    (loop with circular-lst = (nconc lst lst) ; Circular list
          for i below (length string1)
          do (setf (logxor #[string1 i]) #[circular-lst i]))))

; And here's a non-destructive one:

(defun non-destructive-string-xor (string1 string2) ; Might want to shorten the name of this one
  (let ((lst (coerce string2 'list)))
    (with-output-to-string (out)
      (loop with circular-lst = (nconc lst lst)
            for i below (length string1)
            do (write-character (int-char (logxor #[string1 i] #[circular-lst i]))
                 out)))))

Which looks way prettier and easier to understand than your C or python string-xoring

 Spoiler

No offense! And I'll admit that the functions aren't heavily optimized, though with type specifiers, this would be just as fast as C-code if you use a good compiler.