Compile Clojure to Objective-C

[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. 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?

[dgellow]

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

[1] 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.

[MaxGabriel]

If by runtime implications you mean speed, I think it'd be ok. Objective-C makes heavy use of immutable data structures already, and iPhone apps just don't have that much data, anyway.

[nickbauman]

I haven't looked at the source, but the avoidance of full copy-on-write, laziness and instrumentation of immutable structures when returning from functions that update / assoc them will be non-trivial to get right. Not even to mention software transactional memory Clojure supports at all.

[Skinney]

Immutability in general isn't that big of a deal. The problem is that Clojure uses persistent trees for all datastructures, which will trigger alot of retain/release calls. Other than some RC overhead, it should work just fine. A GC would be ideal however.

[gvickers]

Using mutable data structures is pretty easy in clojure, I'm going to dig around and see how they handle this.

[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...

[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.

[phaedryx]

Not necessarily: http://clojure.org/clojureclr http://clojure.org/clojurescript

[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

[pjmlp]

The only dependency to the JVM would be the advantage of integrating with the Java ecosystem.

When compiling Clojure to native code, you won't be able to use Java libraries, unless the native compiler can also generate native code for .class files.

[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?

[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.

[dkersten]

ClojureCLR has existed for .NET since very early on. ClojureScript also targets javascript. There is also a Clojure on Python and a Clojure on Lua.

At the very least, ClojureCLR and ClojureScript most certainly do make sense.

[zephjc]

Targeting another popular platform, Objective-C with the Apple libraries, makes a lot of sense to me. That, and C#/.NET (which is already a thing with clojure-clr) seem like the obvious candidates.