요즘 내가 core.async를 익히고 있는 중이라 go lang 스타일 멀티코어용으로 싸줌 (사실 멀티코어 해도 별볼일 없는 문제지만 ㅎㅎ)


보면 알겠지만 입력은 귀찮아서 되는지 안해보고 걍 가라로 넣어주게 함. 5초 동안 입력만 처리하고는 끗


#_

(defn user-input []

  (println "User input:")

  (flush)

  (let [reader (ConsoleReader.)]

    (loop [ch (.readCharacter reader)]

      (println "*** " ch)

      (when-not (= ch 10) ;; newline

        (recur (.readCharacter reader))))))

#_

(defn user-input [channel]

  (go-loop [ch (.read System/in)]

    (>! channel ch)

    (recur (.read System/in))))


(defn user-input [channel]

  (go-loop [[ch & more-ch] (seq "dafvn kjhv89df77234u4mbdfjhGYTDCG;rkgfv")]

    (when ch 

      (>! channel (int ch))

      (recur more-ch))))


(defn val->channel-key [val]

  (cond (<= (int \0) val (int \9)) :int-ch

        (<= (int \a) val (int \z)) :low-alpha-ch

        (<= (int \A) val (int \Z)) :up-alpha-ch

        :else :else-ch))


(defn distributor [in-ch channel-map]

  (go-loop []

    (let [val (<! in-ch)]

      (-> (val->channel-key val)

          channel-map

          (>! val)))

    (recur)))


(defn process-int [int-ch out-ch]

  (go-loop []

    (>! out-ch

        (-> (<! int-ch)

            (- (int \0))

            (+ 5)))

    (recur)))


(defn process-low-alpha [low-alpha-ch out-ch]

  (go-loop []

    (>! out-ch

        (-> (<! low-alpha-ch)

            char

            clojure.string/upper-case))

    (recur)))


(defn process-up-alpha [up-alpha-ch out-ch]

  (go-loop []

    (>! out-ch

        (-> (<! up-alpha-ch)

            char

            clojure.string/lower-case))

    (recur)))


(defn process-else [else-ch out-ch]

  (go-loop []

    (->> (<! else-ch)

         char

         (>! out-ch))

    (recur)))


(defn -main []

  (let [in-ch (chan 1)

        int-ch (chan 1)

        low-alpha-ch (chan 1)

        up-alpha-ch (chan 1)

        else-ch (chan 1)

        out-ch (chan 1)]

    (distributor in-ch {:int-ch int-ch :low-alpha-ch low-alpha-ch

                        :up-alpha-ch up-alpha-ch :else-ch else-ch})

    (process-int int-ch out-ch)

    (process-low-alpha low-alpha-ch out-ch)

    (process-up-alpha up-alpha-ch out-ch)

    (process-else else-ch out-ch)

    (user-input in-ch)

    (go-loop [t (timeout 5000)]

      (let [[val chan] (alts! [t out-ch])]

        (if (= chan t)

          (flush)

          (do (print val)

              (recur t)))))))