JiSE: Java in S-Expression

JiSE is a Clojure DSL library that compiles a Java-like language into JVM bytecode at macroexpansion time.

Features

Using JiSE, you can:

• Write imperative code that is compiled to JVM bytecode as efficient as written in Java
  • You can use assignment, (nested) loops, (labeled) break/continue, etc.
• Define your own Java class in a cleaner way than using gen-class or proxy
• Combine JiSE code with Clojure in a function- or expression-level of granularity
• Find more errors at compile time due to its static typing
• Extend JiSE syntax with Clojure's ordinary macros
  • Existing Clojure macros can also be used seamlessly from JiSE, such as ->, .. and with-open

Installation

Add the following to your project :dependencies:

If you would rather use an unstable version of the library via Clojure CLI tool, add the following to your deps.edn instead:

{...
 :deps {...
        athos/jise {:git/url "https://github.com/athos/JiSE.git"
                    :sha "<commit sha>"}
        ...}
 ...}

Usage

(require '[jise.core :refer [defclass]])


^:public
(defclass Counter
  ^:private
  (def ^int c)
  ^:public
  (defm Counter [^int c]
    (set! (.-c this) c))
  ^:public ^int
  (defm inc []
    (inc! (.-c this))))

;; You can use the defined class (`Counter`) as an ordinary Java class
(def c (Counter. 10))
(.inc c) ;=> 11
(.inc c) ;=> 12
(.inc c) ;=> 13

;; Also, you can even write quite imperative code easily as follows:

^:public
(defclass Qsort
  ^:public ^:static
  (defm qsort [^{:tag [int]} xs]
    (qsort xs 0 (- (alength xs) 1)))

  ^:private ^:static
  (defm qsort [^{:tag [int]} xs ^int left ^int right]
    (when (< left right)
      (let [p (aget xs (/ (+ left right) 2))
            l left
            r right]
        (while (<= l r)
          (while (< (aget xs l) p) (inc! l))
          (while (> (aget xs r) p) (dec! r))
          (when (<= l r)
            (let [tmp (aget xs l)]
              (aset xs l (aget xs r))
              (aset xs r tmp)
              (inc! l)
              (dec! r))))
        (qsort xs left r)
        (qsort xs l right)))))

(def arr (int-array [3 1 4 1 5 9 2]))
(Qsort/qsort arr)
(seq arr)
;=> (1 1 2 3 4 5 9)

For a more practical example, see also AOBench code written in JiSE.

Supported Java features

• [x] class definition
• [x] inheritance & interface implementation
• [x] constructor definition
• [x] field & method definition
  • [x] non-static fields & methods
  • [x] static fields & static methods
  • [x] method overloading
  • [x] variable arity methods
• [x] various modifiers
  • [x] access control (public / protected / private)
  • [x] abstract
  • [x] final
  • [x] transient
  • [x] volatile
  • [x] synchronized
• [x] initializer & static initializer
• [x] primitive arithmetics
• [x] logical expressions
• [x] assignments
• [x] increments & decrements
• [x] conditionals (if / switch)
• [x] loops (while / for / enhanced for / break / continue)
• [x] return
• [x] arrays (including multi-dimensional arrays)
• [x] casting
• [x] string concatenation
• [x] auto-boxing & auto-unboxing
• [x] constructor invocation (including explicit this() / super() invocation)
• [x] field access
• [x] method invocation (including variable arity method invocation)
• [x] exception handling (try / catch / finally / throw)

Not supported Java features

• [ ] interface definition
• [ ] enum definition
• [ ] nested class definition
  • [ ] member classes
  • [ ] local classes
  • [ ] anonymous classes
• [ ] synchronized blocks
• [ ] annotations
• [ ] generics
• [ ] lambda expressions
• [ ] method references

License

Copyright © 2019 Shogo Ohta

This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 which is available at http://www.eclipse.org/legal/epl-2.0.

This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version, with the GNU Classpath Exception which is available at https://www.gnu.org/software/classpath/license.html.