; def MyException:
; def message() = "".
(def MyException {
:message (fn [return, error] #(return ""))
})
; def consolePuts(def out, text) =
; __Clojure__ (.println out text) ->
; __Clojure__ (.checkError out) -> x
; if (x)
; throw(new MyException:
; def ^message() = "Unknown I/O error".
; )
; else
; return()
(defn console-puts [out, text, return, error]
(let
[_ (.println out text)
x (.checkError out)]
(if x
(error
(assoc MyException :message
(fn [return, error] #(return "Unknown I/O error")))))
return))
; def strictlyAscending = fun (def numbers) => yes(), no():
; __Clojure__ (apply < numbers) -> x
; if (x)
; yes()
; else
; no()
; .
(defn strictly-ascending [numbers, yes, no]
(let [x (apply < numbers)]
(if x
yes
no)))
; def loop(def n, out) =
; strictlyAscending([n, 7]) ->
; (consolePuts(out, "Hello World!") ->
; $loop(++n, out)
; | e
; e.message -> msg
; __Clojure__ (println msg) ->
; return() #implicit re-throw
; )
; |
; return()
(defn fn_loop [n, out, return, error]
(strictly-ascending [n, 7]
(fn []
(console-puts out "Hello World!"
#(fn_loop (+ 1 n) out return error)
(fn [e]
((:message e)
(fn [msg]
(println msg) ;log error
return)
error))))
return))
; def Start:
; struct instance
; make start() =
; loop(0, __Clojure__ System/out) ->
; return(struct)
; .
(def Start {
:instance nil
:new (fn [self, return, error] (fn_loop 0 System/out #(return {}) error))
})
; Start() -> newInstance
; new Start(instance: newInstance) -> Start
; 0
; | e
; (e.message -> msg
; __Clojure__ (throw (new RuntimeException msg))
; | #ignore argument
; __Clojure__ (throw (new IllegalStateException "Error getting exception message!"));;
; )
(trampoline
((:new Start)
Start
(fn [newInstance] (assoc Start :instance newInstance) 0)
(fn [e]
((:message e)
(fn [msg] (throw (new RuntimeException msg)))
(fn [_] (throw (new IllegalStateException "Error getting exception message!")))))))