Some alternatives I'm aware of:

user=> (m/explain [:fn #'even?] nil)
{:schema [:fn #'clojure.core/even?], :value nil, :errors ({:path [], :in [], :schema [:fn #'clojure.core/even?], :value nil, :type nil})}
user=> (m/explain [:fn '(fn [x] (even? x))] nil)
{:schema [:fn (fn [x] (even? x))], :value nil, :errors ({:path [], :in [], :schema [:fn (fn [x] (even? x))], :value nil, :type :sci/error})}
user=> (m/explain [:fn `(fn [x#] (even? x#))] nil)
{:schema [:fn (clojure.core/fn [x__11833__auto__] (clojure.core/even? x__11833__auto__))], :value nil, :errors ({:path [], :in [], :schema [:fn (clojure.core/fn [x__11833__auto__] (clojure.core/even? x__11833__auto__))], :value nil, :type :sci/error})}
user=> (m/explain [:fn `#(even? %)]  nil)
{:schema [:fn (fn* [p1__11870__11871__auto__] (clojure.core/even? p1__11870__11871__auto__))], :value nil, :errors ({:path [], :in [], :schema [:fn (fn* [p1__11870__11871__auto__] (clojure.core/even? p1__11870__11871__auto__))], :value nil, :type :sci/error})}

That's one reason I dislike function schemas. Everything becomes a hassle

Could use :gen/schema on the :or to override the generator spec for a spec.

This works

(me/humanize
 (m/explain [:or
             [:map ["a" [:map ["b" [:= "1"]]]]]
             [:map ["a" [:map ["b" [:= "2"]]]]]]
            {"a" {"b" "3"}}))

protip: :or schemas give worse error messages than :multi schemas, if you can transform your code to use :multi, they perform better too, since they don’t have to check every branch (they’d report an error for each :or branch).

(humanize
  (m/explain [:multi {:dispatch map?}
              [true [:multi {:dispatch #(contains? % "a")}
                     [true [:map ["a" [:multi {:dispatch #(contains? % "b")}
                                       [true [:map ["b" [:not= "1"]]]]
                                       [false :any]]]]]
                     [false :any]]]
              [false :any]]
             {"a" {"b" "1"}}))
{"a" {"b" ["should not be 1"]}}

As you noticed, :not erases any error messages, so you need to formulate the spec positively up to the leaves. Negating a nested map is a very broad spec. That's equivalent to [:not [:map ["a" [:map ["b" [:= "1"]]]]].

I trying to understand how big the task would be to rewrite what I have to use :multi as in your example. What I do not is that I have lots of boolean expressions I parse from strings getting an AST that maps very close to exactly what I have in malli which is nice, then I combine then inside a :and spec in malli. This works nice for my use case of generating data (with some extra magic), however what I am trying now is to use it to also validate data and get good error messages. The expressions I build can get big and complex but they will always have forms like

[:and
 [:not [:map ["a" [:map ["b" [:= "1"]]]]]]
 [:map ["a" [:map ["b" [:= "1"]]]]]
 [:not
  [:or
   [:map ["c" [:map ["d" [:= "1"]]]]]
   [:map ["c" [:map ["d" [:= "2"]]]]]]]
 [:or
  [:map ["a" [:map ["b" [:= "1"]]]]]
  [:map ["c" [:map ["d" [:= "2"]]]]]]]

[:not
  [:or
   [:map ["c" [:map ["d" [:= "1"]]]]]
   [:map ["c" [:map ["d" [:= "2"]]]]]]]

[:map ["c" [:map ["d" [:or [:not= "1"] [:not= "2"]]]]]]

I looked a bit more into this and I haven't worked out how to completely eliminate :or. The problem is that it's not obvious what to use as the dispatch function in general. I'm going to think about it over the weekend and get back to you.

Perhaps one solution would be to push the :not's in to leaves, and allow :or but improve the error message calculation logic for :or. I'll look into that too.

Here's my progress on pushing in :not . Please try it out. Instead of generating [:not s] instead return the result of (malli.negate/negate s). https://github.com/frenchy64/malli/compare/master...fecb20a03d3165816026a47bd10bd8bc488f2647

Oh, but you said that [:or :map :map] worked right? So perhaps this will work for you^

Hawing the following still return unknown error

(me/humanize
 (m/explain
  (mneg/negate
   [:or
    [:map ["a" [:map ["b" [:= "1"]]]]]
    [:map ["a" [:map ["b" [:= "2"]]]]]]
   ){"a" {"b" "1"}})) 

I wonder if not using De Morgans Law and rewrite my expression would work the best, will experiment more with that. The the case

[:not
 [:or
  [:map ["a" [:map ["b" [:= "1"]]]]]
  [:map ["a" [:map ["b" [:= "2"]]]]]]]

[:and
 [:map ["a" [:map ["b" [:not= "1"]]]]]
 [:map ["a" [:map ["b" [:not= "2"]]]]]]

(me/humanize
 (m/explain [:and
             [:map ["a" [:map ["b" [:not= "1"]]]]]
             [:map ["a" [:map ["b" [:not= "2"]]]]]]
            {"a" {"b" "1"}}))

Will have to do some full testing for more cases once I get back to work, but something like this is what im aiming at maybe

(defn negate-eq
  [tree]
  (w/postwalk
   (fn [s]
     (if (= s :=)
       :not= s)) tree)
  )

(w/postwalk
 (fn [s]
   (if (vector? s)
     (case (first s)
       :not
       (case (first (second s))
         :map (negate-eq s)
         :or (into [:and] (mapv negate-eq (drop 1 (second s))))
         :and (into [:or] (mapv negate-eq (drop 1 (second s))))
         s) s)
     s))
 [:not
  [:or
   [:map ["a" [:map ["b" [:= "1"]]]]]
   [:map ["a" [:map ["b" [:= "2"]]]]]]])

I think it's more subtle that than. Those aren't equivalent schemas.

(m/validate
    [:not
     [:or
      [:map ["a" [:map ["b" [:= "1"]]]]]
      [:map ["a" [:map ["b" [:= "2"]]]]]]]
    {})
  ;=> true
  (m/validate
    [:and
     [:map ["a" [:map ["b" [:not= "1"]]]]]
     [:map ["a" [:map ["b" [:not= "2"]]]]]]
    {})
  ;=> false

Following my nose to try and make equivalent schemas is how I ended up with these kinds of negations:

(mn/negate
    [:or
     [:map ["a" [:map ["b" [:= "1"]]]]]
     [:map ["a" [:map ["b" [:= "2"]]]]]])
  ;=> [:and
  ;    [:or
  ;     [:not #'clojure.core/map?]
  ;     [:map ["a" {:optional true} :never]]
  ;     [:map ["a" [:or [:not #'clojure.core/map?] [:map ["b" {:optional true} :never]] [:map ["b" [:not= "1"]]]]]]]
  ;    [:or
  ;     [:not #'clojure.core/map?]
  ;     [:map ["a" {:optional true} :never]]
  ;     [:map ["a" [:or [:not #'clojure.core/map?] [:map ["b" {:optional true} :never]] [:map ["b" [:not= "2"]]]]]]]]

I will need to try and understand all this, I still dont understand why my expressions are not generating the same schema when I do think the boolean algebra I use is valid so the two expressions should be equal. But I am far from an expert. I will keep working on this with the help from your inputs.

Perhaps it might help to think of specs as sets of values, and the negation of a spec as the set of all the other values. [:map [:a [:= 1]] includes {:a 1}. its negation includes every other value, including non-maps.

Might not be what you are after but you can still use float? like this for example

(m/validate [:set float?] #{(float 3.3)})

Yup yup that would work, though it seems in malli float? is sometimes treated as a double too. Which is a little confusing to me, I wonder if :float is mostly an alias to :double or is meant to be distinct?

I think one way to handle this is to use content dependent schemas ? https://github.com/metosin/malli?tab=readme-ov-file#content-dependent-simple-schema

what I don't seem to find in malli is how to implement validation for keys by regular expressions.

"patternProperties": {"^x-": {}}

Class-based schemas, contains java.util.regex.Pattern & js/RegExp