Public Vars

<= (clj)

function

(<= x) (<= x y) (<= x y & more)

Returns non-nil if nums are in monotonically non-decreasing order, otherwise false.

Examples

(ns clojure.core.matrix.macros-clj
  "Namespace for core.matrix macros. Keeping them separate allows us to do conditional
  macros that can handle the differences between Clojure and Clojurescript."
  (:require [clojure.core.matrix.macros :refer [TODO c-for]])
  (:import [java.util Arrays]))

(defmacro eps== [a b eps]
  `(<= (Math/abs (- (double ~a) (double ~b))) (double ~eps) ))

hraberg/deuce

(ns deuce.emacs.character
  (:use [deuce.emacs-lisp :only (defun defvar)])
  (:require [clojure.core :as c])
  (:refer-clojure :exclude []))

(defun characterp (object)
  "Return non-nil if OBJECT is a character."
  (and ((some-fn integer? char?) object) (pos? (int object)) (<= (int object) (max-char))))

hraberg/deuce

(ns deuce.emacs.floatfns
  (:use [deuce.emacs-lisp :only (defun defvar)])
  (:require [clojure.core :as c]
            [deuce.emacs.alloc :as alloc])
  (:refer-clojure :exclude [float]))

(defun logb (arg)
  "Returns largest integer <= the base 2 log of the magnitude of ARG.
  This is the same as the exponent of a float."
  (Math/getExponent (double arg)))

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/< [(t/+ t/Num) :-> t/Bool]
cc/<= [(t/+ t/Num) :-> t/Bool]
cc/> [(t/+ t/Num) :-> t/Bool]
cc/>= [(t/+ t/Num) :-> t/Bool]
cc/== [(t/+ t/Num) :-> t/Bool]

Quantisan/docker-clojure

(ns docker-clojure.config
  (:require [clojure.spec.alpha :as s]
            [clojure.string :as str]
            [docker-clojure.core :as-alias core]))

(s/def ::jdk-version
  (s/and pos-int? #(<= 8 %)))
(s/def ::jdk-versions (s/coll-of ::jdk-version :distinct true :into #{}))