Coverage report: /home/ellis/.stash/quicklisp/dists/quicklisp/software/alexandria-20241012-git/alexandria-1/package.lisp

Kind	Covered	All	%
expression	0	1	0.0
branch	0	0	nil

Key

Not instrumented

Conditionalized out

Executed

Not executed

Both branches taken

One branch taken

Neither branch taken

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

))