(ql:quickload 'cl-rainbow)

(setf cl-rainbow:*enabled* t)
(print (cl-rainbow:color :red "red string"))
(print (cl-rainbow:color #x5599ff "rgb color code"))
(loop for c across "RAINBOW" do (format t "~A" (cl-rainbow:color (random #xffffff) c)))

(ql:quickload 'cl-ltsv)

CL-USER> (cl-ltsv:parse-line "host:127.0.0.1    ident:- user:frank")
(("host" . "127.0.0.1") ("ident" . "-") ("user" . "frank"))

CL-USER> (with-input-from-string (ss "host:127.0.0.1    ident:- user:frank
host:127.0.0.1  ident:- user:jane
host:127.0.0.1  ident:- user:john")
           (cl-ltsv:with-ltsv-from-stream (entry ss)
             (print entry)))

(("host" . "127.0.0.1") ("ident" . "-") ("user" . "frank")) 
(("host" . "127.0.0.1") ("ident" . "-") ("user" . "jane")) 
(("host" . "127.0.0.1") ("ident" . "-") ("user" . "john")) 
NIL

CL-USER> (cl-ltsv:alist-ltsv '(("host" . "127.0.0.1") ("ident" . "-") ("user" . "frank")))
"host:127.0.0.1 ident:- user:frank"

The constant CL-GEARMAN::+REQUEST-MAGIC+ is being redefined
(from #(0 82 69 81) to #(0 82 69 81))
   [Condition of type DEFCONSTANT-UNEQL]
See also:
  Common Lisp Hyperspec, DEFCONSTANT [:macro]
  SBCL Manual, Idiosyncrasies [:node]

Restarts:
 0: [CONTINUE] Go ahead and change the value.
 1: [ABORT] Keep the old value.
 2: [TRY-RECOMPILING] Recompile protocol and try loading it again
 3: [RETRY] Retry loading FASL for #<CL-SOURCE-FILE "cl-gearman" "src" "protocol">.
 4: [ACCEPT] Continue, treating loading FASL for #<CL-SOURCE-FILE "cl-gearman" "src" "protocol"> as having been successful.
 5: [ABORT] Give up on "cl-gearman"
 --more--

Backtrace:
  0: (SB-C::%DEFCONSTANT ..)
  1: (SB-FASL::LOAD-FASL-GROUP ..)
  2: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-FASL::LOAD-AS-FASL))
  3: ((FLET #:WITHOUT-INTERRUPTS-BODY-88874 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
  4: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK ..)
  5: (SB-FASL::LOAD-AS-FASL ..)
  6: ((FLET SB-FASL::LOAD-STREAM :IN LOAD) ..)
  7: (LOAD ..)
  8: (SB-IMPL::%MAP-FOR-EFFECT-ARITY-1 ..)

cd ~/quicklisp/local-projects
git clone https://github.com/taksatou/cl-gearman.git

CL-USER> (cl-gearman:with-client (client "localhost:4730")
           (format t "~a~%" (cl-gearman:submit-job client "hello"))
           (format t "~a~%" (cl-gearman:submit-job client "echo" :arg "foo)))
hello
foo
NIL

CL-USER> (cl-gearman:with-client (client "localhost:4730")
           (let* ((job1 (cl-gearman:submit-background-job client "sleep" :arg "1"))
                  (job2 (cl-gearman:submit-background-job client "sleep" :arg "1" :priority :low))
                  (job3 (cl-gearman:submit-background-job client "sleep" :arg "1" :priority :high))
                  (jobs `(:medium ,job1 :low ,job2 :high ,job3)))

             (dotimes (i 5)
               (loop for (k v) on jobs by #'cddr
                  do (format t "~a: ~a~%" k (cl-gearman:get-job-status client v)))
               (sleep 1))))
MEDIUM: (JOB-HANDLE H:hostname:109 IS-KNOWN 1 IS-RUNNING 1 PROGRESS NAN)
LOW: (JOB-HANDLE H:hostname:110 IS-KNOWN 1 IS-RUNNING 0 PROGRESS NAN)
HIGH: (JOB-HANDLE H:hostname:111 IS-KNOWN 1 IS-RUNNING 0 PROGRESS NAN)
MEDIUM: (JOB-HANDLE H:hostname:109 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
LOW: (JOB-HANDLE H:hostname:110 IS-KNOWN 1 IS-RUNNING 0 PROGRESS NAN)
HIGH: (JOB-HANDLE H:hostname:111 IS-KNOWN 1 IS-RUNNING 0 PROGRESS NAN)
MEDIUM: (JOB-HANDLE H:hostname:109 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
LOW: (JOB-HANDLE H:hostname:110 IS-KNOWN 1 IS-RUNNING 0 PROGRESS NAN)
HIGH: (JOB-HANDLE H:hostname:111 IS-KNOWN 1 IS-RUNNING 1 PROGRESS NAN)
MEDIUM: (JOB-HANDLE H:hostname:109 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
LOW: (JOB-HANDLE H:hostname:110 IS-KNOWN 1 IS-RUNNING 1 PROGRESS NAN)
HIGH: (JOB-HANDLE H:hostname:111 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
MEDIUM: (JOB-HANDLE H:hostname:109 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
LOW: (JOB-HANDLE H:hostname:110 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
HIGH: (JOB-HANDLE H:hostname:111 IS-KNOWN 0 IS-RUNNING 0 PROGRESS NAN)
NIL

(cl-gearman:with-worker (worker "localhost:4730")
  (cl-gearman:add-ability worker "hello"
                          #'(lambda (arg job) "hello"))

  (cl-gearman:add-ability worker "echo"
                          #'(lambda (arg job) arg))

  (cl-gearman:add-ability worker "sleep"
                          #'(lambda (arg job)
                              (sleep (parse-integer arg))
                              (format nil "job:~A finished~%" job)))

  (loop do (cl-gearman:work worker)))

(cl-gearman:with-worker (worker "localhost:4730") 
  (cl-gearman:add-ability worker "error"
                          #'(lambda (arg job) (error "something wrong")))

  (loop do (handler-bind ((error #'(lambda (c) (invoke-restart 'cl-gearman:skip-job))))
             (cl-gearman:work worker))))

(defun add (x y) (+ x y))

(defun add (x y)
  (declare (fixnum x y))
  (the fixnum (+ x y)))

(defun add (x y)
  (declare (optimize (speed 3) (safety 0)))
  (declare (fixnum x y))
  (the fixnum (+ x y)))

CL-USER> (defun add (x y) (+ x y))

CL-USER> (disassemble #'add)
; disassembly for ADD
; 03C43D5D:       488B55F8         MOV RDX, [RBP-8]           ; no-arg-parsing entry point
;       61:       488B7DF0         MOV RDI, [RBP-16]
;       65:       4C8D1C25E0010020 LEA R11, [#x200001E0]      ; GENERIC-+
;       6D:       41FFD3           CALL R11
;       70:       480F42E3         CMOVB RSP, RBX
;       74:       488BE5           MOV RSP, RBP
;       77:       F8               CLC
;       78:       5D               POP RBP
;       79:       C3               RET
;       7A:       CC0A             BREAK 10                   ; error trap
;       7C:       02               BYTE #X02
;       7D:       18               BYTE #X18                  ; INVALID-ARG-COUNT-ERROR
;       7E:       54               BYTE #X54                  ; RCX

CL-USER> (defun add (x y)
           (declare (fixnum x y))
           (the fixnum (+ x y)))

CL-USER> (disassemble #'add)
; disassembly for ADD
; 039D3B73:       488BD1           MOV RDX, RCX               ; no-arg-parsing entry point
;       76:       48D1FA           SAR RDX, 1
;       79:       488BC7           MOV RAX, RDI
;       7C:       48D1F8           SAR RAX, 1
;       7F:       4801C2           ADD RDX, RAX
;       82:       48B80000000000000040 MOV RAX, 4611686018427387904
;       8C:       4801D0           ADD RAX, RDX
;       8F:       48C1E83F         SHR RAX, 63
;       93:       7509             JNE L0
;       95:       48D1E2           SHL RDX, 1
;       98:       488BE5           MOV RSP, RBP
;       9B:       F8               CLC
;       9C:       5D               POP RBP
;       9D:       C3               RET
;       9E: L0:   486BC202         IMUL RAX, RDX, 2
;       A2:       710E             JNO L1
;       A4:       488BC2           MOV RAX, RDX
;       A7:       4C8D1C25B0050020 LEA R11, [#x200005B0]      ; ALLOC-SIGNED-BIGNUM-IN-RAX
;       AF:       41FFD3           CALL R11
;       B2: L1:   488B1557FFFFFF   MOV RDX, [RIP-169]         ; 'FIXNUM
;       B9:       CC0A             BREAK 10                   ; error trap
;       BB:       03               BYTE #X03
;       BC:       1F               BYTE #X1F                  ; OBJECT-NOT-TYPE-ERROR
;       BD:       15               BYTE #X15                  ; RAX
;       BE:       95               BYTE #X95                  ; RDX
;       BF:       CC0A             BREAK 10                   ; error trap
;       C1:       02               BYTE #X02
;       C2:       18               BYTE #X18                  ; INVALID-ARG-COUNT-ERROR
;       C3:       54               BYTE #X54                  ; RCX
;       C4:       CC0A             BREAK 10                   ; error trap
;       C6:       02               BYTE #X02
;       C7:       08               BYTE #X08                  ; OBJECT-NOT-FIXNUM-ERROR
;       C8:       95               BYTE #X95                  ; RDX
;       C9:       CC0A             BREAK 10                   ; error trap
;       CB:       04               BYTE #X04
;       CC:       08               BYTE #X08                  ; OBJECT-NOT-FIXNUM-ERROR
;       CD:       FED501           BYTE #XFE, #XD5, #X01      ; RDI

CL-USER> (defun add (x y)
           (declare (optimize (speed 3) (safety 0)))
           (declare (fixnum x y))
           (the fixnum (+ x y)))

CL-USER> (disassemble #'add)
; disassembly for ADD
; 034DD10F:       4801FA           ADD RDX, RDI               ; no-arg-parsing entry point
;       12:       488BE5           MOV RSP, RBP
;       15:       F8               CLC
;       16:       5D               POP RBP
;       17:       C3               RET

int add(int x, int y) {
    return x + y;
}

a.o:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <add>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   89 7d fc                mov    %edi,-0x4(%rbp)
   7:   89 75 f8                mov    %esi,-0x8(%rbp)
   a:   8b 45 f8                mov    -0x8(%rbp),%eax
   d:   8b 55 fc                mov    -0x4(%rbp),%edx
  10:   01 d0                   add    %edx,%eax
  12:   5d                      pop    %rbp
  13:   c3                      retq

a.o:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <add>:
   0:   8d 04 37                lea    (%rdi,%rsi,1),%eax
   3:   c3                      retq

(let ((_n (parse-integer (read-line)))
      (lis ()))
  (dotimes (i _n)
    (push (parse-integer (read-line)) lis))
  (setf lis (sort lis #'(lambda (x y) (< x y))))
  (dolist (x lis) (format t "~a~%" x)))

$ time ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}' | sbcl --script turbosort.cl > /dev/null
ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}'  1.19s user 0.01s system 91% cpu 1.311 total
sbcl --script turbosort.cl > /dev/null  3.42s user 0.43s system 97% cpu 3.938 total

(let* ((_n (parse-integer (read-line)))
       (lis (make-array _n :fill-pointer 0)))
  (dotimes (i _n)
    (vector-push (parse-integer (read-line)) lis))
  (setf lis (sort lis #'(lambda (x y) (< x y))))
  (loop for i across lis do (format t "~a~%" i)))

$ time ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}' | sbcl --script turbosort.cl > /dev/null
ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}'  1.21s user 0.01s system 94% cpu 1.289 total
sbcl --script turbosort.cl > /dev/null  2.64s user 0.44s system 98% cpu 3.137 total

(defun parse-input (str)
  (loop
     for i = 0 then (+ 1 j)
     as j = (position #\Newline str :start i)
     as k = (parse-integer (subseq str i j) :junk-allowed t)
     if (not (null k))
     collect k
     while j))

(let* ((_n (parse-integer (read-line)))
       (lis (make-array (* _n 20) :element-type 'character))
       (nums ())
       )
  (read-sequence lis *standard-input*)
  (setf nums (sort (parse-input lis) #'(lambda (x y) (< x y))))
  (loop for i in nums do (format t "~a~%" i)))

$ time ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}' | sbcl --script turbosort.cl > /dev/null
ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}'  1.13s user 0.01s system 97% cpu 1.159 total
sbcl --script turbosort.cl > /dev/null  3.67s user 0.48s system 96% cpu 4.297 total

#include <stdio.h>
#include <stdlib.h>

int f(const void *i, const void *j) {
    return *((int*)i) > *((int*)j);
}

int main(void) {
    char buf[256];
    int num = atoi(fgets(buf, 256, stdin));

    int lis[num];
    for (int i = 0; i < num; ++i) {
        lis[i] = atoi(fgets(buf, 256, stdin));
    }
    qsort(lis, num, sizeof(int), f);
    for (int i = 0; i < num; ++i) {
        printf("%d\n", lis[i]);
    }

$ time ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}' | ./a.out > /dev/null
ruby -e 'n=1000000;puts n; n.times{puts (rand * 10000000).to_i}'  0.99s user 0.01s system 99% cpu 1.006 total
./a.out > /dev/null  0.18s user 0.01s system 17% cpu 1.116 total

$ tar xzf zeromq-2.2.0.tar.gz
$ cd zeromq-2.2.0
$ ./build.sh
$ file libzmq.a
libzmq.a: Mach-O universal binary with 2 architectures
libzmq.a (for architecture armv7):      current ar archive random library
libzmq.a (for architecture i386):       current ar archive random library

(load "~/.sbclrc")
(ql:quickload :zeromq)

(defun pull-and-publish ()
  (zmq:with-context (ctx 1)
    (zmq:with-socket (rep-sock ctx zmq:rep)
      (zmq:bind rep-sock "tcp://127.0.0.1:5555")

      (zmq:with-context (ctx2 1)
        (zmq:with-socket (pub-sock ctx2 zmq:pub)
          (zmq:bind pub-sock "tcp://127.0.0.1:5556")

          (loop
             (let ((msg (make-instance 'zmq:msg)))
               (zmq:recv rep-sock msg)
               (zmq:send rep-sock (make-instance 'zmq:msg :data "ok"))
               (zmq:send pub-sock msg))))))))

(pull-and-publish)

#import "ChatViewController.h"
#import "include/zmq.h"

@interface ChatViewController () {

    void *ctx1, *ctx2;
    void *subsock, *reqsock;

    NSMutableArray *messageList;
}
@end

@implementation ChatViewController

@synthesize nickname;
@synthesize timer;

- (void)viewDidLoad
{
    [super viewDidLoad];

    ctx1 = zmq_init(1);
    subsock = zmq_socket(ctx1, ZMQ_SUB);
    zmq_setsockopt(subsock, ZMQ_SUBSCRIBE, "", 0);
    int rc = zmq_connect(subsock, "tcp://127.0.0.1:5556");
    assert(rc == 0);

    ctx2 = zmq_init(1);
    reqsock = zmq_socket(ctx1, ZMQ_REQ);
    rc = zmq_connect(reqsock, "tcp://127.0.0.1:5555");
    assert(rc == 0);

    self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(observeSocket) userInfo:nil repeats:YES];
    messageList = [[NSMutableArray alloc] init];
}

- (void)viewWillDisappear:(BOOL)animated
{
    [self.timer invalidate];
    zmq_close(subsock);
    zmq_close(reqsock);
    zmq_term(ctx1);
    zmq_term(ctx2);
}

- (void)observeSocket
{
    zmq_msg_t msg;
    int rc = zmq_msg_init(&msg);
    assert(rc == 0);

    do {
        rc = zmq_recv(subsock, &msg, ZMQ_NOBLOCK);
        if (rc == EAGAIN) {
            NSLog(@"no data available");
        } else if (rc == ENOTSUP) {
            NSLog(@"ENOTSUP");
        } else if (rc == EFSM) {
            NSLog(@"EFSM");
        } else if (rc == ETERM) {
            NSLog(@"ETERM");
        } else if (rc == ENOTSOCK) {
            NSLog(@"ENOTSOCK");
        } else if (rc == EINTR) {
            NSLog(@"EINTR");
        } else if (rc == EFAULT) {
            NSLog(@"EFAULT");
        } else if (rc == 0) {
            size_t siz = zmq_msg_size(&msg);
            void *dat = zmq_msg_data(&msg);
            NSString *str = [[NSString alloc] initWithData:[NSData dataWithBytes:dat length:siz] encoding:NSUTF8StringEncoding];
            [messageList insertObject:str atIndex:0];
        } else {
            NSLog(@"unknown");
        }
    } while (rc == 0);
    zmq_msg_close(&msg);
    [self.tableView reloadData];
}

- (IBAction) saySomething:(id)sender
{
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"text input"
                                message:@""
                               delegate:self
                      cancelButtonTitle:@"cancel"
                      otherButtonTitles:@"ok", nil];
    alert.alertViewStyle = UIAlertViewStylePlainTextInput;
    [alert show];
}

- (void)alertView:(UIAlertView*)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
{
    zmq_msg_t msg;
    int rc;
    NSData *data;
    NSString *str;

    switch (buttonIndex) {
        case 0:
            break;
        case 1:
            str = [NSString stringWithFormat:@"%@: %@", nickname, [alertView textFieldAtIndex:0].text];
            data = [str dataUsingEncoding:NSUTF8StringEncoding];
            rc = zmq_msg_init_size(&msg, [data length]);
            assert(rc == 0);
            memcpy(zmq_msg_data(&msg), [data bytes], [data length]);

            zmq_send(reqsock, &msg, 0);
            zmq_recv(reqsock, &msg, 0);
            zmq_msg_close(&msg);
            break;
        default:
            break;
    }
}

@end

(load "~/.sbclrc")
(ql:quickload :zeromq)
(ql:quickload :bordeaux-threads)

(defun sub ()
  (zmq:with-context (ctx 1)
    (zmq:with-socket (socket ctx zmq:sub)
      (zmq:setsockopt socket zmq:subscribe "")
      (zmq:connect socket "tcp://127.0.0.1:5556")
      (loop
         (let ((query (make-instance 'zmq:msg)))
           (zmq:recv socket query)
           (format t "received message: ~a~%" (zmq:msg-data-as-string query)))))))

(defun client ()
  (zmq:with-context (ctx 1)
    (zmq:with-socket (socket ctx zmq:req)
      (zmq:connect socket "tcp://127.0.0.1:5555")
      (loop
         (zmq:send socket (make-instance 'zmq:msg
                                         :data (read-line)))
         (let ((result (make-instance 'zmq:msg)))
           (zmq:recv socket result))))))

(bordeaux-threads:make-thread #'sub)
(client)

$ curl -O http://beta.quicklisp.org/quicklisp.lisp
$ sbcl
(load "quicklisp.lisp")
(quicklisp-quickstart:install :path ".quicklisp/")
(ql:add-to-init-file)

(ql:quickload :zeromq)

debugger invoked on a LOAD-FOREIGN-LIBRARY-ERROR in thread
#<THREAD "initial thread" RUNNING {10029990A3}>:
  Unable to load any of the alternatives:
   ("libzmq.so.0.0.0" "libzmq.so")

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [RETRY          ] Try loading the foreign library again.
  1: [USE-VALUE      ] Use another library instead.
  2: [TRY-RECOMPILING] Recompile package and try loading it again
  3: [RETRY          ] Retry
                       loading FASL for #<CL-SOURCE-FILE "zeromq" "package">.
  4: [ACCEPT         ] Continue, treating
                       loading FASL for #<CL-SOURCE-FILE "zeromq" "package"> as
                       having been successful.
  5: [ABORT          ] Give up on "zeromq"
  6:                   Exit debugger, returning to top level.

(CFFI::FL-ERROR
 "Unable to load any of the alternatives:~%   ~S"
 ("libzmq.so.0.0.0" "libzmq.so"))
0] 2

(pushnew "/path/to/lib/" *foreign-library-directories*)

(load "~/.sbclrc")
(ql:quickload :zeromq)

(defun server ()
  (zmq:with-context (ctx 1)
    (zmq:with-socket (socket ctx zmq:rep)
      (zmq:bind socket "tcp://127.0.0.1:5555")
      (loop
         (let ((query (make-instance 'zmq:msg)))
           (zmq:recv socket query)
           (let ((req-string (zmq:msg-data-as-string query)))
             (format t "Recieved message: '~A'~%" req-string)
             (zmq:send socket (make-instance 'zmq:msg :data req-string)) ))))))

(server)

(load "~/.sbclrc")
(ql:quickload :zeromq)

(defun client ()
  (zmq:with-context (ctx 1)
    (zmq:with-socket (socket ctx zmq:req)
      (zmq:connect socket "tcp://127.0.0.1:5555")
      (loop
      (zmq:send socket (make-instance 'zmq:msg
                                      :data (read-line)))
      (let ((result (make-instance 'zmq:msg)))
        (zmq:recv socket result)
        (format t "Recieved message: '~A'~%"
                (zmq:msg-data-as-string result) ))))))

(client)

CL-USER> (sb-mop:class-slots (find-class 'sb-posix:stat))
(#<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::MODE>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::INO>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::DEV>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::NLINK>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::UID>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::GID>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::SIZE>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::ATIME>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::MTIME>
 #<SB-MOP:STANDARD-EFFECTIVE-SLOT-DEFINITION SB-POSIX::CTIME>)