I'm writing my first regular expression of specs. Both these tests should pass:

A :sherman.grammar/expanding-term should contain ONE or more :sherman.grammar/expanding-symbols, and ZERO or more :sherman.grammar/terminating-symbols

I thought this might be it:

At least, I thought that would handle "This is #going# #to# #expand# maybe"

which isn't fully what I'm after but would be partway

have you tried s/alt

I diiiid but not very well

Come to think of it I don't know that my input data is regular

I'm trying to express, "A string that, if you split it at the spaces, one or more of the elements of that collection would be an ::expanding-symbol"

Maybe I should write a function that tests that, and uses it as the predicate

I wanted to check here to see if there is a way to alt this intent

seems like s/cat works for your case unless I’m missing something

oh wait, you want your inputs to be actual strings?

s/alt could spec the result of splitting the string at spaces

in that case, I think I’d tokenize the string before spec’ing it

Getting there. I'm incorrect about what s/+ means, though:

I've changed my terminology a little, but I'm still failing to reject invalid input:

I hypothesize that the right thing to do is to make functions do more work, and specs do less. E.g., much as noisesmith suggested when they suggested tokenizing first, I could have a predicate which detects well-formed tokens, and base a spec off of that

I'm still working out what responsibilities belong in spec and what belong in plain ol' clojure code 🙂

@mathpunk another option using s/&:

(s/def ::valid-term
  (s/& (s/* (s/alt :terminating ::terminating-symbol
                   :expanding ::expanding-symbol))
       #(some (comp #{:expanding} first) %)))
(s/conform ::valid-term (tokenize "This #expands# also"))
=> [[:terminating "This"] [:expanding "#expands#"] [:terminating "also"]]

I'll channel Alex Miller and say clojure.spec is not intended for string parsing -- there are much better tools out that for that (e.g., instaparse).

The "regular expression" part of spec is intended for sequence processing.

^ @mathpunk

I've wondered exactly this!: whether instaparse was obsolete after spec

It is not

Come join us

We have cookies

And somewhat lackluster but existent respond rate to issues

I would expect clojure.spec.alpha/and to be commutative. Is anyone else seeing this behavior?

> *clojurescript-version*
"\"1.9.946\""
> (defn f [m] (println m) (-> m (get 1) :db/id (= 1)))
"#'invest-calc.state/f"
> (s/def :account/works (s/and f (s/map-of any? (s/keys))))
":account/works"
> (s/def :account/fails (s/and (s/map-of any? (s/keys)) f))
":account/fails"
> (s/conform :account/works {1 {:db/id 1}})
{1 #:db{:id 1}}
"{1 #:db{:id [:db/id 1]}}"
> (s/conform :account/fails {1 {:db/id 1}})
{1 #:db{:id [:db/id 1]}}
":cljs.spec.alpha/invalid"

s/and flows conformed results through predicates

Heh, I guess I should read the docs closer. Is it expected that it would operate differently in normal Clojure?

invest-calc.state> *clojure-version*
{:major 1, :minor 9, :incremental 0, :qualifier nil}
invest-calc.state> (defn f [m] (println m) (-> m (get 1) :db/id (= 1)))
#'invest-calc.state/f
invest-calc.state> (s/def :account/works (s/and f (s/map-of any? (s/keys))))
:account/works
invest-calc.state> (s/def :account/fails (s/and (s/map-of any? (s/keys)) f))
:account/fails
invest-calc.state> (s/conform :account/works {1 {:db/id 1}})
{1 #:db{:id 1}}
{1 #:db{:id 1}}
invest-calc.state> (s/conform :account/fails {1 {:db/id 1}})
{1 #:db{:id 1}}
{1 #:db{:id 1}}