pax_global_header00006660000000000000000000000064131160351610014507gustar00rootroot0000000000000052 comment=5e7f84a9b0a09516593cbf1c5c864bb261b083bb curry-compose-reader-macros-20170630-git/000077500000000000000000000000001311603516100200655ustar00rootroot00000000000000curry-compose-reader-macros-20170630-git/README.md000066400000000000000000000051371311603516100213520ustar00rootroot00000000000000# CURRY-COMPOSE-READER-MACROS Reader macros for concise expression of function partial application and composition. These reader macros expand into the `curry`, `rcurry` and `compose` functions from the Alexandria library. The contents of curly brackets are curried and the contents of square brackets are composed. The `_` symbol inside curly brackets changes the order of arguments with `rcurry`. The following examples demonstrate usage. ;; partial application `curry' (mapcar {+ 1} '(1 2 3 4)) ; => (2 3 4 5) ;; alternate order of arguments `rcurry' (mapcar {- _ 1} '(1 2 3 4)) ; => (0 1 2 3) ;; function composition (mapcar [#'list {* 2}] '(1 2 3 4)) ; => ((2) (4) (6) (8)) Additionally, if optional utf8 support is enabled, special brackets may be used to split arguments amongst a list of functions and collect the results. The first element of the `«»`-delimited list is the "join" function. Incoming arguments are split out to the remaining functions in the `«»`-delimited list, and their results are then passed to the join function. ;; function split and join (mapcar «list {* 2} {* 3}» '(1 2 3 4)) ; => ((2 3) (4 6) (6 9) (8 12)) (mapcar «and {< 2} #'evenp» '(1 2 3 4)) ; => (NIL NIL NIL T) (mapcar «+ {* 2} {- _ 1}» '(1 2 3 4)) ; => (2 5 8 11) `enable-curry-compose-reader-macros` is a macro which wraps itself in `eval-when` to ensure that reader macros are defined for both compilation and execution. (enable-curry-compose-reader-macros) Or to load utf8 support as well (which is probably going too far). (enable-curry-compose-reader-macros :include-utf8) Emacs users may easily treat `{}`'s, `[]`'s and `«»`'s as parenthesis for paredit commands and SEXP movement with the following configuration. ;; Syntax table (modify-syntax-entry ?\[ "(]" lisp-mode-syntax-table) (modify-syntax-entry ?\] ")[" lisp-mode-syntax-table) (modify-syntax-entry ?\{ "(}" lisp-mode-syntax-table) (modify-syntax-entry ?\} "){" lisp-mode-syntax-table) ;; optional UTF8 characters (modify-syntax-entry ?\« "(»" lisp-mode-syntax-table) (modify-syntax-entry ?\» ")«" lisp-mode-syntax-table) ;; Paredit keys (eval-after-load "paredit" '(progn (define-key paredit-mode-map "[" 'paredit-open-parenthesis) (define-key paredit-mode-map "]" 'paredit-close-parenthesis) (define-key paredit-mode-map "(" 'paredit-open-bracket) (define-key paredit-mode-map ")" 'paredit-close-bracket) (define-key paredit-mode-map "{" 'paredit-open-curly) (define-key paredit-mode-map "}" 'paredit-close-curly))) curry-compose-reader-macros-20170630-git/curry-compose-reader-macros.asd000066400000000000000000000005431311603516100261110ustar00rootroot00000000000000(defsystem :curry-compose-reader-macros :description "reader macros for concise function partial application and composition" :author "Eric Schulte " :version "1.0.0" :licence "Public Domain" :depends-on (alexandria) :components ((:file "package") (:file "curry-compose-reader-macros" :depends-on ("package")))) curry-compose-reader-macros-20170630-git/curry-compose-reader-macros.lisp000066400000000000000000000134511311603516100263130ustar00rootroot00000000000000;;; curry-compose-reader-macros --- partial application and composition ;; Copyright (C) Eric Schulte 2013 ;; Placed in the public domain. ;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ;; FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ;; COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ;; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ;; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ;; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ;; STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED ;; OF THE POSSIBILITY OF SUCH DAMAGE. ;;; Commentary ;; Reader macros for concise expression of function partial ;; application and composition. ;; ;; These reader macros expand into the `curry', `rcurry' and `compose' ;; functions from the Alexandria library. The contents of curly ;; brackets are curried and the contents of square brackets are ;; composed. The `_' symbol inside curly brackets changes the order ;; of arguments with `rcurry'. ;; ;; The following examples demonstrate usage. ;; ;; ;; partial application `curry' ;; (mapcar {+ 1} '(1 2 3 4)) ; => (2 3 4 5) ;; ;; ;; alternate order of arguments `rcurry' ;; (mapcar {- _ 1} '(1 2 3 4)) ; => (0 1 2 3) ;; ;; ;; function composition ;; (mapcar [#'list {* 2}] '(1 2 3 4)) ; => ((2) (4) (6) (8)) ;; ;; ;; function split and join (with the `include-utf8' option) ;; (mapcar «list {* 2} {* 3}» '(1 2 3 4)) ; => ((2 3) (4 6) (6 9) (8 12)) ;; (mapcar «and {< 2} #'evenp» '(1 2 3 4)) ; => (NIL NIL NIL T) ;; (mapcar «+ {* 2} {- _ 1}» '(1 2 3 4)) ; => (2 5 8 11) ;; ;; `enable-curry-compose-reader-macros' is a macro which wraps itself ;; in `eval-when' to ensure that reader macros are defined for both ;; compilation and execution. ;; ;; Or to load utf8 support as well (which is probably going too far). ;; ;; (enable-curry-compose-reader-macros :include-utf8) ;; ;; Emacs users may easily treat {}'s, []'s and «»'s as parenthesis ;; for paredit commands and SEXP movement with the following ;; configuration. ;; ;; ;; Syntax table ;; (modify-syntax-entry ?\[ "(]" lisp-mode-syntax-table) ;; (modify-syntax-entry ?\] ")[" lisp-mode-syntax-table) ;; (modify-syntax-entry ?\{ "(}" lisp-mode-syntax-table) ;; (modify-syntax-entry ?\} "){" lisp-mode-syntax-table) ;; (modify-syntax-entry ?\« "(»" lisp-mode-syntax-table) ;; (modify-syntax-entry ?\» ")«" lisp-mode-syntax-table) ;; ;; ;; Paredit keys ;; (eval-after-load "paredit" ;; '(progn ;; (define-key paredit-mode-map "[" 'paredit-open-parenthesis) ;; (define-key paredit-mode-map "]" 'paredit-close-parenthesis) ;; (define-key paredit-mode-map "(" 'paredit-open-bracket) ;; (define-key paredit-mode-map ")" 'paredit-close-bracket) ;; (define-key paredit-mode-map "{" 'paredit-open-curly) ;; (define-key paredit-mode-map "}" 'paredit-close-curly))) ;;; Code: (in-package :curry-compose-reader-macros) (defvar *previous-readtables* nil) (defmacro enable-curry-compose-reader-macros (&optional include-utf8) "Enable concise syntax for Alexandria's `curry', `rcurry' and `compose'." `(eval-when (:compile-toplevel :load-toplevel :execute) (push *readtable* *previous-readtables*) ;; partial application with {} using Alexandria's `curry' and `rcurry' (set-syntax-from-char #\{ #\( ) (set-syntax-from-char #\} #\) ) ,@(unless (fboundp 'lcurly-brace-reader) `((defun lcurly-brace-reader (stream inchar) (declare (ignore inchar)) (let ((spec (read-delimited-list #\} stream t))) (if (eq (cadr spec) '_) `(rcurry (function ,(car spec)) ,@(cddr spec)) `(curry (function ,(car spec)) ,@(cdr spec))))))) (set-macro-character #\{ #'lcurly-brace-reader) (set-macro-character #\} (get-macro-character #\) )) ;; composition with [] using Alexandria's `compose' (set-syntax-from-char #\[ #\( ) (set-syntax-from-char #\] #\) ) ,@(unless (fboundp 'lsquare-brace-reader) `((defun lsquare-brace-reader (stream inchar) (declare (ignore inchar)) (cons 'compose (read-delimited-list #\] stream t))))) (set-macro-character #\[ #'lsquare-brace-reader) (set-macro-character #\] (get-macro-character #\) )) ,@(when include-utf8 `(;; inform lisp that source code is encoded in UTF-8 #+sbcl (setf sb-impl::*default-external-format* :UTF-8) ;; list split collection with «» (set-syntax-from-char #\« #\( ) (set-syntax-from-char #\» #\) ) ,@(unless (fboundp 'langle-quotation-reader) `((defun langle-quotation-reader (stream inchar) (declare (ignore inchar)) (let ((contents (read-delimited-list #\» stream t)) (args (gensym "langle-quotation-reader"))) `(lambda (&rest ,args) (,(car contents) ; Join function (or macro). ,@(mapcar (lambda (fun) `(apply ,fun ,args)) (cdr contents)))))))) (set-macro-character #\« #'langle-quotation-reader) (set-macro-character #\» (get-macro-character #\))))))) (defmacro disable-curry-compose-reader-macros () '(eval-when (:compile-toplevel :load-toplevel :execute) (setf *readtable* (pop *previous-readtables*)))) curry-compose-reader-macros-20170630-git/package.lisp000066400000000000000000000002731311603516100223530ustar00rootroot00000000000000(defpackage #:curry-compose-reader-macros (:use :common-lisp :alexandria) (:export :enable-curry-compose-reader-macros :disable-curry-compose-reader-macros :_))