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