How to check Clojure, macro specs?

See also questions close to this topic

• Catch multiple exceptions in Clojure and handle them the same

  This is a bit similar to this question, but I want to catch multiple exceptions and handle them all the same. In Ruby, I can write

  begin
    rand(2) == 0 ? ([] + '') : (foo)
  rescue TypeError, NameError => e
    puts "oops: #{e.message}"
  end
  

  Can I do the same in Clojure? For now I let a function and just call it in each catch body.
• How do I add a click event to trigger a JavaScript event in ClojureScript using Reagent Hiccup

  I have just started using Reagent and am very new to Clojure.

  I have created a mobile menu function and want the mobile hamburger menu to be clickable in order to show the actual menu. When clicked on again, the menu must hide. I have no idea how to do

  (defn mobile-menu [primary-menu secondary-menu logo-el]
   [:div#ca-horizontal-mobile
    [:div#logo logo-el]
    [:div#menu-button
     [:a
      [:i.icon.bars]]]
  
    [:header#menu.mobile
     [:div
      [:div.center.menu
       (let [menu (concat primary-menu secondary-menu)]
         (for [i menu]
           [:div.item {:key (:key i)}
            [:a.item {:id   (:key i)
                      :href (:target i)} (:name i)]]))
       [:div.item
        [:a
         {:style    {:cursor :pointer}
          :id       :logout
          :on-click #(re-frame/dispatch [:logout])} (str "Logout")]]]]]])])
  

  The anchor needs to expand and hide the menu.

     [:a
      [:i.icon.bars]]]
  

  All I need is an example of how to make a JavaScript call on a JavaScript event and a little bit of help understanding it.

  I found this snippet online https://www.reddit.com/r/Clojure/comments/4ofct5/calling_methods_on_an_element_in_a_reagent/ but am unsure how it hooks up to anything. How does the .play element know what to do on-click?

  (defn video-elem [src-url uid]
    [:div
      [:video {:src src-url :id uid}]
          [:button {:on-click #(.play (.getElementById js/document uid))} "Play!"]
          [:button {:on-click #(.pause (.getElementById js/document uid))} "Pause!"]])
  
• How to deploy and run clojurescript application in Heroku

  I have a template of a clojurescript application from https://github.com/Day8/re-frame-template. So I want to deploy that template without any modifications to Heroku. So I followed the instructions on the README lein clean lein cljsbuild once min. Then I follow the instructions on Heroku as well on deploying clojure on https://devcenter.heroku.com/categories/clojure-support

  But when I check if the application runs all I get is an application error. So my questions are:

  1. How does one build and deploy a clojurescript app to heroku?
  2. What is the difference in deploying a clojurescript app vs a clojure app
  3. Do I need a clojure server in order to run clojurescript?
  4. How does one even run a standalone clojurescript app on the desktop?
  5. How is the generated app.js related to running a clojurescript app?

  I have found it pretty easy to deploy and run a clojure app on Heroku as well as a standalone applicaton on my desktop, I was hoping the same would be true for clojurescript.

  Edited: The error is here: https://floating-depths-33030.herokuapp.com/
• Compare a string in a list of string in TeraTerm

  I am trying to compare if a string variable will appear in a list of of strings. The scenario is as follow; System will print a list of values which will indicate "OK" for each value (total number of values is not definite) and if there will be a "Fail", it will show system error.

  I tried using the below but did not seem to work. Someone kindly help. Thank you.

  strCheck = ''
  strconcat strCheck 'OK'
  
  wait StrCheck
  
  if strCheck != 'OK'
      goto error
  else
      messagebox 'All system OK.' 'OK'
  endif
  
  :error
  
• WinActivate brings up the window but window then becomes not active

  I'm using WinActivate and I am able to bring up the window but the window then becomes not active / selected (the title bar in the window is grayed instead of the dark blue or bright color when the window is selected). I would need to click on the window and manually perform the next step in the macro before the rest of the macro will run. Sometimes when I run the macro it runs perfectly and the window comes up and stays activated. But other times the macro stalls after the window is brought up but I notice the window is not really selected/activated (the title bar of the window dims with the appearance similar to when I click outside the window). I've tried WinRestore and still getting the problem.
• Implicit argument in Rust macros

  I'm trying to understand how Rust macro captures work and am looking at the nom parser library.

  Location nom/src/bytes.rs declares macro tag! which captures with ($i:expr, $tag: expr). However throughout the places where tag! is used it is used with only one argument, i.e. tag!("+"). Example: nom-lua52/op.rs. I've read tutorials about macros however this construct seems to be special.

  It seems like the input $i is somehow implicit?
• Proper nesting of Clojure Specs?

  I think I may have a problem with the correct order of nesting Specs within a function - specifically s/with-gen and s/or...

  I have this function and Spec:

  (defn set-gift-pair-in-gift-history [g-hist g-year g-pair]
    (if (nil? g-hist)
      [{:giver :none, :givee :none}]
      (assoc g-hist g-year g-pair)))
  (s/fdef set-gift-pair-in-gift-history
          :args (s/with-gen
                  (s/or :input-hist (s/and
                                      (s/cat :g-hist :unq/gift-history
                                             :g-year (s/and int? #(> % -1))
                                             :g-pair :unq/gift-pair)
                                      #(<= (:g-year %) (count (:g-hist %))))
                        :input-nil (s/and
                                     (s/cat :g-hist nil?
                                            :g-year (s/and int? #(> % -1))
                                            :g-pair :unq/gift-pair)
                                     #(<= (:g-year %) (count (:g-hist %)))))
                  #(gen/let [hist (s/gen :unq/gift-history)
                             year (gen/large-integer* {:min 0 :max (max 0 (dec (count hist)))})
                             pair (s/gen :unq/gift-pair)]
                     [hist year pair]))
          :ret :unq/gift-history)
  

  Which tests correctly:

  (stest/check `set-gift-pair-in-gift-history)
  =>
  ({:spec #object[clojure.spec.alpha$fspec_impl$reify__2451
                  0x729d93b6
                  "clojure.spec.alpha$fspec_impl$reify__2451@729d93b6"],
    :clojure.spec.test.check/ret {:result true,
                                  :num-tests 1000,
                                  :seed 1531413555637},
    :sym clojure-redpoint.roster/set-gift-pair-in-gift-history})
  

  And its parameters conform correctly:

  (s/conform (s/or :input-hist (s/and
                                 (s/cat :g-hist :unq/gift-history
                                        :g-year (s/and int? #(> % -1))
                                        :g-pair :unq/gift-pair)
                                 #(<= (:g-year %) (count (:g-hist %))))
                   :input-nil (s/and
                                (s/cat :g-hist nil?
                                       :g-year (s/and int? #(> % -1))
                                       :g-pair :unq/gift-pair)
                                #(<= (:g-year %) (count (:g-hist %)))))
             [[{:giver :GeoHar, :givee :JohLen}] 0 {:giver :RinStaXX, :givee :PauMccXX}])
  =>
  [:input-hist
   {:g-hist [{:giver :GeoHar, :givee :JohLen}],
    :g-year 0,
    :g-pair {:giver :RinStaXX, :givee :PauMccXX}}]
  
  (s/conform (s/or :input-hist (s/and
                                 (s/cat :g-hist :unq/gift-history
                                        :g-year (s/and int? #(> % -1))
                                        :g-pair :unq/gift-pair)
                                 #(<= (:g-year %) (count (:g-hist %))))
                   :input-nil (s/and
                                (s/cat :g-hist nil?
                                       :g-year (s/and int? #(> % -1))
                                       :g-pair :unq/gift-pair)
                                #(<= (:g-year %) (count (:g-hist %)))))
             [nil 0 {:giver :RinStaXX, :givee :PauMccXX}])
  =>
  [:input-nil
   {:g-hist nil, :g-year 0, :g-pair {:giver :RinStaXX, :givee :PauMccXX}}]
  

  But when this "correct" function is consumed by a second function:

  (defn set-gift-pair-in-roster [plrs-map plr-sym g-year g-pair]
    (let [plr (get-player-in-roster plrs-map plr-sym)
          gh (get-gift-history-in-player plr)
          ngh (set-gift-pair-in-gift-history gh g-year g-pair)
          nplr (set-gift-history-in-player ngh plr)]
      (assoc plrs-map plr-sym nplr)))
  (s/fdef set-gift-pair-in-roster
          :args (s/cat :plrs-map ::plr-map
                       :plr-sym keyword?
                       :g-year (s/and int? #(> % -1))
                       :g-pair :unq/gift-pair)
          :ret ::plr-map)
  

  The consumed function becomes a source of error for the consuming function (the nil case - which I thought was handled):

  (stest/check `set-gift-pair-in-roster)
  =>
  ({:spec #object[clojure.spec.alpha$fspec_impl$reify__2451
                  0x3bbc704a
                  "clojure.spec.alpha$fspec_impl$reify__2451@3bbc704a"],
    :clojure.spec.test.check/ret {:result #error{:cause "Call to #'clojure-redpoint.roster/set-gift-pair-in-gift-history did not conform to spec:
                                                         In: [0] val: nil fails spec: :unq/gift-history at: [:args :input-hist :g-hist] predicate: vector?
                                                         val: {:g-hist nil, :g-year 1, :g-pair {:givee :_+, :giver :RJK/Y24}} fails at: [:args :input-nil] predicate: (<= (:g-year %) (count (:g-hist %)))
  

  I have tried changing the order and grouping (nesting) of the specs in the consumed function - but then it fails the tests that it used to pass, before even getting to testing the consuming function.

  Any thoughts on what is going wrong here?

  Thank you!

  EDIT:

  As suggested, here is the full code for a better understanding:

  ;Here is an example of The Beatles keeping track of the Xmas gifts
  ;they give to each other (:giver and :givee) each year over time:
  
  (ns clojure-redpoint.roster2
    (:require [clojure.spec.alpha :as s]
              [orchestra.spec.test :as st]
              [clojure.test.check.generators :as gen]
              [clojure.spec.test.alpha :as stest]))
  
  (s/def ::givee keyword?)
  (s/def ::giver keyword?)
  (s/def :unq/gift-pair (s/keys :req-un [::givee ::giver]))
  (s/def ::name string?)
  (s/def :unq/gift-history (s/coll-of :unq/gift-pair :kind vector?))
  (s/def :unq/player (s/keys :req-un [::name :unq/gift-history]))
  (s/def ::plr-map (s/map-of keyword? :unq/player))
  
  
  (defn- get-player-in-roster [plrs-map plr-sym]
    (get plrs-map plr-sym))
  (s/fdef get-player-in-roster
          :args (s/cat :plrs-map ::plr-map :plr-sym keyword?)
          :ret (s/or :found :unq/player
                     :not-found nil?))
  
  (defn- get-gift-history-in-player [plr]
    (get plr :gift-history))
  (s/fdef get-gift-history-in-player
          :args (s/or :input-plr (s/cat :plr :unq/player)
                      :input-nil (s/cat :plr nil?))
          :ret (s/or :found :unq/gift-history
                     :not-found nil?))
  
  (defn set-gift-pair-in-gift-history [g-hist g-year g-pair]
    (if (nil? g-hist)
      [{:giver :none, :givee :none}]
      (assoc g-hist g-year g-pair)))
  (s/fdef set-gift-pair-in-gift-history
          :args (s/with-gen
                  (s/or :input-hist (s/and
                                      (s/cat :g-hist :unq/gift-history
                                             :g-year (s/and int? #(> % -1))
                                             :g-pair :unq/gift-pair)
                                      #(<= (:g-year %) (count (:g-hist %))))
                        :input-nil (s/and
                                     (s/cat :g-hist nil?
                                            :g-year (s/and int? #(> % -1))
                                            :g-pair :unq/gift-pair)
                                     #(<= (:g-year %) (count (:g-hist %)))))
                  #(gen/let [hist (s/gen :unq/gift-history)
                             year (gen/large-integer* {:min 0 :max (max 0 (dec (count hist)))})
                             pair (s/gen :unq/gift-pair)]
                     [hist year pair]))
          :ret :unq/gift-history)
  
  (defn set-gift-history-in-player [g-hist plr]
    (if (or (nil? g-hist) (nil? plr))
      {:name "none", :gift-history [{:giver :none, :givee :none}]}
      (assoc plr :gift-history g-hist)))
  (s/fdef set-gift-history-in-player
          :args (s/or :input-good (s/cat :g-hist :unq/gift-history
                                         :plr :unq/player)
                      :input-hist-nil (s/cat :g-hist nil?
                                             :plr :unq/player)
                      :input-plr-nil (s/cat :g-hist :unq/gift-history
                                            :plr nil?)
                      :input-both-nil (s/cat :g-hist nil?
                                             :plr nil?))
          :ret :unq/player)
  
  (defn set-gift-pair-in-roster [plrs-map plr-sym g-year g-pair]
    (let [plr (get-player-in-roster plrs-map plr-sym)
          gh (get-gift-history-in-player plr)
          ngh (set-gift-pair-in-gift-history gh g-year g-pair)
          nplr (set-gift-history-in-player ngh plr)]
      (assoc plrs-map plr-sym nplr)))
  (s/fdef set-gift-pair-in-roster
          :args (s/cat :plrs-map ::plr-map
                       :plr-sym keyword?
                       :g-year (s/and int? #(> % -1))
                       :g-pair :unq/gift-pair)
          :ret ::plr-map)
  
  (st/instrument)
  
  (def roster-map
    {:RinSta {:name "Ringo Starr", :gift-history [{:giver :RinSta, :givee :PauMcc}]},
     :JohLen {:name "John Lennon", :gift-history [{:giver :JohLen, :givee :GeoHar}]},
     :GeoHar {:name "George Harrison", :gift-history [{:giver :GeoHar, :givee :JohLen}]},
     :PauMcc {:name "Paul McCartney", :gift-history [{:giver :PauMcc, :givee :RinSta}]}})
  
  (s/conform ::plr-map
             (set-gift-pair-in-roster roster-map :PauMcc 0 {:giver :JohLenXXX, :givee :GeoHarXXX}))
  ;=>
  ;{:RinSta {:name "Ringo Starr", :gift-history [{:giver :GeoHar, :givee :JohLen}]},
  ; :JohLen {:name "John Lennon", :gift-history [{:giver :RinSta, :givee :PauMcc}]},
  ; :GeoHar {:name "George Harrison",
  ;          :gift-history [{:giver :PauMcc, :givee :RinSta}]},
  ; :PauMcc {:name "Paul McCartney",
  ;          :gift-history [{:giver :JohLenXXX, :givee :GeoHarXXX}]}}
  
  ;(stest/check `set-gift-pair-in-roster)
  

  Unfortunately, it did not help me find my error...
• Clojure Spec and "Couldn't satisfy such-that predicate after 100 tries..."

  Let's say you have a ::givee and a ::giver:

  (s/def ::givee keyword?)
  (s/def ::giver keyword?)
  

  That form a unq/gift-pair:

  (s/def :unq/gift-pair (s/keys :req-un [::givee ::giver]))
  

  And then you have a :unq/gift-history which is a vector of unq/gift-pair:

  (s/def :unq/gift-history (s/coll-of :unq/gift-pair :kind vector?))
  

  Last, suppose you want to replace one of the :unq/gift-pair in the vector:

  (defn set-gift-pair-in-gift-history [g-hist g-year g-pair]
    (assoc g-hist g-year g-pair))
  (s/fdef set-gift-pair-in-gift-history
          :args (s/and (s/cat :g-hist :unq/gift-history
                              :g-year int?
                              :g-pair :unq/gift-pair)
                       #(< (:g-year %) (count (:g-hist %)))
                       #(> (:g-year %) -1))
          :ret :unq/gift-history)
  

  All works fine:

  (s/conform :unq/gift-history
             (set-gift-pair-in-gift-history [{:givee :me, :giver :you} {:givee :him, :giver :her}] 1 {:givee :dog, :giver :cat}))
  => [{:givee :me, :giver :you} {:givee :dog, :giver :cat}]
  

  Until I try tostest/check it:

  (stest/check `set-gift-pair-in-gift-history)
               clojure.lang.ExceptionInfo: Couldn't satisfy such-that predicate after 100 tries.
  java.util.concurrent.ExecutionException: clojure.lang.ExceptionInfo: Couldn't satisfy such-that predicate after 100 tries. {}
  

  I have tried using s/int-in to limit the vector count (thinking that may be the problem) without success.

  Any ideas on how to run (stest/check `set-gift-pair-in-gift-history) correctly?

  Thank you.
• Clojure Spec - Issue with spec/or nested in spec/and

  I've recently been trying out Clojure Spec and ran into an unexpected error message. I've figured out that if you have a spec/or nested in a spec/and then the spec functions, after the spec/or branch, get passed a conformed value rather than the top level value.

  You can see this in the printed value of "v" here (contrived example):

  (spec/valid? (spec/and (spec/or :always-true (constantly true))
                         (fn [v]
                           (println "v:" v)
                           (constantly true)))
           nil)
  v: [:always-true nil]
  => true
  

  I think this may be intentional from the doc string of spec/and:

  Takes predicate/spec-forms, e.g.

  (s/and even? #(< % 42))

  Returns a spec that returns the conformed value. Successive conformed values propagate through rest of predicates.

  But this seems counterintuitive to me as it would hamper reuse of spec predicates, because they'd need to be written to accept "[<or branch> <actual value>]".

  Things get even worse if you have multiple spec/or branches:

  (spec/valid? (spec/and (spec/or :always-true (constantly true))
                         (spec/or :also-always-true (constantly true))
                         (fn [v]
                           (println "v:" v)
                         (constantly true)))
           nil)
  v: [:also-always-true [:always-true nil]]
  => true
  

  Have I missed something fundamental here?
• Why is my Scalacheck test with a custom Generator failing after discarding many cases, and how do I fix this?

  I am a newbie with Scala and I am writing my first Scalacheck suite.

  I have a data structure in my program that essentially looks like a (List[Double], List[Double]) which is well-formed only if each element of _1 is strictly greater than the corresponding element of _2.

  Since it's slightly more complicated in practice (although for the purpose of this MWE we can pretend there's all there is to it), I've written a custom generator for it.

  I then added two trivial tests (including the most trivial of all, 1 == 1) and in both cases the tests fail, with the messageGave up after only XX passed tests. YYY tests were discarded.

  Why is it, and how do I fix it?

  Attached is my test suite and the output.

  ---

  package com.foo.bar
  
  import org.scalacheck._
  import Prop._
  import Arbitrary._
  
  object FooSpecification extends Properties("FooIntervals") {
  
    type FooIntervals = (List[Double], List[Double])
  
    /* This is supposed to be a tuple of lists s.t. each element of _1
     *  is < the corresponding element of _2
     * 
     *  e.g. (List(1,3,5), List(2,4,6))
     */
  
    implicit def arbInterval : Arbitrary[FooIntervals] =
      Arbitrary {
        /**
          * Yields a pair (low, high) s.t. low < high
          */
        def GenPair : Gen[(Double, Double)] = for {
          low <- arbitrary[Double]
          high <- arbitrary[Double].suchThat(_ > low)
        } yield (low, high)
  
        /**
          * Yields (List(x_1,...,x_n), List(y_1,...,y_n))
          * where x_i < y_i forall i and 1 <= n < 20
          */
        for {
          n <- Gen.choose(1,20)
          pairs : List[(Double, Double)] <- Gen.containerOfN[List, (Double, Double)](n, GenPair)
        } yield ((pairs.unzip._1, pairs.unzip._2))
      }
  
    property("1 == 1") = forAll {
      (b1: FooIntervals)
      =>
      1 == 1
    }
  
    property("_1.head < _2.head") = forAll {
      (b1: FooIntervals)
      =>
      b1._1.head < b1._2.head
    }
  }
  

  ---

  [info] ! FooIntervals.1 == 1: Gave up after only 32 passed tests. 501 tests were discarded.
  [info] ! FooIntervals._1.head < _2.head: Gave up after only 28 passed tests. 501 tests were discarded.
  [info] ScalaTest
  [info] Run completed in 1 second, 519 milliseconds.
  [info] Total number of tests run: 0
  [info] Suites: completed 0, aborted 0
  [info] Tests: succeeded 0, failed 0, canceled 0, ignored 0, pending 0
  [info] No tests were executed.
  [error] Failed: Total 1, Failed 1, Errors 0, Passed 0
  [error] Failed tests:
  [error]     com.foo.bar.FooSpecification
  
• What is generative testing in Clojure?

  I came across Generative Testing in Clojure with spec notion and would like to learn about it.

  Also providing some examples would be very useful.