package.lisp

   1 (defpackage :alexandria.0.dev
   2   (:nicknames :alexandria)
   3   (:use :cl)
   4   (:export
   5    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6    ;; BLESSED
   7    ;;
   8    ;; Binding constructs
   9    #:if-let
  10    #:when-let
  11    #:when-let*
  12    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  13    ;; REVIEW IN PROGRESS
  14    ;;
  15    ;; Control flow
  16    #:cswitch
  17    #:eswitch
  18    #:switch
  19    #:multiple-value-prog2
  20    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  21    ;; REVIEW PENDING
  22    ;;
  23    #:nth-value-or
  24    #:whichever
  25    #:xor
  26    ;; Definitions
  27    #:define-constant
  28    ;; Hash tables
  29    #:alist-hash-table
  30    #:copy-hash-table
  31    #:ensure-gethash
  32    #:hash-table-alist
  33    #:hash-table-keys
  34    #:hash-table-plist
  35    #:hash-table-values
  36    #:maphash-keys
  37    #:maphash-values
  38    #:plist-hash-table
  39    ;; Functions
  40    #:compose
  41    #:conjoin
  42    #:curry
  43    #:disjoin
  44    #:ensure-function
  45    #:multiple-value-compose
  46    #:named-lambda
  47    #:rcurry
  48    ;; Lists
  49    #:alist-plist
  50    #:appendf
  51    #:nconcf
  52    #:reversef
  53    #:nreversef
  54    #:circular-list
  55    #:circular-list-p
  56    #:circular-tree-p
  57    #:doplist
  58    #:ensure-car
  59    #:ensure-cons
  60    #:ensure-list
  61    #:flatten
  62    #:lastcar
  63    #:make-circular-list
  64    #:map-product
  65    #:mappend
  66    #:nunionf
  67    #:plist-alist
  68    #:proper-list
  69    #:proper-list-length
  70    #:proper-list-p
  71    #:remove-from-plist
  72    #:remove-from-plistf
  73    #:delete-from-plist
  74    #:delete-from-plistf
  75    #:set-equal
  76    #:setp
  77    #:unionf
  78    ;; Numbers
  79    #:binomial-coefficient
  80    #:clamp
  81    #:count-permutations
  82    #:factorial
  83    #:gaussian-random
  84    #:iota
  85    #:lerp
  86    #:map-iota
  87    #:maxf
  88    #:mean
  89    #:median
  90    #:minf
  91    #:standard-deviation
  92    #:subfactorial
  93    #:variance
  94    ;; Arrays
  95    #:array-index
  96    #:array-length
  97    #:copy-array
  98    ;; Sequences
  99    #:copy-sequence
 100    #:deletef
 101    #:emptyp
 102    #:ends-with
 103    #:ends-with-subseq
 104    #:first-elt
 105    #:last-elt
 106    #:map-combinations
 107    #:map-derangements
 108    #:map-permutations
 109    #:proper-sequence
 110    #:random-elt
 111    #:removef
 112    #:rotate
 113    #:sequence-of-length-p
 114    #:length=
 115    #:shuffle
 116    #:starts-with
 117    #:starts-with-subseq
 118    ;; Macros
 119    #:once-only
 120    #:parse-body
 121    #:parse-ordinary-lambda-list
 122    #:with-gensyms
 123    #:with-unique-names
 124    ;; Symbols
 125    #:ensure-symbol
 126    #:format-symbol
 127    #:make-gensym
 128    #:make-gensym-list
 129    #:make-keyword
 130    ;; Strings
 131    #:string-designator
 132    ;; Types
 133    #:negative-double-float
 134    #:negative-fixnum-p
 135    #:negative-float
 136    #:negative-float-p
 137    #:negative-long-float
 138    #:negative-long-float-p
 139    #:negative-rational
 140    #:negative-rational-p
 141    #:negative-real
 142    #:negative-single-float-p
 143    #:non-negative-double-float
 144    #:non-negative-double-float-p
 145    #:non-negative-fixnum
 146    #:non-negative-fixnum-p
 147    #:non-negative-float
 148    #:non-negative-float-p
 149    #:non-negative-integer-p
 150    #:non-negative-long-float
 151    #:non-negative-rational
 152    #:non-negative-real-p
 153    #:non-negative-short-float-p
 154    #:non-negative-single-float
 155    #:non-negative-single-float-p
 156    #:non-positive-double-float
 157    #:non-positive-double-float-p
 158    #:non-positive-fixnum
 159    #:non-positive-fixnum-p
 160    #:non-positive-float
 161    #:non-positive-float-p
 162    #:non-positive-integer
 163    #:non-positive-rational
 164    #:non-positive-real
 165    #:non-positive-real-p
 166    #:non-positive-short-float
 167    #:non-positive-short-float-p
 168    #:non-positive-single-float-p
 169    #:ordinary-lambda-list-keywords
 170    #:positive-double-float
 171    #:positive-double-float-p
 172    #:positive-fixnum
 173    #:positive-fixnum-p
 174    #:positive-float
 175    #:positive-float-p
 176    #:positive-integer
 177    #:positive-rational
 178    #:positive-real
 179    #:positive-real-p
 180    #:positive-short-float
 181    #:positive-short-float-p
 182    #:positive-single-float
 183    #:positive-single-float-p
 184    #:coercef
 185    #:negative-double-float-p
 186    #:negative-fixnum
 187    #:negative-integer
 188    #:negative-integer-p
 189    #:negative-real-p
 190    #:negative-short-float
 191    #:negative-short-float-p
 192    #:negative-single-float
 193    #:non-negative-integer
 194    #:non-negative-long-float-p
 195    #:non-negative-rational-p
 196    #:non-negative-real
 197    #:non-negative-short-float
 198    #:non-positive-integer-p
 199    #:non-positive-long-float
 200    #:non-positive-long-float-p
 201    #:non-positive-rational-p
 202    #:non-positive-single-float
 203    #:of-type
 204    #:positive-integer-p
 205    #:positive-long-float
 206    #:positive-long-float-p
 207    #:positive-rational-p
 208    #:type=
 209    ;; Conditions
 210    #:required-argument
 211    #:ignore-some-conditions
 212    #:simple-style-warning
 213    #:simple-reader-error
 214    #:simple-parse-error
 215    #:simple-program-error
 216    #:unwind-protect-case
 217    ;; Features
 218    #:featurep
 219    ;; io
 220    #:with-input-from-file
 221    #:with-output-to-file
 222    #:read-file-into-string
 223    #:write-string-into-file
 224    #:copy-stream
 225    #:copy-file
 226    ;; new additions collected at the end
 227    #:symbolicate
 228    ))