thegeez/spec_parsing.clj

## spec_parsing.clj
(ns net.thegeez.advent.spec-parsing
  (:require [clojure.string :as str]
            [clojure.spec :as s]
            [clojure.spec.gen :as gen]
            [clojure.test.check.generators :as tgen]))
;; Dependencies:
;; [org.clojure/clojure "1.9.0-alpha14"]
;; [org.clojure/test.check "0.9.0"]

;; Advent of Code is a series of code challenges in the form of an advent
;; calender, counting down to Christmas. The challenges are given as a
;; list of inputs and the solution needs to be entered in a text box on
;; the website. So you can use any programming language you like!

(def fun "http://adventofcode.com/")

;; Clojure 1.9 includes clojure.spec which can do parsing with regular
;; expressions. This can be used to parse the input for the challenges
;; for Advent of Code!

;; The challenge for day 7 is to find valid ip addresses that are
;; defined by some property that make them proper ip addresses for the
;; Easter Bunny headquarters.

(def example-ips
   "abba[mnop]qrst
abcd[bddb]xyyx
aaaa[qwer]tyui
ioxxoj[asdfgh]zxcvbn
ioxxoj[asdfgh]zxcvbnioxxoj[asdfgh]zxcvbn
")
;;
;; The first 4 lines contain example ips, the last one is more like the
;; ones found in the actual input for the challenge. The challenge is
;; to find only the ips that have some property for the characters
;; outside the square brackets and the characters within the quare
;; brackets. So to solve this challenge it would be usefull to turn a
;; string like "abba[mnop]qrst" into
;; {:outers [[\a \b \b \a] [\q \r \s \t]] :inners [[\m \n \o \p]]}.
;; Clojure.spec can help with that.

;; Remember that strings is Clojure are also sequences of characters:
(= (seq "abcd") [\a \b \c \d]) ;;=> true

;; Some helpers:
(def alphabet "abcdefghijklmnopqrstuvwxyz")
(def letter (set alphabet))

;; Parsing a string with clojure.spec:
(s/conform (s/* letter) "abcd")
;;=>  :clojure.spec/invalid, because the regex spec works on sequences
(s/conform (s/* letter) (seq "abcd")) ;;=> [\a \b \c \d]
;; Or
(s/conform (s/and string?
                  (s/conformer seq)
                  (s/* letter))
           "abcd") ;;=> [\a \b \c \d]
;; Note that because string? has been matched already, the conformer
;; `seq` will never fail here, so the conformer can never return
;; :clojure.spec/invalid

;; Lets first parse the input into an ip per line
(s/def ::ips (s/and string?
                    (s/conformer seq)
                    (s/+ (s/cat
                          :ip (s/+ (into letter "[]"))
                          :newline #{\newline}))))

(s/conform ::ips example-ips)
;;=>
;; [{:ip [\a \b \b \a \[ \m \n \o \p \] \q \r \s \t], :newline \newline}
;;  {:ip [\a \b \c \d \[ \b \d \d \b \] \x \y \y \x], :newline \newline}
;; .. etc ..]

;; Lets specify the definition of an ip a bit further
(s/def ::ips (s/and string?
                    (s/conformer seq)
                    (s/+ (s/cat
                          :ip ::ip
                          :newline #{\newline}))))

(s/def ::ip (s/cat :outer-first (s/+ letter)
                   :inner (s/cat
                           :openbracket #{\[}
                           :inner (s/+ letter)
                           :closebracket #{\]})
                   :outer-last (s/+ letter)))
(s/conform ::ips example-ips) ;;=> :clojure.spec/invalid
(s/explain-data ::ips example-ips)
;; => #:clojure.spec{:problems [{:path [:newline], :pred #{\newline}, :val \[, :via [:net.thegeez.advent.spec-parsing/ips], :in [92]}]}

(subs example-ips 92) ;;=> "[asdfgh]zxcvbn\n"
;; This shows that the ::ip spec works for the simple examples,
;; but fails to parse the second inner part from the last example,
;; which is more like the real input for the challenge

;; One attempt can be to look for a repeating pattern of outer
;; parts such as "abcd" followed by an inner part "[xyz]" where
;; the inner part is optional, because there is now inner part at
;; the end of an ip.
(s/def ::ip (s/* (s/cat :outer (s/+ letter)
                        :inner (s/?
                                (s/cat
                                 :openbracket #{\[}
                                 :inner (s/+ letter)
                                 :closebracket #{\]})))))

;; (s/conform ::ips example-ips) ;; WARNING! running this will
;; be very very very slow!

;; This is not a good idea, because we run into a common
;; regular expression problem. Because the inner part is
;; defined as optional, there are many ways to parse an ip now.
;; We are looking for the first part to be parsed as
;; [{:outer [\a \b \c \d] :inner ..etc..}]. Because the inner
;; part is optional, it can also be parsed as
;; [{:outer [\a]} {:outer [\b]} .. etc ..]. The regular
;; expression can use some help with the parsing.

(s/def ::ip (s/cat :beginning
                   (s/* (s/cat :outer (s/+ letter)
                               :inner (s/cat
                                       :openbracket #{\[}
                                       :inner (s/+ letter)
                                       :closebracket #{\]})))
                   :end (s/+ letter)))

(s/conform ::ips example-ips)q
;; => [{:ip {:beginning [{:outer [\a \b \b \a], :inner {:openbracket \[, :inner [\m \n \o \p], :closebracket \]}}], :end [\q \r \s \t]}, :newline \newline}
;;      ... etc ...
;;     {:ip {:beginning [{:outer [\i \o \x \x \o \j], :inner {:openbracket \[, :inner [\a \s \d \f \g \h], :closebracket \]}} {:outer [\z \x \c \v \b \n \i \o \x \x \o \j], :inner {:openbracket \[, :inner [\a \s \d \f \g \h], :closebracket \]}}], :end [\z \x \c \v \b \n]}, :newline \newline}]

;; By rewriting the regular expression without using the
;; optional predicate (s/? ..) the ips can be parsed again.

;; Sadly, now the structure of the conformed values is a bit
;; nested, while we only care about the :outer and :inner parts
;; of and ip. With a custom conformer this can be transformed
;; into a shape that is easier to use
(s/def ::ip
  (s/& (s/cat :beginning
              (s/* (s/cat :outer (s/+ letter)
                          :inner (s/cat
                                  :openbracket #{\[}
                                  :inner (s/+ letter)
                                  :closebracket #{\]})))
              :end (s/+ letter))
       (s/conformer
        (fn [parsed]
          {:inners (mapv (comp :inner :inner) (:beginning parsed))
           :outers (-> []
                       (into (map :outer (:beginning parsed)))
                       (conj (:end parsed)))}))))

(s/conform ::ips example-ips)
;; => [{:ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]}, :newline \newline}
;;     {:ip {:inners [[\b \d \d \b]], :outers [[\a \b \c \d] [\x \y \y \x]]}, :newline \newline}
;;     {:ip {:inners [[\q \w \e \r]], :outers [[\a \a \a \a] [\t \y \u \i]]}, :newline \newline}
;;     {:ip {:inners [[\a \s \d \f \g \h]], :outers [[\i \o \x \x \o \j] [\z \x \c \v \b \n]]}, :newline \newline}
;;     {:ip {:inners [[\a \s \d \f \g \h] [\a \s \d \f \g \h]], :outers [[\i \o \x \x \o \j] [\z \x \c \v \b \n \i \o \x \x \o \j] [\z \x \c \v \b \n]]}, :newline \newline}]

;; And now the input is in a nice shape to solve the
;; actual challenge with.

;; Clojure specs can work both ways. From a conformed
;; parsing result you can go back to the original input:
(s/unform ::ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]})
;; => Throws Exception: IllegalStateException no unform fn for conformer  clojure.spec/spec-impl/reify--13832 (spec.clj:870)

;; But that does require that every step is defined to both
;; conform and unform. In the ::ip example there is a
;; conformer, but not an unformer that works the other way.
;; Lets add that one:
(s/def ::ip
  (s/& (s/cat :beginning
              (s/* (s/cat :outer (s/+ letter)
                          :inner (s/cat
                                  :openbracket #{\[}
                                  :inner (s/+ letter)
                                  :closebracket #{\]})))
              :end (s/+ letter))
       (s/conformer
        (fn [parsed]
          {:inners (mapv
                    (comp :inner :inner) (:beginning parsed))
           :outers (-> []
                       (into (map :outer (:beginning parsed)))
                       (conj (:end parsed)))})
        (fn [out]
          {:beginning (for [[outer inner] (->> (interleave (butlast (:outers out)) (:inners out))
                                               (partition 2))]
                        {:outer outer
                         :inner {:openbracket \[
                                 :inner inner
                                 :closebracket \]}})
           :end (last (:outers out))}))))

(s/unform ::ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]})
;; => (\a \b \b \a \[ \m \n \o \p \] \q \r \s \t)

;; And adding an unformer to the ::ips spec:
(s/def ::ips (s/and string?
                    (s/conformer seq  #(apply str %))
                    (s/+ (s/cat
                          :ip ::ip
                          :newline #{\newline}))))
(s/unform ::ips [{:ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]}}]) ;; => "abba[mnop]qrst"

(= (s/unform ::ips (s/conform ::ips example-ips)) example-ips) ;; => true!

;; With specs you can also generate data:
(gen/generate (s/gen ::ip)) ;;=> (\h \r \e \h  \[ \v \r \x \g \x \] \k \q \v \y \o \i \y \g \i \s \n \j ... a probably very long generated sample ...)

;; You can also generate your own input for the Advent
;; of Code challenge:
(gen/generate (s/gen ::ips)) ;; => Exception "Couldn't satisfy such-that predicate after 100 tries."

;; What is happening here is that (s/gen ::ips) will
;; generate random strings and not strings that conform
;; to our ::ip spec, because (s/and ...) will use the
;; first spec as its generator, our conformer and :ip and
;; :newline definition are not used. This can be fixed:

(s/def ::many-ips (s/+ (s/cat
                        :ip ::ip
                        :newline #{\newline})))
(s/def ::ips (s/with-gen
               (s/and string?
                      (s/conformer seq  #(apply str %))
                      ::many-ips)
               (fn []
                 (gen/fmap
                  (fn [char-seq]
                    (apply str char-seq))
                  (s/gen ::many-ips)))))

;; now this works:
(gen/generate (s/gen ::ips)) ;;=> "btpmlpdo[nhchrwg]anbqb[qrnb]ico\njwgrxdb[vbo]grqy.... a very long string of long ips .... "


;; The challenge for day 8 in the Advent of Code is to
;; use some instruction for a LED screen to find a
;; password. Again the input is a string with on each
;; line some useful input:
(def example-instructions
  "rect 31x24
rotate column x=11 by 1
rotate row y=23 by 30
rotate column x=1 by 1
")

;; To use these actions it would be helpful to have
;; them in the shape of [[:rect {:wide 31 :tall 24}] ...etc...]

;; Some helpers again:
(def numbers "0123456789")
(def number (set numbers))
(def alphabet "abcdefghijklmnopqrstuvwxyz")
(def letter (set alphabet))

(s/def ::action (s/alt :rect (s/cat :char-r #{\r}
                                    :char-e #{\e}
                                    :char-c #{\c}
                                    :char-t #{\t}
                                    :space #{\space}
                                    :wide (s/+ number)
                                    :char-x #{\x}
                                    :tall (s/+ number))))
(s/conform ::action (seq "rect 31x24"))
;;=> [:rect {:char-r \r, :char-e \e, :char-c \c, :char-t \t, :space \space, :wide [\3 \1], :char-x \x, :tall [\2 \4]}]

;; Two things are not so nice about this. It is a
;; bit tedious to spell out all the characters of
;; the "rect " string and it would be nice if the
;; numbers for :wide and :tall were actual numbers.
;; To make :wide and :tall a number:

(s/def ::number (s/with-gen
                  (s/& (s/+ number)
                       (s/conformer
                        (fn [parsed]
                          (Long/parseLong (apply str parsed)))
                        (fn [out]
                          (seq (str out)))))
                  (fn []
                    (gen/fmap
                     (fn [l]
                       (seq (str l)))
                     tgen/pos-int))))
(s/def ::action (s/alt :rect (s/cat :char-r #{\r}
                                    :char-e #{\e}
                                    :char-c #{\c}
                                    :char-t #{\t}
                                    :space #{\space}
                                    :wide ::number
                                    :char-x #{\x}
                                    :tall ::number)))

(s/conform ::action (seq "rect 31x24"))
;;=> [:rect {:char-r \r, :char-e \e, :char-c \c, :char-t \t, :space \space, :wide 31, :char-x \x, :tall 24}]
(let [in (seq "rect 31x24")]
  (= (s/unform ::action (s/conform ::action in)) in)) ;;=> true!

;; The tedious specification of string matching
;; can be solved with a helper:
(defmacro match-seq [c]
  (let [ks (mapv keyword (repeatedly (count c) gensym))
        cat-kvs (mapcat vector ks (map hash-set c))]
    `(s/with-gen
       (s/&
        (s/cat ~@cat-kvs)
        (s/conformer
         (juxt ~@ks)
         (fn [out#]
           (zipmap ~ks out#))))
       (fn []
         (s/gen #{~c})))))

(s/def ::action (s/alt :rect (s/cat :text (match-seq "rect ")
                                    :wide ::number
                                    :x #{\x}
                                    :tall ::number)
                       :column (s/cat :text (match-seq "rotate column x=")
                                      :index ::number
                                      :by (match-seq " by ")
                                      :shift ::number)
                       :row (s/cat :text (match-seq "rotate row y=")
                                   :index ::number
                                   :by (match-seq " by ")
                                   :shift ::number)))
(s/def ::action-many (s/* (s/cat
                           :action ::action
                           :newline #{\newline})))
(s/def ::instructions (s/with-gen
                        (s/and string?
                               (s/conformer seq)
                               ::action-many)
                        (fn []
                          (gen/fmap
                           (fn [char-seq]
                             (apply str char-seq))
                           (s/gen ::action-many)))))

(s/conform ::instructions example-instructions)
;;=> [{:action [:rect {:text [\r \e \c \t \space], :wide 31, :x \x, :tall 24}], :newline \newline}
;;    {:action [:column {:text [\r \o \t \a \t \e \space \c \o \l \u \m \n \space \x \=], :index 11, :by [\space \b \y \space], :shift 1}], :newline \newline}
;;    {:action [:row {:text [\r \o \t \a \t \e \space \r \o \w \space \y \=], :index 23, :by [\space \b \y \space], :shift 30}], :newline \newline}
;;    {:action [:column {:text [\r \o \t \a \t \e \space \c \o \l \u \m \n \space \x \=], :index 1, :by [\space \b \y \space], :shift 1}], :newline \newline}]

;; And again you can also generate some
;; instructions from the specs:
(gen/generate (s/gen ::instructions))
;;=> "rect 10x23\nrotate column x=11 by 8\nrotate column x=16 by 7\nrect 28x10\nrotate row y=8 by 20\nrotate column x=8 by 21\nrotate column x=19 by 27\nrect 4x0\nrotate column x=18 by 18\nrotate row y=27 by 13\nrect 10x21\nrotate column x=0 by 17\nrect 5x3\nrotate row y=13 by 14\nrotate row y=17 by 29\nrotate row y=5 by 17\nrect 25x18\nrect 20x4\nrotate column x=8 by 25\nrect 1x28\nrotate column x=3 by 4\nrect 1x24\nrect 28x3\n"
	(ns net.thegeez.advent.spec-parsing
	(:require [clojure.string :as str]
	[clojure.spec :as s]
	[clojure.spec.gen :as gen]
	[clojure.test.check.generators :as tgen]))
	;; Dependencies:
	;; [org.clojure/clojure "1.9.0-alpha14"]
	;; [org.clojure/test.check "0.9.0"]

	;; Advent of Code is a series of code challenges in the form of an advent
	;; calender, counting down to Christmas. The challenges are given as a
	;; list of inputs and the solution needs to be entered in a text box on
	;; the website. So you can use any programming language you like!

	(def fun "http://adventofcode.com/")

	;; Clojure 1.9 includes clojure.spec which can do parsing with regular
	;; expressions. This can be used to parse the input for the challenges
	;; for Advent of Code!

	;; The challenge for day 7 is to find valid ip addresses that are
	;; defined by some property that make them proper ip addresses for the
	;; Easter Bunny headquarters.

	(def example-ips
	"abba[mnop]qrst
	abcd[bddb]xyyx
	aaaa[qwer]tyui
	ioxxoj[asdfgh]zxcvbn
	ioxxoj[asdfgh]zxcvbnioxxoj[asdfgh]zxcvbn
	")
	;;
	;; The first 4 lines contain example ips, the last one is more like the
	;; ones found in the actual input for the challenge. The challenge is
	;; to find only the ips that have some property for the characters
	;; outside the square brackets and the characters within the quare
	;; brackets. So to solve this challenge it would be usefull to turn a
	;; string like "abba[mnop]qrst" into
	;; {:outers [[\a \b \b \a] [\q \r \s \t]] :inners [[\m \n \o \p]]}.
	;; Clojure.spec can help with that.

	;; Remember that strings is Clojure are also sequences of characters:
	(= (seq "abcd") [\a \b \c \d]) ;;=> true

	;; Some helpers:
	(def alphabet "abcdefghijklmnopqrstuvwxyz")
	(def letter (set alphabet))

	;; Parsing a string with clojure.spec:
	(s/conform (s/* letter) "abcd")
	;;=> :clojure.spec/invalid, because the regex spec works on sequences
	(s/conform (s/* letter) (seq "abcd")) ;;=> [\a \b \c \d]
	;; Or
	(s/conform (s/and string?
	(s/conformer seq)
	(s/* letter))
	"abcd") ;;=> [\a \b \c \d]
	;; Note that because string? has been matched already, the conformer
	;; `seq` will never fail here, so the conformer can never return
	;; :clojure.spec/invalid

	;; Lets first parse the input into an ip per line
	(s/def ::ips (s/and string?
	(s/conformer seq)
	(s/+ (s/cat
	:ip (s/+ (into letter "[]"))
	:newline #{\newline}))))

	(s/conform ::ips example-ips)
	;;=>
	;; [{:ip [\a \b \b \a \[ \m \n \o \p \] \q \r \s \t], :newline \newline}
	;; {:ip [\a \b \c \d \[ \b \d \d \b \] \x \y \y \x], :newline \newline}
	;; .. etc ..]

	;; Lets specify the definition of an ip a bit further
	(s/def ::ips (s/and string?
	(s/conformer seq)
	(s/+ (s/cat
	:ip ::ip
	:newline #{\newline}))))

	(s/def ::ip (s/cat :outer-first (s/+ letter)
	:inner (s/cat
	:openbracket #{\[}
	:inner (s/+ letter)
	:closebracket #{\]})
	:outer-last (s/+ letter)))
	(s/conform ::ips example-ips) ;;=> :clojure.spec/invalid
	(s/explain-data ::ips example-ips)
	;; => #:clojure.spec{:problems [{:path [:newline], :pred #{\newline}, :val \[, :via [:net.thegeez.advent.spec-parsing/ips], :in [92]}]}

	(subs example-ips 92) ;;=> "[asdfgh]zxcvbn\n"
	;; This shows that the ::ip spec works for the simple examples,
	;; but fails to parse the second inner part from the last example,
	;; which is more like the real input for the challenge

	;; One attempt can be to look for a repeating pattern of outer
	;; parts such as "abcd" followed by an inner part "[xyz]" where
	;; the inner part is optional, because there is now inner part at
	;; the end of an ip.
	(s/def ::ip (s/* (s/cat :outer (s/+ letter)
	:inner (s/?
	(s/cat
	:openbracket #{\[}
	:inner (s/+ letter)
	:closebracket #{\]})))))

	;; (s/conform ::ips example-ips) ;; WARNING! running this will
	;; be very very very slow!

	;; This is not a good idea, because we run into a common
	;; regular expression problem. Because the inner part is
	;; defined as optional, there are many ways to parse an ip now.
	;; We are looking for the first part to be parsed as
	;; [{:outer [\a \b \c \d] :inner ..etc..}]. Because the inner
	;; part is optional, it can also be parsed as
	;; [{:outer [\a]} {:outer [\b]} .. etc ..]. The regular
	;; expression can use some help with the parsing.

	(s/def ::ip (s/cat :beginning
	(s/* (s/cat :outer (s/+ letter)
	:inner (s/cat
	:openbracket #{\[}
	:inner (s/+ letter)
	:closebracket #{\]})))
	:end (s/+ letter)))

	(s/conform ::ips example-ips)q
	;; => [{:ip {:beginning [{:outer [\a \b \b \a], :inner {:openbracket \[, :inner [\m \n \o \p], :closebracket \]}}], :end [\q \r \s \t]}, :newline \newline}
	;; ... etc ...
	;; {:ip {:beginning [{:outer [\i \o \x \x \o \j], :inner {:openbracket \[, :inner [\a \s \d \f \g \h], :closebracket \]}} {:outer [\z \x \c \v \b \n \i \o \x \x \o \j], :inner {:openbracket \[, :inner [\a \s \d \f \g \h], :closebracket \]}}], :end [\z \x \c \v \b \n]}, :newline \newline}]

	;; By rewriting the regular expression without using the
	;; optional predicate (s/? ..) the ips can be parsed again.

	;; Sadly, now the structure of the conformed values is a bit
	;; nested, while we only care about the :outer and :inner parts
	;; of and ip. With a custom conformer this can be transformed
	;; into a shape that is easier to use
	(s/def ::ip
	(s/& (s/cat :beginning
	(s/* (s/cat :outer (s/+ letter)
	:inner (s/cat
	:openbracket #{\[}
	:inner (s/+ letter)
	:closebracket #{\]})))
	:end (s/+ letter))
	(s/conformer
	(fn [parsed]
	{:inners (mapv (comp :inner :inner) (:beginning parsed))
	:outers (-> []
	(into (map :outer (:beginning parsed)))
	(conj (:end parsed)))}))))

	(s/conform ::ips example-ips)
	;; => [{:ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]}, :newline \newline}
	;; {:ip {:inners [[\b \d \d \b]], :outers [[\a \b \c \d] [\x \y \y \x]]}, :newline \newline}
	;; {:ip {:inners [[\q \w \e \r]], :outers [[\a \a \a \a] [\t \y \u \i]]}, :newline \newline}
	;; {:ip {:inners [[\a \s \d \f \g \h]], :outers [[\i \o \x \x \o \j] [\z \x \c \v \b \n]]}, :newline \newline}
	;; {:ip {:inners [[\a \s \d \f \g \h] [\a \s \d \f \g \h]], :outers [[\i \o \x \x \o \j] [\z \x \c \v \b \n \i \o \x \x \o \j] [\z \x \c \v \b \n]]}, :newline \newline}]

	;; And now the input is in a nice shape to solve the
	;; actual challenge with.

	;; Clojure specs can work both ways. From a conformed
	;; parsing result you can go back to the original input:
	(s/unform ::ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]})
	;; => Throws Exception: IllegalStateException no unform fn for conformer clojure.spec/spec-impl/reify--13832 (spec.clj:870)

	;; But that does require that every step is defined to both
	;; conform and unform. In the ::ip example there is a
	;; conformer, but not an unformer that works the other way.
	;; Lets add that one:
	(s/def ::ip
	(s/& (s/cat :beginning
	(s/* (s/cat :outer (s/+ letter)
	:inner (s/cat
	:openbracket #{\[}
	:inner (s/+ letter)
	:closebracket #{\]})))
	:end (s/+ letter))
	(s/conformer
	(fn [parsed]
	{:inners (mapv
	(comp :inner :inner) (:beginning parsed))
	:outers (-> []
	(into (map :outer (:beginning parsed)))
	(conj (:end parsed)))})
	(fn [out]
	{:beginning (for [[outer inner] (->> (interleave (butlast (:outers out)) (:inners out))
	(partition 2))]
	{:outer outer
	:inner {:openbracket \[
	:inner inner
	:closebracket \]}})
	:end (last (:outers out))}))))

	(s/unform ::ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]})
	;; => (\a \b \b \a \[ \m \n \o \p \] \q \r \s \t)

	;; And adding an unformer to the ::ips spec:
	(s/def ::ips (s/and string?
	(s/conformer seq #(apply str %))
	(s/+ (s/cat
	:ip ::ip
	:newline #{\newline}))))
	(s/unform ::ips [{:ip {:inners [[\m \n \o \p]], :outers [[\a \b \b \a] [\q \r \s \t]]}}]) ;; => "abba[mnop]qrst"

	(= (s/unform ::ips (s/conform ::ips example-ips)) example-ips) ;; => true!

	;; With specs you can also generate data:
	(gen/generate (s/gen ::ip)) ;;=> (\h \r \e \h \[ \v \r \x \g \x \] \k \q \v \y \o \i \y \g \i \s \n \j ... a probably very long generated sample ...)

	;; You can also generate your own input for the Advent
	;; of Code challenge:
	(gen/generate (s/gen ::ips)) ;; => Exception "Couldn't satisfy such-that predicate after 100 tries."

	;; What is happening here is that (s/gen ::ips) will
	;; generate random strings and not strings that conform
	;; to our ::ip spec, because (s/and ...) will use the
	;; first spec as its generator, our conformer and :ip and
	;; :newline definition are not used. This can be fixed:

	(s/def ::many-ips (s/+ (s/cat
	:ip ::ip
	:newline #{\newline})))
	(s/def ::ips (s/with-gen
	(s/and string?
	(s/conformer seq #(apply str %))
	::many-ips)
	(fn []
	(gen/fmap
	(fn [char-seq]
	(apply str char-seq))
	(s/gen ::many-ips)))))

	;; now this works:
	(gen/generate (s/gen ::ips)) ;;=> "btpmlpdo[nhchrwg]anbqb[qrnb]ico\njwgrxdb[vbo]grqy.... a very long string of long ips .... "



	;; The challenge for day 8 in the Advent of Code is to
	;; use some instruction for a LED screen to find a
	;; password. Again the input is a string with on each
	;; line some useful input:
	(def example-instructions
	"rect 31x24
	rotate column x=11 by 1
	rotate row y=23 by 30
	rotate column x=1 by 1
	")

	;; To use these actions it would be helpful to have
	;; them in the shape of [[:rect {:wide 31 :tall 24}] ...etc...]

	;; Some helpers again:
	(def numbers "0123456789")
	(def number (set numbers))
	(def alphabet "abcdefghijklmnopqrstuvwxyz")
	(def letter (set alphabet))

	(s/def ::action (s/alt :rect (s/cat :char-r #{\r}
	:char-e #{\e}
	:char-c #{\c}
	:char-t #{\t}
	:space #{\space}
	:wide (s/+ number)
	:char-x #{\x}
	:tall (s/+ number))))
	(s/conform ::action (seq "rect 31x24"))
	;;=> [:rect {:char-r \r, :char-e \e, :char-c \c, :char-t \t, :space \space, :wide [\3 \1], :char-x \x, :tall [\2 \4]}]

	;; Two things are not so nice about this. It is a
	;; bit tedious to spell out all the characters of
	;; the "rect " string and it would be nice if the
	;; numbers for :wide and :tall were actual numbers.
	;; To make :wide and :tall a number:

	(s/def ::number (s/with-gen
	(s/& (s/+ number)
	(s/conformer
	(fn [parsed]
	(Long/parseLong (apply str parsed)))
	(fn [out]
	(seq (str out)))))
	(fn []
	(gen/fmap
	(fn [l]
	(seq (str l)))
	tgen/pos-int))))
	(s/def ::action (s/alt :rect (s/cat :char-r #{\r}
	:char-e #{\e}
	:char-c #{\c}
	:char-t #{\t}
	:space #{\space}
	:wide ::number
	:char-x #{\x}
	:tall ::number)))

	(s/conform ::action (seq "rect 31x24"))
	;;=> [:rect {:char-r \r, :char-e \e, :char-c \c, :char-t \t, :space \space, :wide 31, :char-x \x, :tall 24}]
	(let [in (seq "rect 31x24")]
	(= (s/unform ::action (s/conform ::action in)) in)) ;;=> true!

	;; The tedious specification of string matching
	;; can be solved with a helper:
	(defmacro match-seq [c]
	(let [ks (mapv keyword (repeatedly (count c) gensym))
	cat-kvs (mapcat vector ks (map hash-set c))]
	`(s/with-gen
	(s/&
	(s/cat ~@cat-kvs)
	(s/conformer
	(juxt ~@ks)
	(fn [out#]
	(zipmap ~ks out#))))
	(fn []
	(s/gen #{~c})))))

	(s/def ::action (s/alt :rect (s/cat :text (match-seq "rect ")
	:wide ::number
	:x #{\x}
	:tall ::number)
	:column (s/cat :text (match-seq "rotate column x=")
	:index ::number
	:by (match-seq " by ")
	:shift ::number)
	:row (s/cat :text (match-seq "rotate row y=")
	:index ::number
	:by (match-seq " by ")
	:shift ::number)))
	(s/def ::action-many (s/* (s/cat
	:action ::action
	:newline #{\newline})))
	(s/def ::instructions (s/with-gen
	(s/and string?
	(s/conformer seq)
	::action-many)
	(fn []
	(gen/fmap
	(fn [char-seq]
	(apply str char-seq))
	(s/gen ::action-many)))))

	(s/conform ::instructions example-instructions)
	;;=> [{:action [:rect {:text [\r \e \c \t \space], :wide 31, :x \x, :tall 24}], :newline \newline}
	;; {:action [:column {:text [\r \o \t \a \t \e \space \c \o \l \u \m \n \space \x \=], :index 11, :by [\space \b \y \space], :shift 1}], :newline \newline}
	;; {:action [:row {:text [\r \o \t \a \t \e \space \r \o \w \space \y \=], :index 23, :by [\space \b \y \space], :shift 30}], :newline \newline}
	;; {:action [:column {:text [\r \o \t \a \t \e \space \c \o \l \u \m \n \space \x \=], :index 1, :by [\space \b \y \space], :shift 1}], :newline \newline}]

	;; And again you can also generate some
	;; instructions from the specs:
	(gen/generate (s/gen ::instructions))
	;;=> "rect 10x23\nrotate column x=11 by 8\nrotate column x=16 by 7\nrect 28x10\nrotate row y=8 by 20\nrotate column x=8 by 21\nrotate column x=19 by 27\nrect 4x0\nrotate column x=18 by 18\nrotate row y=27 by 13\nrect 10x21\nrotate column x=0 by 17\nrect 5x3\nrotate row y=13 by 14\nrotate row y=17 by 29\nrotate row y=5 by 17\nrect 25x18\nrect 20x4\nrotate column x=8 by 25\nrect 1x28\nrotate column x=3 by 4\nrect 1x24\nrect 28x3\n"