sample.clj

(def A1
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "A1"]]
    [:value float?]
    ]))

(def B1
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "B1"]]
    [:value float?]
    ]))

(def C1
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "C1"]]
    [:value float?]
    ]))

(def D1
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "D1"]]
    [:value float?]
    ]))

(def E1
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "E1"]]
    [:value float?]
    ]))

(def M1
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A1" A1]
    ["B1" B1]
    ["C1" C1]
    ["D1" D1]
    ]))

(def M2
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A1" A1]
    ["B1" B1]
    ["C1" C1]
    ["E1" E1]
    ]))

(def M3
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A1" A1]
    ["B1" B1]
    ["D1" D1]
    ["E1" E1]
    ]))

(def M4
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A1" A1]
    ["C1" C1]
    ["D1" D1]
    ["E1" E1]
    ]))

(def M5
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["B1" B1]
    ["C1" C1]
    ["D1" D1]
    ["E1" E1]
    ]))

(def A2
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "A2"]]
    [:value double?]
    [:m2 M2]
    [:m3 M3]
    [:m4 M4]
    [:m5 M5]
    ]))

(def B2
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "B2"]]
    [:value double?]
    [:m1 M1]
    [:m3 M3]
    [:m4 M4]
    [:m5 M5]
    ]))

(def C2
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "C2"]]
    [:value double?]
    [:m1 M1]
    [:m2 M2]
    [:m4 M4]
    [:m5 M5]
    ]))

(def D2
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "D2"]]
    [:value double?]
    [:m1 M1]
    [:m2 M2]
    [:m3 M3]
    [:m5 M5]
    ]))

(def E2
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "E2"]]
    [:value double?]
    [:m1 M1]
    [:m2 M2]
    [:m3 M3]
    [:m4 M4]
    ]))

(def MM1
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["B2" B2]
    ["C2" C2]
    ["D2" D2]
    ["E2" E2]
    ]))

(def MM2
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A2" A2]
    ["C2" C2]
    ["D2" D2]
    ["E2" E2]
    ]))

(def MM3
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A2" A2]
    ["B2" B2]
    ["D2" D2]
    ["E2" E2]
    ]))

(def MM4
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A2" A2]
    ["B2" B2]
    ["C2" C2]
    ["E2" E2]
    ]))

(def MM5
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A2" A2]
    ["B2" B2]
    ["C2" C2]
    ["D2" D2]
    ]))

(def A3
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "A3"]]
    [:value double?]
    [:mm2 MM2]
    [:mm3 MM3]
    [:mm4 MM4]
    [:mm5 MM5]
    ]))

(def B3
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "B3"]]
    [:value double?]
    [:mm1 MM1]
    [:mm3 MM3]
    [:mm4 MM4]
    [:mm5 MM5]
    ]))

(def C3
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "C3"]]
    [:value double?]
    [:mm1 MM1]
    [:mm2 MM2]
    [:mm4 MM4]
    [:mm5 MM5]
    ]))

(def D3
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "D3"]]
    [:value double?]
    [:mm1 MM1]
    [:mm2 MM2]
    [:mm3 MM3]
    [:mm5 MM5]
    ]))

(def E3
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "E3"]]
    [:value double?]
    [:mm1 MM1]
    [:mm2 MM2]
    [:mm3 MM3]
    [:mm4 MM4]
    ]))

(def MMM1
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A3" A3]
    ["B3" B3]
    ["C3" C3]
    ["D3" D3]
    ["E3" E3]
    ]))

(def MMM2
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A3" A3]
    ["B3" B3]
    ["C3" C3]
    ["D3" D3]
    ["E3" E3]
    ]))

(def MMM3
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A3" A3]
    ["B3" B3]
    ["C3" C3]
    ["D3" D3]
    ["E3" E3]
    ]))

(def MMM4
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A3" A3]
    ["B3" B3]
    ["C3" C3]
    ["D3" D3]
    ["E3" E3]
    ]))

(def MMM5
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A3" A3]
    ["B3" B3]
    ["C3" C3]
    ["D3" D3]
    ["E3" E3]
    ]))

(def A4
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "A4"]]
    [:value double?]
    [:mmm1 MMM1]
    [:mmm2 MMM2]
    [:mmm3 MMM3]
    [:mmm4 MMM4]
    [:mmm5 MMM5]
    ]))

(def B4
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "B4"]]
    [:value double?]
    [:mmm1 MMM1]
    [:mmm2 MMM2]
    [:mmm3 MMM3]
    [:mmm4 MMM4]
    [:mmm5 MMM5]
    ]))

(def C4
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "C4"]]
    [:value double?]
    [:mmm1 MMM1]
    [:mmm2 MMM2]
    [:mmm3 MMM3]
    [:mmm4 MMM4]
    [:mmm5 MMM5]
    ]))

(def D4
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "D4"]]
    [:value double?]
    [:mmm1 MMM1]
    [:mmm2 MMM2]
    [:mmm3 MMM3]
    [:mmm4 MMM4]
    [:mmm5 MMM5]
    ]))

(def E4
  (m/schema
   [:map
    {:encode/test {:leave encode} :decode/test decode}
    [:type [:= "E4"]]
    [:value double?]
    [:mmm1 MMM1]
    [:mmm2 MMM2]
    [:mmm3 MMM3]
    [:mmm4 MMM4]
    [:mmm5 MMM5]
    ]))

(def MMMM
  (m/schema
   [:multi
    {:dispatch (dispatcher :type)
     :decode/test {:enter #(name (:type %))}}
    ["A4" A4]
    ["B4" B4]
    ["C4" C4]
    ["D4" D4]
    ["E4" E4]
    ]))