Back
pos? (clj)
(source)function
(pos? num)
Returns true if num is greater than zero, else false
Examples
penpot/penpot
#_:clj-kondo/ignore
(ns app.common.data.macros
"Data retrieval & manipulation specific macros."
(:refer-clojure :exclude [get-in select-keys str with-open min max])
#?(:cljs (:require-macros [app.common.data.macros]))
(:require
#?(:clj [clojure.core :as c]
:cljs [cljs.core :as c])
[app.common.data :as d]
[cljs.analyzer.api :as aapi]
[cuerdas.core :as str]))
;; Code for ClojureScript
(let [mdata (aapi/resolve &env v)
arglists (second (get-in mdata [:meta :arglists]))
sym (symbol (c/name v))
andsym (symbol "&")
procarg #(if (= % andsym) % (gensym "param"))]
(if (pos? (count arglists))
`(def
~(with-meta sym (:meta mdata))
(fn ~@(for [args arglists]
(let [args (map procarg args)]
(if (some #(= andsym %) args)
(let [[sargs dargs] (split-with #(not= andsym %) args)]
`([~@sargs ~@dargs] (apply ~v ~@sargs ~@(rest dargs))))
`([~@args] (~v ~@args)))))))
`(def ~(with-meta sym (:meta mdata)) ~v)))
(defmacro with-open
[bindings & body]
{:pre [(vector? bindings)
(even? (count bindings))
(pos? (count bindings))]}
(reduce (fn [acc bindings]
`(let ~(vec bindings)
(try
~acc
(finally
(d/close! ~(first bindings))))))
`(do ~@body)
(reverse (partition 2 bindings))))
seancorfield/next-jdbc
(ns next.jdbc-test
"Basic tests for the primary API of `next.jdbc`."
(:require [clojure.core.reducers :as r]
[clojure.string :as str]
[clojure.test :refer [deftest is testing use-fixtures]]
[next.jdbc :as jdbc]
[next.jdbc.connection :as c]
[next.jdbc.test-fixtures
:refer [with-test-db db ds column
default-options stored-proc?
derby? hsqldb? jtds? mssql? mysql? postgres? sqlite?]]
[next.jdbc.prepare :as prep]
[next.jdbc.result-set :as rs]
[next.jdbc.specs :as specs]
[next.jdbc.types :as types])
(:import (com.zaxxer.hikari HikariDataSource)
(com.mchange.v2.c3p0 ComboPooledDataSource PooledDataSource)
(java.sql ResultSet ResultSetMetaData)))
(deftest bool-tests
(doseq [[n b] [["zero" 0] ["one" 1] ["false" false] ["true" true]]
:let [v-bit (if (number? b) b (if b 1 0))
v-bool (if (number? b) (pos? b) b)]]
(jdbc/execute-one!
(ds)
["insert into btest (name,is_it,twiddle) values (?,?,?)"
n
(if (postgres?)
(types/as-boolean b)
b) ; 0, 1, false, true are all acceptable
(cond (hsqldb?)
v-bool ; hsqldb requires a boolean here
(postgres?)
(types/as-other v-bit) ; really postgres??
:else
v-bit)]))
(let [data (jdbc/execute! (ds) ["select * from btest"]
(default-options))]
(if (sqlite?)
(is (every? number? (map (column :BTEST/IS_IT) data)))
(is (every? boolean? (map (column :BTEST/IS_IT) data))))
(if (or (sqlite?) (derby?))
(is (every? number? (map (column :BTEST/TWIDDLE) data)))
(is (every? boolean? (map (column :BTEST/TWIDDLE) data)))))
(let [data (jdbc/execute! (ds) ["select * from btest"]
(cond-> (default-options)
(sqlite?)
(assoc :builder-fn
(rs/builder-adapter
rs/as-maps
(fn [builder ^ResultSet rs ^Integer i]
(let [rsm ^ResultSetMetaData (:rsmeta builder)]
(rs/read-column-by-index
;; we only use bit and bool for
;; sqlite (not boolean)
(if (#{"BIT" "BOOL"} (.getColumnTypeName rsm i))
(.getBoolean rs i)
(.getObject rs i))
rsm
i)))))))]
(is (every? boolean? (map (column :BTEST/IS_IT) data)))
(if (derby?)
(is (every? number? (map (column :BTEST/TWIDDLE) data)))
(is (every? boolean? (map (column :BTEST/TWIDDLE) data)))))
(let [data (reduce (fn [acc row]
(conj acc (cond-> (select-keys row [:is_it :twiddle])
(sqlite?)
(update :is_it pos?)
(or (sqlite?) (derby?))
(update :twiddle pos?))))
[]
(jdbc/plan (ds) ["select * from btest"]))]
(is (every? boolean? (map :is_it data)))
(is (every? boolean? (map :twiddle data)))))
mikera/core.matrix
(ns clojure.core.matrix.test-selection
"Namespace for testing the clojure.core.matrix.select API"
(:refer-clojure :exclude [vector?])
(:require [clojure.core.matrix.protocols :as mp]
[clojure.core.matrix.implementations :as imp]
[clojure.core.matrix :as mat]
[clojure.core.matrix.utils :refer [broadcast-shape]]
#?(:clj [clojure.core.matrix.macros-clj :refer [error?]]
:cljs [clojure.core.matrix.macros-cljs :refer-macros [error?]])
[clojure.core.matrix.selection :refer [sel where exclude irange set-sel set-sel! odd even end]]
#?(:clj [clojure.test :refer [deftest testing is]]
:cljs [cljs.test :refer-macros [deftest testing is]])))
(deftest test-sel
(let [a [[1 2] [3 4]]]
(testing "higher level indexing"
(is (mat/equals 1 (sel a 0 0)))
(is (mat/equals [[1] [3]] (sel a [0 1] [0])))
(is (mat/equals [1 3] (sel a [0 1] 0)))
(is (mat/equals a (sel a :all :all)))
(is (mat/equals 4 (sel a end end)))
(is (mat/equals 2 (sel a (exclude 1) (exclude 0))))
(is (mat/equals [[1 2]] (sel [[-1 0] [1 2]] (where pos?) :all)))
(is (mat/equals [0 1 2 3 4] (sel (range 10) (where (partial > 5))))))))
typedclojure/typedclojure
(ns ^:no-doc typed.ann.clojure
"Type annotations for the base Clojure distribution."
#?(:cljs (:require-macros [typed.ann-macros.clojure :as macros]))
(:require [clojure.core :as cc]
[typed.clojure :as t]
#?(:clj [typed.ann-macros.clojure :as macros])
#?(:clj typed.ann.clojure.jvm) ;; jvm annotations
#?(:clj clojure.core.typed))
#?(:clj
(:import (clojure.lang PersistentHashSet PersistentList
APersistentMap #_IPersistentCollection
#_ITransientSet
IRef)
(java.util Comparator Collection))))
cc/pos? [t/Num :-> t/Bool]
cc/neg? [t/Num :-> t/Bool]
marick/structural-typing
(ns structural-typing.use.condensed-type-descriptions.f-all-of
(:require [structural-typing.preds :as pred])
(:use midje.sweet
structural-typing.type
structural-typing.global-type
structural-typing.clojure.core
structural-typing.assist.testutil)
(:refer-clojure :except [any?]))
(fact "a more complicated example using `implies`"
;; Multiple levels of type-expansion happening here.
;; Note also that `all-of` can be completely outside of the body of `type!`
(let [then-part (pred/all-of (includes :Colorful)
(requires :z)
{:z pos?}
{:secondary [required-path (includes :Colorful)]})]
(type! :A (pred/implies (includes :Point) then-part)))