digikar99

Features of a Common Lispy approach to (better) Numpy

Numpy is great, in fact it’s one of the things that pulls people to Python. But can it be better?

Common Lisp is great, in fact it’s one of the things that pulls people to Common Lisp. But can it be better? Indeed Python can’t be better than Common Lisp without it becoming another Lisp. The closest we have is Julia. And while it gets some things right, Julia lacks certain features that limit the goodness of a numerical computing library.

All combined, below I will highlight some of the features that I wish a numerical computing library or ecosystem had. I also want to request the readers for their own inputs about how things can be even better. The goal amidst this is solely to keep things numpy-like. I do not intend to - nor have the background to - make a DSL like April or Petalisp.

While I take some interest in performance and numerical computing, I have m

death

(defpackage #:snippets/history-class
  (:use #:cl #:closer-mop)
  (:shadowing-import-from
   #:closer-mop
   #:standard-generic-function
   #:defgeneric
   #:defmethod)
  (:import-from
   #:fset)
  (:export

chuckxD

dank yet obscure FFZ/BTTV API end-points you can use for stuff

• Created doc while stumbling upon this PR / issue in https://github.com/night/betterttv
• Also kudos Chrome network panel

here's the TL;DR

bttv

• global: https://api.betterttv.net/3/cached/emotes/global

lokedhs

(defun em-spacing-predicates (endp delimiter)
  (not (or (and (eql ?\( delimiter)
                (eql ?\@ (char-before (point))))
           (and (eql ?\" delimiter)
                (eql ?\p (char-before (point)))
                (eql ?\# (char-before (1- (point))))))))

(setq paredit-space-for-delimiter-predicates '(em-spacing-predicates))

WetHat

no-defun-allowed

(defun read-list (stream)
  (if (char= (peek-char t stream) #\))
      (progn
        (read-char stream) 
        nil)
      (cons (read-sexp stream)
            (read-list stream))))

(defun read-atom (stream &optional (collected nil))
  (let ((char (peek-char (null collected) stream nil :eof)))

TeMPOraL

(defpackage #:scratch/clx-test
  (:use #:cl)
  (:export #:run))

(in-package #:scratch/clx-test)

;;; A minimum test case for properly handling window close events from the window manager.

(defun delete-window-event-p (display type data)
  (and (eq type :wm_protocols)

wiseman

;; Make multiple-value-bind a little more convenient.

(defmacro mv-let* ((&rest bdgs) &body body)
  (if (null bdgs)
    `(progn ,@body)
    `(multiple-value-bind ,(butlast (car bdgs))
                          ,@(last (car bdgs))
       (mv-let* ,(cdr bdgs)
         ,@body))))

chsh

burtonsamograd

;; -*- mode: lisp -*-
;;
;; A quick and dirty tree shaker for SBCL.  Basically, it destroys the
;; package system and does a gc before saving the lisp image.  Gives
;; about a 40% reduction in image size on a basic hello world test.
;; Would like to hear how it works on larger projects.
;;
;; Original idea from: https://groups.google.com/d/msg/comp.lang.lisp/6zpZsWFFW18/WMy4PyA9B4kJ
;;
;; Burton Samograd