Polymorphic schemas

[frenchy64]

Close #846
Depends on #1071

I went through several iterations on the internal representation. It felt correct once the serialized form of a polymorphic schema was human readable and ergonomic (doesn't require quoting to evaluate correctly, so no symbols allowed). The tradeoff is that we need to implement capture-avoiding substitution, and that's very error-prone. I tested a few cases.

The identity schema's form is [:all [:X] [:-> :X :X]]. It's introduced with the m/all macro by (m/all [X] [:-> X X]).

To instantiate it, you perform a walk/postwalk-replace with {:X this-to-instantiate}.

(m/inst (m/all [X] [:-> X X])
        [:int])
;=> [:-> [:schema :int] [:schema :int]]

The extra :schema's make sure regex's don't splice. By default, variables are single schemas.

This representation is delicate, but works and is serializable if a few rules are followed:

It's a leaf schema, and it's essential that its body is not manipulated by users before instantiating it.

For example, variables are renamed if they clash with any keywords in the body:

(m/all [cat] [:=> [:cat cat] cat])
;=> [:all [:cat0] [:=> [:cat :cat0] :cat0]]

m/inst also does renaming to avoid capture. A variable can be "captured" by any schema, not just another variable, since variables are keywords and so are schemas.

The following renames to :y0 because if it was :y, then instantiation would destroy the body via (postwalk-replace {:y ...}).

(m/inst (m/all [x] (m/all [y] x))
        [(m/all [y] y)])
;=> [:all [:y0] [:schema [:all [:y] :y]]]

I don't know how to generate polymorphic functions, but there's some ideas in my deterministic function PR #1042

The mg/check implementation is pretty simple and can be improved. It just instantiates variables to very small schemas of a single value.

[NoahTheDuke]

Should you have three different schemas here? I know the two enums are technically different, but maybe :nil, [:enum 50] and [:map-of :keyword :any] or something would better clarify what's happening.

[frenchy64]

Currently it really is this simple, more like:

[:fn {:gen/return nil} (fn [r] (= nil r))]
[:fn {:gen/return 50} (fn [r] (= 50 r))]
[:fn {:gen/return 5333344553} (fn [r] (= 5333344553 r))]

[NoahTheDuke]

Oh interesting, okay.

[frenchy64]

To go further we'll need to think about what it means to shrink a schema. There are ideas in the spec impl of this, but this is the minimal proof-of-concept.

[frenchy64]

I will elaborate on exactly what happens in the docs though, thanks for the feedback.

[frenchy64]

Found the reason I needed such a convoluted representation in the first place: #1070

[frenchy64]

I will elaborate on exactly what happens in the docs though, thanks for the feedback.

Done.

[frenchy64]

Moved to frenchy64#11