Back
count (clj)
(source)function
(count coll)
Returns the number of items in the collection. (count nil) returns
0. Also works on strings, arrays, and Java Collections and Maps
Examples
clojure
(ns clojure.test-clojure.server
(:import java.util.Random)
(:require [clojure.test :refer :all])
(:require [clojure.core.server :as s]))
(deftest test-parse-props
(let [thread (create-random-thread)]
(.start thread)
(Thread/sleep 1000)
(try
(is (>= (count
(#'s/parse-props (System/getProperties))) 0))
(finally (.interrupt thread)))))
clojure
(ns clojure.test-clojure.reducers
(:require [clojure.core.reducers :as r]
[clojure.test.generative :refer (defspec)]
[clojure.data.generators :as gen])
(:use clojure.test))
(deftest test-fold-runtime-exception
(is (thrown? IndexOutOfBoundsException
(let [test-map-count 1234
k-fail (rand-int test-map-count)]
(r/fold (fn ([])
([ret [k v]])
([ret k v] (when (= k k-fail)
(throw (IndexOutOfBoundsException.)))))
(zipmap (range test-map-count) (repeat :dummy)))))))
clojure/core.typed
(ns ^:skip-wiki clojure.core.typed.ann.clojure
"Type annotations for the base Clojure distribution."
(:require [#?(:clj clojure.core.typed
:cljs cljs.core.typed)
:refer [defalias] :as t]))
(defalias
^{:doc "The type of all things with count 0. Use as part of an intersection.
eg. See EmptySeqable."
:forms '[EmptyCount]}
t/EmptyCount
(t/ExactCount 0))
(defalias
^{:doc "The type of all things with count greater than 0. Use as part of an intersection.
eg. See NonEmptySeq"
:forms '[NonEmptyCount]}
t/NonEmptyCount
(t/CountRange 1))
(defalias
^{:doc "A persistent collection with member type x and count greater than 0."
:forms '[(NonEmptyColl t)]}
t/NonEmptyColl
(t/TFn [[x :variance :covariant]]
(t/I (t/Coll x)
t/NonEmptyCount)))
(defalias
^{:doc "A persistent vector with member type x and count greater than 0."
:forms '[(NonEmptyVec t)]}
t/NonEmptyVec
(t/TFn [[x :variance :covariant]]
(t/I (t/Vec x)
t/NonEmptyCount)))
(defalias
^{:doc "A persistent vector returned from clojure.core/vector (and others) and count greater than 0."
:forms '[(NonEmptyAVec t)]}
t/NonEmptyAVec
(t/TFn [[x :variance :covariant]]
(t/I (t/AVec x)
t/NonEmptyCount)))
(defalias
^{:doc "A type that can be used to create a sequence of member type x
with count greater than 0."
:forms '[(NonEmptySeqable t)]}
t/NonEmptySeqable
(t/TFn [[x :variance :covariant]]
(t/I (t/Seqable x)
t/NonEmptyCount)))
(defalias
^{:doc "A type that can be used to create a sequence of member type x
with count 0."
:forms '[(EmptySeqable t)]}
t/EmptySeqable
(t/TFn [[x :variance :covariant]]
(t/I (t/Seqable x)
t/EmptyCount)))
(defalias
^{:doc "A persistent sequence of member type x with count greater than 0."
:forms '[(NonEmptySeq t)]}
t/NonEmptySeq
(t/TFn [[x :variance :covariant]]
(t/I (t/Seq x)
t/NonEmptyCount)))
(defalias
^{:doc "A persistent sequence of member type x with count greater than 0, or nil."
:forms '[(NilableNonEmptySeq t)]}
t/NilableNonEmptySeq
(t/TFn [[x :variance :covariant]]
(t/Nilable
(t/NonEmptySeq x))))
(t/rclass-preds
; clojure.lang.Seqable
; {:pred (fn [this a?]
; (cond
; (string? this) (every? a? this)
; (coll? this) (every? a? this)))}
clojure.lang.IPersistentCollection
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.ISeq
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.IPersistentSet
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.APersistentSet
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.PersistentHashSet
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.PersistentTreeSet
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.Associative
{:args #{2}
:pred (fn [this a? b?]
`(cond
(vector? ~this) (and (every? ~a? (range (count ~this)))
(every? ~b? ~this))
(map? ~this) (and (every? ~a? (keys ~this))
(every? ~b? (vals ~this)))))}
clojure.lang.IPersistentStack
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.IPersistentVector
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.APersistentVector
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.PersistentVector
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.IMapEntry
{:args #{2}
:pred (fn [this a? b?]
`(and (~a? (key ~this)) (~b? (val ~this))))}
clojure.lang.AMapEntry
{:args #{2}
:pred (fn [this a? b?]
`(and (~a? (key ~this)) (~b? (val ~this))))}
clojure.lang.MapEntry
{:args #{2}
:pred (fn [this a? b?]
`(and (~a? (key ~this)) (~b? (val ~this))))}
clojure.lang.IPersistentMap
{:args #{2}
:pred (fn [this a? b?]
`(and (every? ~a? (keys ~this))
(every? ~b? (vals ~this))))}
clojure.lang.ASeq
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.APersistentMap
{:args #{2}
:pred (fn [this a? b?]
`(and (every? ~a? (keys ~this))
(every? ~b? (vals ~this))))}
clojure.lang.PersistentHashMap
{:args #{2}
:pred (fn [this a? b?]
`(and (every? ~a? (keys ~this))
(every? ~b? (vals ~this))))}
clojure.lang.Cons
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.IPersistentList
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.PersistentList
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.LazySeq
{:args #{1}
:pred (fn [this a?]
`(every? ~a? ~this))}
clojure.lang.Reduced
{:args #{1}
:pred (fn [this a?]
`(~a? (deref ~this)))})
hoplon/hoplon
(ns hoplon.binding
(:refer-clojure :exclude [binding bound-fn])
(:require [clojure.core :as clj]
[cljs.analyzer :as a]))
(defmacro binding
"See clojure.core/binding."
[bindings & body]
(let [env (assoc &env :ns (a/get-namespace a/*cljs-ns*))
value-exprs (take-nth 2 (rest bindings))
bind-syms (map #(:name (a/resolve-existing-var env %)) (take-nth 2 bindings))
bind-syms' (map (partial list 'quote) bind-syms)
set-syms (repeatedly (count bind-syms) gensym)
setfn (fn [x y]
{:push! `(fn []
(let [z# ~x]
(set! ~x ~y)
(fn [] (set! ~x z#))))})
thunkmaps (map setfn bind-syms set-syms)]
(a/confirm-bindings env bind-syms)
`(let [~@(interleave set-syms value-exprs)]
(hoplon.binding/push-thread-bindings ~(zipmap bind-syms' thunkmaps))
(try ~@body (finally (hoplon.binding/pop-thread-bindings))))))
hraberg/deuce
(ns deuce.emacs.alloc
(:use [deuce.emacs-lisp :only (defun defvar) :as el]
[taoensso.timbre :as timbre
:only (trace debug info warn error fatal spy)])
(:require [clojure.core :as c]
[clojure.walk :as w]
[deuce.emacs-lisp.cons :as cons])
(:refer-clojure :exclude [vector cons list])
(:import [java.util Arrays]
[java.lang.management ManagementFactory MemoryNotificationInfo MemoryType MemoryPoolMXBean]
[javax.management NotificationListener NotificationEmitter Notification]))
(defvar gc-cons-threshold nil
"*Number of bytes of consing between garbage collections.
Garbage collection can happen automatically once this many bytes have been
allocated since the last garbage collection. All data types count.
(defun memory-use-counts ()
"Return a list of counters that measure how much consing there has been.
Each of these counters increments for a certain kind of object.
The counters wrap around from the largest positive integer to zero.
Garbage collection does not decrease them.
The elements of the value are as follows:
(CONSES FLOATS VECTOR-CELLS SYMBOLS STRING-CHARS MISCS INTERVALS STRINGS)
All are in units of 1 = one object consed
except for VECTOR-CELLS and STRING-CHARS, which count the total length of
objects consed.
MISCS include overlays, markers, and some internal types.
Frames, windows, buffers, and subprocesses count as vectors
(but the contents of a buffer's text do not count here)."
)
hraberg/deuce
(ns deuce.emacs.macros
(:use [deuce.emacs-lisp :only (defun defvar)])
(:require [clojure.core :as c])
(:refer-clojure :exclude []))
(defun execute-kbd-macro (macro &optional count loopfunc)
"Execute MACRO as string of editor command characters.
If MACRO is a symbol, its function definition is used.
COUNT is a repeat count, or nil for once, or 0 for infinite loop.
With numeric arg, repeat macro now that many times,
counting the definition just completed as the first repetition.
An argument of zero means repeat until error.
A prefix argument serves as a repeat count. Zero means repeat until error.
hraberg/deuce
(ns deuce.emacs.character
(:use [deuce.emacs-lisp :only (defun defvar)])
(:require [clojure.core :as c])
(:refer-clojure :exclude []))
(defun string-width (string)
"Return width of STRING when displayed in the current buffer.
Width is measured by how many columns it occupies on the screen.
When calculating width of a multibyte character in STRING,
only the base leading-code is considered; the validity of
the following bytes is not checked. Tabs in STRING are always
taken to occupy `tab-width' columns."
(count (.getBytes (str string))))