
Compile Clojure to Objective-C - dgellow
https://github.com/joshaber/clojurem
======
takeoutweight
I took a different tack with clojure-scheme by compiling via Gambit Scheme,
which can target Objective-C. [https://github.com/takeoutweight/clojure-
scheme](https://github.com/takeoutweight/clojure-scheme). This approach made
it easier to provide self-hosted compilation, enabling niceties like an on-
device repl.

~~~
terhechte
I recently wanted to try out clojure-scheme for a simple Mac OS X or iOS app,
but I couldn't easily find an example app that shows how to set up a project
to target Objective-C and compile correctly, and what to import to call the
Apple frameworks.

Is that even possible? If yes, is there some sort of sample that I didn't see?

~~~
takeoutweight
The best place to start is actually the scheme iOS repl that comes packaged
with the Gambit source. Take a look at the misc/build-gambit-iOS script
(mentioned on slide 39,40 of my linked talk slides). It's a bit of a hairy
build process (and clojure-scheme only adds more hair into the mix) but once
you have the repl working it's easier to see where to slide in the .scm/.m
files that clojure-scheme and Gambit generate. Some kind of CMake script would
probably ease this pain in setting up all this Xcode stuff.

------
dgellow
Check the refactor-fns branch[1] for recent commits.

[1] [https://github.com/joshaber/clojurem/tree/refactor-
fns](https://github.com/joshaber/clojurem/tree/refactor-fns)

------
javajosh
I would be very curious to understand the runtime implications of imposing
immutability on an Objective-C program. Presumably porting that was a lot of
work.

~~~
robterrell
Many Cocoa classes are immutable (NSString, NSDictionary, NSArray). You can
use the mutable versions (i.e. NSMutableString, NSMutableDictionary,
NSMutableArray) but there's no reason to if the immutable versions are a
better fit for clojurem.

------
adambard
Last commit a year ago, unfortunately.

~~~
trentmb
At least it's open source.

------
elwell
[https://github.com/joshaber/clojurem/blob/refactor-
fns/src/c...](https://github.com/joshaber/clojurem/blob/refactor-
fns/src/cljm/cljm/core.cljm#L64)

------
AlexanderDhoore
I read somewhere it is kind of impossible to implement Clojure without the
JVM...

I would really like to see a Clojure on LLVM project though. Maybe speed won't
be better, but memory usage and boot times might.

~~~
markc
Implementations already exist for the CLR as well as Python, C, Scheme, and of
course JavaScript. LLVM appears to be in the thinking stage still:
[https://github.com/halgari/clojure-metal](https://github.com/halgari/clojure-
metal)

~~~
Touche
To be fair, nothing but JVM and JavaScript are more than just prototypes.

~~~
mortyseinfeld
That's not true. In fact, the CLR port has been around and up to date for
years and before ClojureScript.

~~~
Touche
It's used by no one.

~~~
mortyseinfeld
You're not only wrong, but incapable of knowing that.

------
rbanffy
:-(

I saw the Xcode requirement but I had hopes it would work on Linux.

~~~
melling
It's probably all open source and it's just a matter of resources, right?

~~~
rbanffy
Couldn't make it work, but I admit I didn't try very hard. A Makefile would
probably help a lot.

------
dschiptsov
Clojure's one real advantage is Java interoperability and it is its biggest
single selling point.

You just can code nice and quick in a language _much nicer_ than Java, but
easily access all that code from our_stalled_corporate_crap.jar, _and_
package/deploy it the way they do it in their Java EE world.

Clojure outside Java ecosystem makes no sense.

~~~
Skinney
Persistent datastructures, STM, CAS concurrency primitives and hygenic macros
make no sense outside of the JVM? Please...

Clojure has host language interop, this isn't necessarily the same as Java
interop. It would be very nice to write an iOS app using Clojure for instance.

~~~
dmpk2k
I'd be delighted for a version of Clojure that both drops the JVM and can bind
easily with C.

One of Clojure's big advantages is that it uses the JVM. One of Clojure's big
disadvantages is... that it uses the JVM.

~~~
dschiptsov
Another point is that one have to write a runtime, while Clojure "delegates"
almost everything to JRE.

Clojure is a very clever scripting language for JRE.)

I think that it is good idea to marry Arc and Golang in the same way.)

~~~
Skinney
Nitpic: Clojure delegates most things to the VM. The subtle difference that it
works just fine on JS engines and CLR.

Arc and Golang would not be a good idea. I'm not trying to be overly negative,
but Arc does have it's issues, the main thing being that Arc does not always
work, meaning you would need some tool to hunt down leaks. RC is also slower
than GC for several reasons, and when you require a runtime anyway for
goroutines, you might as well include a GC, especially since Go can have a
precise GC.

