try.clje

(ns examples.try)

(def prn (fn* [x] (io/format "~s~n" #erl((clj_rt/str x)))))
(def assert (fn* [result] (if result nil (erlang/error :failed-assertion))))

(try (prn 1))

(try (erlang/+ 1 :a)
     (catch :error error
       (prn [:error error])))

(try (throw :hello)
     (catch :throw error
       (throw #erl[:not-catched error]))
     (catch :exit error
       (throw #erl[:not-catched error]))
     (catch :error error
       (prn [:throw error])))

(try (throw :hello-before-finally)
     (catch :throw error
       (throw #erl[:not-catched error]))
     (catch :exit error
       (throw #erl[:not-catched error]))
     (catch :error error
       (prn [:throw error]))
     (finally
       (prn :finally)))

;; Accept any error type with _

(try
  (throw :throw)
  (catch _ e
    (prn e)))

(try
  (erlang/throw :error)
  (catch _ e
    (prn e)))

(try
  (erlang/exit :exit)
  (catch _ e
    (prn e)))

;; Use binding for error type

(try
  (erlang/exit :foo)
  (catch t e
    (prn [t e])))

;; Use type name for error type

(try
  (erlang/exit :foo)
  (catch clojerl.ExceptionInfo e
    (throw :bad-stuff))
  (catch :exit e
    (prn e)))

(try
  (throw (clojerl.ExceptionInfo. "hello" {:some :info}))
  (catch clojerl.ExceptionInfo e
    (prn e))
  (catch :error e
    (throw :bad-stuff)))

;; Provide stacktrace

(try
  (throw (clojerl.ExceptionInfo. "hello" {:some :info}) #erl())
  (catch clojerl.ExceptionInfo e :stack st
    (assert (erlang/== #erl() st))
    (prn e))
  (catch :error e
    (throw :bad-stuff)))

;; [#684] Pattern matching a local

(let* [x 1
       y (try
           (throw 1)
           (catch _ x :one)
           (catch _ _ :not-one))]
  (if (erlang/=:= y :one)
    nil
    (throw :error)))