Clojure Q&A - Recent questions tagged spec 2

clojure spec vs plumatic schema

Wed, 17 Apr 2024 04:11:04 +0000

A colleague brought to my attention that Clojure Spec is still alpha and that Plumatic Schema might be a better way to do the same tipe of spec.

Do you folks have any advice?

Cheers!

Spec 2: Closed Generators

Mon, 12 Sep 2022 08:36:26 +0000

Hello,

is it possible to get a "closed" generator from a `s/select` form
and/or make it the default in Spec 2?

From the example in the Wiki:

(ns user
  (:require [clojure.alpha.spec :as s]))

(s/def ::id int?)
(s/def ::first string?)
(s/def ::last string?)
(s/def ::user (s/schema [::id ::first ::last ::addr]))

(s/def ::my-user (s/select ::user [::id]))

(s/exercise ::my-user)

This generates users that have more keys than what I selected:

([#:user{:id 0} #:user{:id 0}]
 [#:user{:addr #:user{:city "1"}, :first "O", :id 0}
  #:user{:addr #:user{:city "1"}, :first "O", :id 0}])

I believe it is the same data which the `s/schema` for the `::user`
spec generates. My guess is this just hasn't been implemented yet.

Would it be possible to support this?

Clojure Spec 2. Unexpected s/with-gen behaviour

Fri, 09 Sep 2022 10:49:50 +0000

When using regular expression operators (s/alt s/cat etc ) to describe sequences, s/with-gen doesn't work as I would have expected. It completely ignores the generator passed to the definition. Eg:

(require '[clojure.alpha.spec :as s])
(require '[clojure.alpha.spec.gen :as gen])
(s/def ::some-spec 
 (s/with-gen string? (constantly (gen/return "olar"))))

(gen/sample (s/gen ::some-spec))
 ;;=> ("olar" "olar" "olar" "olar" "olar" "olar" "olar" "olar" "olar" "olar")

The above generator works as I would expected, now if we try to create a similar one for s/alt we get unexpected results:

(s/def ::some-other-spec 
 (s/with-gen
  (s/alt :greetings #{:olar :oizito :oi :hello :hey :yo :hallo}
             :farewell #{:bye :bye-bye :hasta-la-vista :tchussy :tchau-kakao})
  (constantly (gen/return [:tchau-kakao]))))

(gen/sample (s/gen ::some-other-spec))
;;=> => ([:olar] [:hasta-la-vista] [:hallo] [:hallo] [:tchussy] [:oi] [:bye-bye] [:tchussy] [:tchau-kakao] [:yo])

Is this a bug or is it expected somehow?

What is the canonical way to share bundles of predicates + generators in clojure spec?

Wed, 17 Nov 2021 11:51:41 +0000

I've been trying out Clojure spec and I often face situations in which I have to come up with a custom predicate function. Then sometimes these predicate functions require a custom generator. How can I share this predicate+generator bundle between different attributes?

(Also not so important but, can I call this bundle of predicate-fn + generator a spec?)

Example:
Suppose I have the custom predicate:

   (defn local-date? [x]
      (instance? LocalDate x))

and then I define a brand new generator function for it:

(defn local-date-generator []
  (gen/fmap #(LocalDate/ofInstant (Instant/ofEpochMilli %) (ZoneId/of "UTC")) 
                       (gen/large-integer)))

I can go on and define an attribute like:

(s/def :person/birth-date (s/with-gen local-date local-date-generator))

but then I would have to define this s/with-gen every time I create a LocalDate attribute.

How can I abstract that away?

I've come to the conclusion that the right way to do that would be to define an attribute in a namespace (e.g myprojec.specs) in which I create an attribute with that spec

(s/def ::local-date (s/with-gen local-date local-date-generator))

and then just re-use it elsewhere

(s/def :person/birth-date :myproject.specs/localdate)

What are the alternatives?

Spec2: Use case for multi-spec as Schema provider

Tue, 15 Jun 2021 21:18:25 +0000

I have a scenario where I'd like to define some attributes that are internal and common, and some other attributes that are external and dynamic, both related to the same "things". Specifically, I am trying to model a trading library. There are many different exchanges/brokers/services, but all of them talk about similar/equivalent things.
Let's take the example of an order, you can have some attributes that can be common in all services (they don't necessarily appear on all services):

(spec/def :order/id string?)
(spec/def :order/quantity number?)
(spec/def :order/side #{:buy :sell})

Then, every external service can have specific attributes related to how that service handles orders:

(spec/def :service1-order/execution-instructions (spec/coll-of string?))
(spec/def :service2-order/iceberg-quantity (spec/coll-of string?))

I was thinking on having a multi-spec returning schemas, so each service can define what schema to use for an order, on a key like :service/name, but all of them can be "selected" from :order/order.

(defmulti order-schema :service/name)

(defmethod order-schema :service1
  [_]
  (spec/schema [:order/id :order/quantity :order/side :service1-order/execution-instructions]))

(defmethod order-schema :service2
  [_]
  (spec/schema [:order/id :order/quantity :order/side :service2-order/iceberg-quantity]))

(defmethod order-schema :default
  [_]
  (spec/schema [:order/id :order/quantity :order/side]))

(spec/def :order/order (spec/multi-spec order-schema :service/name))

This can be useful also when nesting objects. Imagine I have an account that will contain orders. The account can also be specced as a multi-spec for each service:

(spec/def :account/id string?)
(spec/def :account/orders (spec/coll-of :order/order))

(spec/def :service1-account/type #{:spot :margin :futures})

(defmulti account-schema :service/id)

(defmethod account-schema :service1
  [_]
  (spec/schema [:account/id :account/orders :service1-account/type]))

(defmethod account-schema :default
  [_]
  (spec/schema [:account/id :account/orders]))

(spec/def :account/account (spec/multi-spec account-schema :service/id))

This would allow to select in the following manner:

(spec/def ::service1-account-info (spec/select :account/account [:service1-account/type :account/orders {:account/orders [:order/id :order/quantity :service1-order/execution-instructions]}]))

This way, external services can specify the information they handle about the common layer domain attributes and entities, as well as specify their specific attributes. The user is able to reuse a set of common functions that operate on the common attributes, and if different services provide these common attributes, they can be used interchangeably, while keeping a way to create functions and selections that are specific to specific services.

Does this use case make sense? Is there a different way to model this that would be better?

Thanks

Problems with s/union

Mon, 15 Mar 2021 09:49:01 +0000

While playing around with spec2, I'm seeing the following behavior which seems like a bug:

(s/def ::s1 (s/schema {:a string?}))
=> :dev.fp.livingdocs.specs/s1
(s/def ::s2 (s/schema {:b string?}))
=> :dev.fp.livingdocs.specs/s2
(s/def ::s3 (s/schema {:c string?}))
=> :dev.fp.livingdocs.specs/s3

;; The following is unexpected (neseted unions)
(s/def ::u (s/union ::s1 (s/union ::s2 ::s3)))
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval1665$fn$G     (protocols.clj:20).
No implementation of method: :keyspecs* of protocol: #'clojure.alpha.spec.protocols/Schema found for class: clojure.lang.PersistentList
(s/def ::u (s/union (s/union ::s1 ::s2) ::s3))
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval1665$fn$G (protocols.clj:20).
No implementation of method: :keyspecs* of protocol: #'clojure.alpha.spec.protocols/Schema found for class: clojure.lang.PersistentList

;; if I try to pull out the nested union into a separate keyword, it starts working 
(s/def ::u' (s/union ::s1 ::s2))
=> :dev.fp.livingdocs.specs/u'
(s/def ::u (s/union ::u' ::s3))
=> :dev.fp.livingdocs.specs/u
(s/explain (s/select ::u [:a :c]) {:a "bdfd"})
{:a "bdfd"} - failed: (fn [m] (contains? m :c))

;; but also this
(s/form ::ld/typed)
=>
(clojure.alpha.spec/schema
 [{:name clojure.core/string?, :type clojure.core/string?}])
(s/form ::ldd/editable)
=>
(clojure.alpha.spec/schema
 [{:optional clojure.core/boolean?,
   :maxLength clojure.core/integer?,
   :plainText clojure.core/boolean?,
   :excluexcludeFromTextCount clojure.core/boolean?}])
 
(s/def ::service
  (s/or :single (s/select (s/union ::ld/typed ::ldd/editable) [:type :name :optional])
         :multiple (s/select (s/union :ld/typed ::ldd/editable) [:type :name :maxLength])))
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval1665$fn$G (protocols.clj:20).
No implementation of method: :keyspecs* of protocol: #'clojure.alpha.spec.protocols/Schema found for class: clojure.lang.PersistentList

In both cases s/union shows up in a nested position inside a form passed to a spec macro.

I think there's a typo in spec2 that breaks if you don't alias clojure.alpha.spec -> s

Mon, 16 Nov 2020 06:12:55 +0000

In a project, I required + aliased clojure.alpha.spec like this:

(ns example.core
    (:require [clojure.alpha.spec :as spec]))

Then I tried to define a simple spec like

(spec/def ::example-spec #(not (neg? %)))

Compiling gave the error that namespace s was undefined.

I believe this came down to a typo in clojure.alpha.spec/def. In file spec-alpha2/src/main/clojure/clojure/alpha/spec.clj, line 456, there is a backquoted s/spec but the alias at the top of the file is to sa. Here's line 456:

    (#{'fn 'fn* `c/fn} op) `(s/spec ~explicated-form)

After changing the line to

(#{'fn 'fn* `c/fn} op) `(sa/spec ~explicated-form)

my spec/def works successfully.

Problem with (s/nest) and (s/describe) in spec-alpha2

Tue, 20 Oct 2020 16:55:08 +0000

It looks like calling (s/describe) for (s/nest) specs fails with an exception.

The following call:

(s/describe (s/nest int?))

fails with this exception:

IllegalStateException Attempting to call unbound fn: #'clojure.core/unquote
    clojure.lang.Var$Unbound.throwArity (Var.java:45)
    clojure.alpha.spec.impl/nest-impl/reify--1676 (impl.clj:647)
    clojure.alpha.spec/form (spec.clj:258)
    clojure.alpha.spec/form (spec.clj:254)
    clojure.alpha.spec/describe (spec.clj:282)
    clojure.alpha.spec/describe (spec.clj:279)
    stem.i.log/eval16342 (log.clj:91)
    stem.i.log/eval16342 (log.clj:91)
    clojure.lang.Compiler.eval (Compiler.java:7177)
    clojure.lang.Compiler.eval (Compiler.java:7132)
    clojure.core/eval (core.clj:3214)
    clojure.core.server/prepl/fn--8941 (server.clj:232)

in spec-alpha2 with the latest commit from master

{:git/url "https://github.com/clojure/spec-alpha2.git" :sha "d514b06b25c41a676b95afcc9bfac8ca34c5741e"}

Problem with select in schema with namespaced keys of schema with unnamespaced keys

Fri, 24 Jul 2020 18:43:51 +0000

In specs alpha 2, if we define a clojure.alpha.spec/select of a spec defined as a s/schema of a nested spec that is itself a s/schema, but of unnamespaced keys, and try to use it with either s/valid? or s/exercise, we get exceptions:
s/valid throws *"No implementation of method: :conform of protocol: #'clojure.alpha.spec.protocols/Spec found for class: clojure.lang.Keyword" and s/exercise throws "Unable to resolve spec: :foo"** (where :foo is the unnamespaced key).

An example can illustrate the issue better:

; Context
(s/def ::foo int?)
(s/def ::inner (s/schema [{:foo ::foo}]))
(s/def ::outer (s/schema [::inner]))

; Works as expected:
(s/exercise ::outer)
(s/exercise (s/select ::inner [*]))
(s/valid? (s/select ::inner [*]) {:foo 10})

; Fails with "Unable to resolve spec: :foo"
(s/exercise (s/select ::outer [*]))

; Fails with "No implementation of method: :conform* of protocol: #'clojure.alpha.spec.protocols/Spec found for class: clojure.lang.Keyword"
(s/valid? (s/select ::outer [*]) {::inner {:foo 10}})

In Spec 2, is this a bug?

Wed, 11 Mar 2020 10:06:44 +0000

Just reporting an error I've come across while using Spec 2 of SHA "b29ae46".

(s/def ::special-name   
  (s/and string? #(clojure.string/starts-with? % "Special")))
(s/def ::schema-1    (s/schema [::special-name]))
(s/valid? ::schema-1 {::special-name "Special Person"})
;;=> true

(s/def ::name        ::special-name)
(s/def ::schema-2    (s/schema [::name]))
(s/valid? ::schema-2 {::name "Special Person"})
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval5664$fn$G (protocols.clj:11).
No implementation of method: :conform* of protocol: #'clojure.alpha.spec.protocols/Spec found for class: clojure.lang.Keyword

In Spec 2, are nested schemas illegal?

Wed, 11 Mar 2020 09:27:15 +0000

One of the problems that I've run into while using Spec 2.

(s/def ::number      number?)
(s/def ::boolean     boolean?)
(s/def ::schema      (s/schema [::number ::boolean]))
(s/def ::only-number (s/select ::schema [::number]))
(s/def ::this-works  (s/keys :req [::only-number]))
(s/def ::this-fails  (s/schema [::only-number]))
Execution error (AssertionError) at clojure.alpha.spec.impl/schema-impl (impl.clj:422).
Assert failed: (every? (fn* [p1__6948#] (if-let [sp (s/get-spec p1__6948#)] (not (select? sp)) true)) ks)

I made up this example to replicate an error I've got while I was creating a wrapper for AWS DynamoDB REST API.