Changing data within bytes...

Lisp: where you have to modify the language to get anything useful done.

I don't really get what's going on here. You made a macro/function that lets you take the nth element of any sequence? Doesn't sound that special to me. :-\

Changing bits isn't hard if you write a function for it. In C++:

 Spoiler

Code:

template<typename type>
void setbit(type& variable, size_t bit, bool on)
{
    unsigned char * bytePtr = (unsigned char *) (&variable);
    size_t byteOffset = bit / 8;
    bytePtr += byteOffset;
    size_t bitOffset = bit % 8;

    if(on)
    {
        *bytePtr = *bytePtr | ( (unsigned char) (1) << (7 - bitOffset));
    }
    else
    {
        *bytePtr = *bytePtr & ( ( ~((unsigned char) (1)) ) << (7 - bitOffset));
    }
}

template<typename type>
bool getbit(const type& variable, size_t bit)
{
    const unsigned char * bytePtr = (const unsigned char *) (&variable);
    size_t byteOffset = bit / 8;
    bytePtr += byteOffset;
    size_t bitOffset = bit % 8;

    unsigned char byteCopy = *bytePtr;
    byteCopy = byteCopy | ( (unsigned char) (1) << (7 - bitOffset)); // Set the bit in a copy of the byte to 1, then check if the setting of the bit changed the byte
    if(byteCopy == *bytePtr)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Thing is, it's easier to refer to the bit through this, correct?

Code:

(un)signed whatever n = x;
int bitnumber = y;
cout << x[bitnumber];
x[bitnumber] = 1;

I think you can in C *scratches head* In py/pl you can do something to the same purpose without writing a whole crapload of code. You wouldn't usually use Perl for the same things you'd want Lisp for anyway.

 whee

print ord('P') ^ 0xFF;

Oh, that's really fancy. I don't know what you'd use Perl especially for, though I know you guys have a Memoization module:

 Spoiler

Code:

use Memoize;
memoize 'fib';

sub fib {
  my ($n) = @_;
  if ($n < 2) { 1 }
  else {
    fib($n - 1) + fib($n - 2);
  }
}

If you're able to write modules which work like this, then it's amazing. In LISP, you could always make a macro which do the same thing:

 Spoiler

Code:

(defmacro defmemoize (fn variables @body body)
  (let ((ht (gensym))
        (evaluated-vars (gensym)))
    `(progn
      (defvar ,ht (make-hash-table :test #'equal))
      (defun ,fn ,variables
        (let ((,evaluated-vars (list ,@variables)))
          (or (gethash ,evaluated-vars ,ht)
              (setf (gethash ,evaluated-vars ,ht)
                (progn ,@body))))))))

(defmemoize fib (n)
  (if (< n 2)
    1
    (+ (fib (- n 1))
       (fib (- n 2)))))

Though this would be rather slow for some cases (like where you can use an n-dimensional array instead), and possibly more inefficient unless you optimise the code some.

If you just want a quick and simple way to xor every character in a string without doing too many convertions, just make a dll in asm and make an external dll call. This way you will also gain some performance, if that matters to you.

I suppose you could, and I suppose it wouldn't be too hard/ugly to implement something like that. But that's not really the idea behind this function. The idea was just to show lisp's flexibility, and hopefully something we would be able to do later on. I'm aware that changing bits (and bytes) in programming-languages doesn't occur extremely frequently, but since there's nothing to lose by having this function available, then why not implement it to ease the work for programmers?