c06af7c9f4
ifn? (jolt-1vx) is the canonical IFn set in the overlay: fns, keywords,
symbols, maps (sorted included), sets, vectors, and vars — NOT lists. The
seed version said true for lists and false for struct maps and vars.
Mutable-mode caveat documented (vectors and lists share the array repr
there). 13 predicate rows.
Multimethod dispatch (jolt-heo) now collects EVERY isa-matching method key
and picks the dominant one — x dominates y when prefer-method'd over it or
(isa? x y) — and two matches with no dominant is an ambiguity ERROR, as in
Clojure. It used to take whichever key the table yielded first, silently
ignoring prefer-method. The prefers store upgrades to Clojure's
{x -> set-of-dominated} shape, shared between the dispatch closure and
prefer-method-setup via the var; prefers becomes a macro over a setup fn
(the store lives on the VAR — the multifn value can't carry it, so the old
fn read {} forever). 6 multimethod rows + the conformance row updated to
the canonical shape (335x3).
The reader (jolt-ou8) kept the pending KEY when a comment or #_ sits in a
map's VALUE slot: the old code dropped both, desyncing kv pairing — the
real value became the next key and the closing brace landed in value
position ('Unmatched closing brace'). Selmer's deps.edn (a '; for
development (REPL, etc)' comment between key and value) now parses; 6
reader rows incl. nested commented maps.
Gate: jpm exit 0, conformance 335x3, all tests passed.
202 lines
10 KiB
Text
202 lines
10 KiB
Text
# Specification: type & value predicates.
|
|
(use ../support/harness)
|
|
|
|
(defspec "predicates / nil & boolean"
|
|
["nil? true" "true" "(nil? nil)"]
|
|
["nil? false" "false" "(nil? 0)"]
|
|
["some? true" "true" "(some? 0)"]
|
|
["some? on nil" "false" "(some? nil)"]
|
|
["true?" "true" "(true? true)"]
|
|
["false?" "true" "(false? false)"]
|
|
["boolean? true" "true" "(boolean? false)"]
|
|
["not nil" "true" "(not nil)"]
|
|
["not 0 is false" "false" "(not 0)"]
|
|
["boolean of nil" "false" "(boolean nil)"]
|
|
["boolean of value" "true" "(boolean 5)"])
|
|
|
|
(defspec "predicates / types"
|
|
["string?" "true" "(string? \"x\")"]
|
|
["number?" "true" "(number? 1)"]
|
|
["keyword?" "true" "(keyword? :a)"]
|
|
["symbol?" "true" "(symbol? (quote a))"]
|
|
["char?" "true" "(char? \\a)"]
|
|
["fn? on fn" "true" "(fn? inc)"]
|
|
["ifn? on keyword" "true" "(ifn? :a)"]
|
|
["vector?" "true" "(vector? [1])"]
|
|
["list?" "true" "(list? (list 1))"]
|
|
["map?" "true" "(map? {:a 1})"]
|
|
["set?" "true" "(set? #{1})"]
|
|
["coll? vector" "true" "(coll? [1])"]
|
|
["coll? map" "true" "(coll? {:a 1})"]
|
|
["coll? on number" "false" "(coll? 1)"]
|
|
["seq? list" "true" "(seq? (list 1))"]
|
|
["seq? vector" "false" "(seq? [1])"]
|
|
["sequential? vector" "true" "(sequential? [1])"]
|
|
["associative? map" "true" "(associative? {:a 1})"]
|
|
["associative? vec" "true" "(associative? [1])"]
|
|
["associative? list" "false" "(associative? '(1 2))"]
|
|
["associative? set" "false" "(associative? #{1})"]
|
|
["reversible? vec" "true" "(reversible? [1 2])"]
|
|
["reversible? list" "false" "(reversible? '(1 2))"]
|
|
["reversible? smap" "true" "(reversible? (sorted-map :a 1))"]
|
|
["reversible? hmap" "false" "(reversible? (hash-map :a 1))"]
|
|
["indexed? vector" "true" "(indexed? [1])"]
|
|
["counted? vector" "true" "(counted? [1])"])
|
|
|
|
(defspec "predicates / idents"
|
|
["ident? keyword" "true" "(ident? :a)"]
|
|
["ident? symbol" "true" "(ident? (quote a))"]
|
|
["simple-keyword?" "true" "(simple-keyword? :a)"]
|
|
["qualified-keyword?" "true" "(qualified-keyword? :a/b)"]
|
|
["simple-symbol?" "true" "(simple-symbol? (quote a))"]
|
|
["qualified-symbol?" "true" "(qualified-symbol? (quote a/b))"]
|
|
["name of keyword" "\"a\"" "(name :a)"]
|
|
["name of qualified" "\"b\"" "(name :a/b)"]
|
|
["namespace" "\"a\"" "(namespace :a/b)"]
|
|
["namespace simple" "nil" "(namespace :a)"]
|
|
["keyword constructor" ":foo" "(keyword \"foo\")"]
|
|
["keyword ns + name" ":a/b" "(keyword \"a\" \"b\")"]
|
|
["symbol constructor" "(quote x)" "(symbol \"x\")"]
|
|
["name of string" "\"s\"" "(name \"s\")"])
|
|
|
|
# Predicates moved from Janet to the Clojure overlay (jolt-1j0). Jolt has no
|
|
# ratio/bigdecimal types (so ratio?/decimal? are always false, rational?=int?),
|
|
# and no distinct host object/undefined types (object?/undefined? always false).
|
|
(defspec "predicates / overlay-migrated"
|
|
["not-any? true" "true" "(not-any? even? [1 3 5])"]
|
|
["not-any? false" "false" "(not-any? even? [1 2 3])"]
|
|
["not-every? true" "true" "(not-every? even? [2 4 5])"]
|
|
["not-every? false" "false" "(not-every? even? [2 4 6])"]
|
|
["ident? number" "false" "(ident? 1)"]
|
|
["qualified-ident?" "true" "(qualified-ident? :a/b)"]
|
|
["qualified-ident? no" "false" "(qualified-ident? :a)"]
|
|
["simple-ident?" "true" "(simple-ident? :a)"]
|
|
["ratio?" "false" "(ratio? 3)"]
|
|
["decimal?" "false" "(decimal? 3)"]
|
|
["rational? int" "true" "(rational? 3)"]
|
|
["rational? float" "false" "(rational? 3.5)"]
|
|
["nat-int? zero" "true" "(nat-int? 0)"]
|
|
["nat-int? neg" "false" "(nat-int? -1)"]
|
|
["pos-int?" "true" "(pos-int? 5)"]
|
|
["neg-int?" "true" "(neg-int? -3)"]
|
|
["NaN? on nan" "true" "(NaN? (/ 0.0 0.0))"]
|
|
["NaN? on number" "false" "(NaN? 5)"]
|
|
["abs negative" "3" "(abs -3)"]
|
|
["abs positive" "2.5" "(abs 2.5)"]
|
|
["object?" "false" "(object? 1)"]
|
|
["undefined?" "false" "(undefined? 1)"]
|
|
["keyword-identical?" "true" "(keyword-identical? :a :a)"]
|
|
["keyword-identical? no" "false" "(keyword-identical? :a :b)"])
|
|
|
|
# Tagged-value predicates moved to the overlay in Phase 4 (read the value's
|
|
# :jolt/type via get). The constructors stay native.
|
|
# map?/coll? are STRICT (jolt-6s2 cleanup): tagged structs (symbols, chars,
|
|
# uuids) are values, not collections; sorted maps/sets and records ARE
|
|
# collections (and sorted-map/record are map?), matching Clojure.
|
|
(defspec "predicates / map? & coll? strictness"
|
|
["map? symbol" "false" "(map? (quote sym))"]
|
|
["map? char" "false" "(map? \\a)"]
|
|
["map? uuid" "false" "(map? (random-uuid))"]
|
|
["map? literal" "true" "(map? {:a 1})"]
|
|
["map? hash-map" "true" "(map? (hash-map :a 1))"]
|
|
["map? sorted-map" "true" "(map? (sorted-map :a 1))"]
|
|
["map? record" "true" "(do (defrecord Mr [a]) (map? (->Mr 1)))"]
|
|
["map? sorted-set" "false" "(map? (sorted-set 1))"]
|
|
["map? vector" "false" "(map? [1])"]
|
|
["coll? symbol" "false" "(coll? (quote sym))"]
|
|
["coll? char" "false" "(coll? \\a)"]
|
|
["coll? uuid" "false" "(coll? (random-uuid))"]
|
|
["coll? keyword" "false" "(coll? :k)"]
|
|
["coll? string" "false" "(coll? \"s\")"]
|
|
["coll? map literal" "true" "(coll? {:a 1})"]
|
|
["coll? sorted-map" "true" "(coll? (sorted-map :a 1))"]
|
|
["coll? sorted-set" "true" "(coll? (sorted-set 1))"]
|
|
["coll? record" "true" "(do (defrecord Cr [a]) (coll? (->Cr 1)))"]
|
|
["coll? vector" "true" "(coll? [1])"]
|
|
["coll? list" "true" "(coll? (list 1))"]
|
|
["coll? set" "true" "(coll? #{1})"]
|
|
["coll? lazy seq" "true" "(coll? (map inc [1]))"])
|
|
|
|
(defspec "predicates / tagged-value (Phase 4)"
|
|
["atom? yes" "true" "(atom? (atom 1))"]
|
|
["atom? no" "false" "(atom? 1)"]
|
|
["volatile? yes" "true" "(volatile? (volatile! 1))"]
|
|
["volatile? no" "false" "(volatile? (atom 1))"]
|
|
["record? yes" "true" "(do (defrecord Rp [a]) (record? (->Rp 1)))"]
|
|
["record? no map" "false" "(record? {:a 1})"]
|
|
["record? no nil" "false" "(record? nil)"]
|
|
["tagged-literal? yes" "true" "(tagged-literal? (tagged-literal (quote inst) \"2020\"))"]
|
|
["tagged-literal? no" "false" "(tagged-literal? 1)"]
|
|
["reader-conditional? no" "false" "(reader-conditional? 1)"]
|
|
["chunked-seq? always false" "false" "(chunked-seq? (seq [1 2 3]))"])
|
|
|
|
(defspec "predicates / equality & identity"
|
|
["= same" "true" "(= 1 1)"]
|
|
["= vectors" "true" "(= [1 2] [1 2])"]
|
|
["= vector & list" "true" "(= [1 2] (list 1 2))"]
|
|
["= maps" "true" "(= {:a 1} {:a 1})"]
|
|
["= sets" "true" "(= #{1 2} #{2 1})"]
|
|
["= nested" "true" "(= {:a [1 2]} {:a [1 2]})"]
|
|
["not= differs" "true" "(not= [1 2] [1 3])"]
|
|
["identical? same kw" "true" "(identical? :a :a)"]
|
|
["compare strings" "-1" "(compare \"a\" \"b\")"])
|
|
|
|
(defspec "predicates / seqable, reduced & emptiness"
|
|
["seqable? vector" "true" "(seqable? [1])"]
|
|
["seqable? map" "true" "(seqable? {:a 1})"]
|
|
["seqable? string" "true" "(seqable? \"s\")"]
|
|
["seqable? nil" "true" "(seqable? nil)"]
|
|
["seqable? number" "false" "(seqable? 5)"]
|
|
["integer? int" "true" "(integer? 5)"]
|
|
["integer? fraction" "false" "(integer? 5.5)"]
|
|
["reduced? wrapped" "true" "(reduced? (reduced 1))"]
|
|
["reduced? plain" "false" "(reduced? 1)"]
|
|
["deref reduced" "9" "(deref (reduced 9))"]
|
|
["unreduced wrapped" "9" "(unreduced (reduced 9))"]
|
|
["unreduced plain" "9" "(unreduced 9)"]
|
|
["not-empty full" "[1]" "(not-empty [1])"]
|
|
["not-empty empty" "nil" "(not-empty [])"]
|
|
["not-empty string" "nil" "(not-empty \"\")"])
|
|
|
|
# Stage 3 turn 2a: the implicit Janet root-env fallback is GONE — these are now
|
|
# proper interned clojure.core vars with Clojure semantics (compare's total
|
|
# order, meta-aware type, any?, gensym returning jolt symbols).
|
|
(defspec "predicates / compare, type, any? (stage 3)"
|
|
["compare =" "0" "(compare 1 1)"]
|
|
["compare <" "-1" "(compare 1 2)"]
|
|
["compare nil first" "-1" "(compare nil 1)"]
|
|
["compare nil nil" "0" "(compare nil nil)"]
|
|
["compare strings" "-1" "(compare \"a\" \"b\")"]
|
|
["compare keywords" "-1" "(compare :a :b)"]
|
|
["compare symbols" "-1" "(compare (quote a) (quote b))"]
|
|
["compare bools" "-1" "(compare false true)"]
|
|
["compare vec length" "-1" "(compare [1 2] [1 2 3])"]
|
|
["compare vec elems" "-1" "(compare [1 2] [1 3])"]
|
|
["compare cross-type throws" :throws "(compare 1 \"a\")"]
|
|
["sort with compare" "[nil 1 3]" "(sort compare [3 nil 1])"]
|
|
["type meta override" ":custom" "(type (with-meta [1] {:type :custom}))"]
|
|
["type of record" "true" "(do (defrecord TyR [a]) (= (symbol (str (type (->TyR 1)))) (type (->TyR 1))))"]
|
|
["any? value" "true" "(any? 5)"]
|
|
["any? nil" "true" "(any? nil)"]
|
|
["gensym is symbol" "true" "(symbol? (gensym))"]
|
|
["gensym prefix" "true" "(do (require (quote [clojure.string :as s])) (s/starts-with? (str (gensym \"p_\")) \"p_\"))"]
|
|
["gensym distinct" "false" "(= (gensym) (gensym))"]
|
|
["int? Inf false" "false" "(int? ##Inf)"]
|
|
["integer? Inf false" "false" "(integer? ##Inf)"]
|
|
["integer? NaN false" "false" "(integer? ##NaN)"])
|
|
|
|
# ifn? is the canonical IFn set (jolt-1vx): lists are NOT IFn.
|
|
(defspec "predicates / ifn?"
|
|
["fn" "true" "(ifn? inc)"]
|
|
["keyword" "true" "(ifn? :k)"]
|
|
["symbol" "true" "(ifn? (quote s))"]
|
|
["map" "true" "(ifn? {})"]
|
|
["sorted map" "true" "(ifn? (sorted-map))"]
|
|
["set" "true" "(ifn? #{1})"]
|
|
["vector" "true" "(ifn? [1])"]
|
|
["var" "true" "(ifn? (var first))"]
|
|
["list NOT" "false" "(ifn? (list 1 2))"]
|
|
["lazy NOT" "false" "(ifn? (map inc [1]))"]
|
|
["string NOT" "false" "(ifn? \"s\")"]
|
|
["number NOT" "false" "(ifn? 5)"]
|
|
["nil NOT" "false" "(ifn? nil)"])
|