Carp

I love Clojure, but I do miss static types. I'm hoping Carp[0] (mentioned in the article) comes into its own. It seems like it could become my ideal language. The other problem I have with lisps in general is that they seem to encourage clever programming that is hard to read / debug (or maybe they just attract developers who value brevity over clarity... not sure). [0] https://github.com/carp-lang/Carp

In the “Immediate plans (say, March 2019)” (yes, most of this project is 2¾ years old, though there have been spasms of activity in some areas from time to time since): > Leconscrip: a memory-safe low-level statically-typed imperative language without garbage collection and with Lisp syntax, […] I think producing anything even vaguely useful of this description in under a month was fairly wildly unrealistic. The only path to memory safety without garbage collection (… unless you’re willing to forego references altogether, which would generally disqualify usefulness) is some form of ownership tracking, and that’s a fairly lightly-trodden and lightly-documented path. There are very few examples of such languages even if you skip Lispness—I think Cyclone was the first (a research project spanning 2001–2006; and correct me if there was prior

> I just with there was a Lisp like it that didn't run on the JVM. There are a few, with varying degrees of distance from the JVM and varying degrees of similarity to Clojure. - There's ClojureScript, which is Clojure transpiled to JavaScript. - See also Lumo (<https://github.com/anmonteiro/lumo>) and Planck (<https://planck-repl.org/guide-all.html>) - There's Babashka (https://github.com/babashka/babashka), which is a natively-compiled Clojure interpreter, implemented with the Small Clojure Interpreter (https://github.com/babashka/sci) and GraalVM for native compilation. - There's Joker (https://github.com/candid82/joker) with a similar mission to Babashka, but commonly used as a linter. - There's ClojureCLR (https://groups.google.com/g/clojure-clr) on the Common Language Runtime. - There's Cloture (https://github.com/ruricolist/clot

So "cons", and the associated "car" and "cdr" functions are innately the "thing" that needs to be garbage collected in Lisp-like languages. So I immediately went to the manual, and CTRL+F'd for cons. Carp has the following restriction: https://github.com/carp-lang/Carp/blob/master/docs/Manual.md > If you're calling a dynamic function (something defined with defndynamic, or a built in command) it will be executed right away. This works very much like a classic, dynamically typed Lisp interpreter. The dynamic functions are not available in compiled code! Their main usage is in macros and to programatically control your build settings. cons, car, and cdr are all "Dynamic" functions that can only run _DURING COMPILE TIME_. Which means the GC is not needed during runtime: all garbage-collection occurs in the compiler.

An overview of it's deficiencies: https://github.com/carp-lang/Carp/issues/1317

Of course the obvious question is "What kind of memory management does it use?" It uses a "linear" (actually affine) type system for memory management, with borrowed refs similar to Rust, but evidently without tracking mutability: https://github.com/carp-lang/Carp/blob/master/docs/Memory.md The omission of the kind of mutability tracking that eases multithreading seems like a significant drawback for its target application domain.

Thanks for the links. There's also this Reddit discussion [0] from 2 years ago (it mentions Carp btw.) and an explanation about how Carp manages memory [1]. [0] https://www.reddit.com/r/haskell/comments/d5d13i/is_it_possi... [1] https://github.com/carp-lang/Carp/blob/master/docs/Memory.md

Lisp is not necessarily functional. There's a lot of mutation in Common Lisp even if the community favors a functional style. I think the question is: how does Lisp function without garbage collecting cons cells? For one, I'm not sure they even rely on cons cells like "real" Lisp. Clojure doesn't either. They cite ML as inspiration. Carp language guide states object lifetimes are statically inferred [1] which my guess is they allocate on stack (or malloc/free by scope) and detect use-after-free at compile time. Another, more theoretical approach is using linear types which require all values to be "consumed" [2] 1: https://github.com/carp-lang/Carp/blob/master/docs/LanguageG... 2: https://www.cs.utexas.edu/users/hunt/research/hash-cons/hash...

Check out https://github.com/carp-lang/Carp From the readme: > The key features of Carp are the following: > - Automatic and deterministic memory management (no garbage collector or VM) > - Inferred static types for great speed and reliability > - Ownership tracking enables a functional programming style while still using mutation of cache-friendly data structures under the hood > - No hidden performance penalties – allocation and copying are explicit > - Straightforward integration with existing C code > - Lisp macros, compile time scripting and a helpful REPL

We're lucky that language diffusion works both ways. I've kept my eye on Carp[1] because it takes a cue from Rust and brings deterministic memory management & ownership into a Lisp. [1] https://github.com/carp-lang/Carp

There’s a lisp-like language without a GC called Carp [1]. I believe the goal was enabling real time applications and specifically games. I’ve only toyed with it a tiny bit, but it has an ownership memory model inspired by Rust. Pretty neat project! [1] https://github.com/carp-lang/Carp

Another commenter already mentioned Gambit Scheme. That provides for inline C and therefore very easy interop with external libraries. It still has a runtime and GC though - those might pose a problem depending on your platform and task. Ferret (https://github.com/nakkaya/ferret) and Carp (https://github.com/carp-lang/Carp) are both Lisp-like low level languages. Both seem to be fairly experimental in nature though. > anything but C Taking you literally, Rust and D can both compile for bare metal. D in particular has a "Better C" subset. (https://dlang.org/spec/betterc.html) In the same vein, Terra is a C like language (manual memory management) that you metaprogram with Lua. (https://github.com/terralang/terra) Taking you very literally, Forth is also an option.