Found this page to be a nice intro to the syntax and semantics:<p><a href="https://github.com/carp-lang/Carp/blob/master/docs/LanguageGuide.md">https://github.com/carp-lang/Carp/blob/master/docs/LanguageG...</a><p>This part hits a real sweet spot for me:<p>> Carp borrows its looks from Clojure but the runtime semantics are much closer to those of ML or Rust.<p>One of my current side-projects is a little Civ-style game I'm working on in Racket, which I decided to start coding in on a whim. Will see how it goes moving pieces of it across to Carp.
To me, the most interesting aspect of S-expression programming languages is that they are very well suited for other editors than the text editor. I know of a number of experiments in this regard but I have yet to see anything quite as ground breaking as what I can imagine is possible.<p>How come we don't have Google Maps-like zooming with LOD mapping to abstractions at different levels?
I tried it out months ago. It has a really limiting REPL if you’re coming from other lisps like Common Lisp or even Clojure. If your bag is interactive development, then that might be a bummer. <a href="https://github.com/carp-lang/Carp/blob/master/docs/Manual.md#differences-compared-to-repls-in-other-lisps">https://github.com/carp-lang/Carp/blob/master/docs/Manual.md...</a>
I'm excited about Carp's comprehensive and well documented[1] interoperability with C, which unlocks lots of potential for interfacing with existing libraries.<p>Tim Dévé has even created a game for the Nintendo Game Boy Advance by using Carp's C interoperability; you can play an emulated version online[2].<p>[1]: <a href="https://github.com/carp-lang/Carp/blob/master/docs/CInterop.md">https://github.com/carp-lang/Carp/blob/master/docs/CInterop....</a><p>[2]: <a href="https://radicorn.do.timdeve.com/" rel="nofollow">https://radicorn.do.timdeve.com/</a>
The project compiles LISP to C (with Haskell code-base) and relies on a C compiler to generate executables. This means you will have to get your C dependencies in-place to work with carp.<p>I was trying this from `nix-shell -p carp` and immediately ran into issue with this when building the hello world example from the README. (Package sdl2 was not found).<p>Not sure how to fix this just adding `- p SDL` to the nix-shell prompt does not help, as the invoked compiler does not know where to look.<p>Any recommendations here? I want to avoid using a global clang/gcc installation for various reasons. Is running this under `nix` a good idea? Should I move this into a container?
Sounds similar to Cakelisp. Has anyone tried both and is able to contrast them?<p>The author of Cakelisp notes that Carp requires writing bindings, but Cakelisp apparently does not:<p><a href="https://macoy.me/code/macoy/cakelisp/src/branch/master/doc/VsOtherLanguages.org" rel="nofollow">https://macoy.me/code/macoy/cakelisp/src/branch/master/doc/V...</a><p>Edit: I think Cakelisp has you explicitly generate C code, and maybe Carp does it behind the scenes?
I only read the front page, but I can't figure out what "statically typed" even means in the context of lisp. If it isn't doing manifest value typing it's hard for me to call whatever it is "lisp"; it's something else with a lot of parentheses. Does it just mean once a symbol has taken a value of one type it can't ever take a value of another? What would the point of that limitation be?
Don't get too hung up on the "lisp" in that title.
I think the language would better be described as statically typed, with s-expr syntax, inspired by Clojure|Rust|ML and with a lispy language accessible for use in macros. But that's less catchy.<p>Source: I contribute to the language.
Wasn't this at some point written in Rust? What prompted the Haskell rewrite? I tried looking through the issue tracker but didn't find anything, just curious.
Having used <a href="https://perldoc.perl.org/Carp" rel="nofollow">https://perldoc.perl.org/Carp</a> in the past, I always have to remind myself that this is the noun, not the verb.
A looked at it a couple of years ago. It didn't have a Lisp like repl in the sense that it was not possible to recompile running code. I don't know if that has changed in the meantime.