
Carp 0.3 - tosh
https://github.com/carp-lang/Carp/releases/tag/v0.3.0
======
ghosthamlet
Other GC-free Lisps:

    
    
        Pre-Scheme(https://en.wikipedia.org/wiki/PreScheme) is a GC-free (LIFO) subset of Scheme
    
        newLISP(http://www.newlisp.org/) uses "One Reference Only" memory management
    
        Linear Lisp(http://home.pipeline.com/%7Ehbaker1/LinearLisp.html) produces no garbage (and seems to have no implementation)
    
        Dale(https://github.com/tomhrr/dale) is basically C in S-Exprs (but with macros)
    
        ThinLisp(https://web.archive.org/web/20160324213055/http://www.thinlisp.org/, https://github.com/ska80/thinlisp) is a subset of Common Lisp that can be used without GC
    
        Bone Lisp(https://github.com/wolfgangj/bone-lisp) semi-automatic memory management
    
    

list is copyed from:
[https://www.reddit.com/r/lisp/comments/4mtktn/bone_01_lisp_w...](https://www.reddit.com/r/lisp/comments/4mtktn/bone_01_lisp_without_garbage_collection/)

------
chc4
Has anyone used Carp? What is your experience with it?

I looked at it a few times over the years and the domain (statically typed
language with Rust-esque lifetimes for no GC) is exactly what I've wanted a
few times, but there isn't any mention of _embeding_ Carp in a program, only
using it standalone. Targetting e.g. video games with low latency is fine, but
I'd rather write an engine (or use an existing one!) and use Carp for
scripting than be locked into solely Carp.

~~~
voidhorse
I’ve played with Carp a bit and have made minor contributions to the language.
I’m not sure if there’s been any investigation into using it as an embedded
scripting language yet, but there are definitely folks using it for embedded
programming based on the community chats. I think someone has used it for
programming modular synthesizers (or something like that)? At any rate, Carp
definitely supports interfacing with C libs and you can choose to disinclude
the standard library which is useful when you have limited space.

More generally, the language is a blast to use! IMO it grants one the fluidity
and expression of lisp with the confidence one gets from a Haskellesque type
system.

If you have any questions, the community on Gitter is very helpful.

~~~
dmix
It's always interesting to see who adopts the languages first and what they
build with it.

A non-GC statically typed language seems to be the future a lot of people are
looking for.

------
DrBazza
tl;dr Carp is a small programming language designed to work well for
interactive and performance sensitive use cases like games, sound synthesis
and visualizations.

~~~
anthony_doan
Thank you, I thought it was OpenBSD's CARP port to Linux until I read your
comment.

------
mncharity
Today there's also discussion of the 1992 "Lively Linear Lisp" paper as
[https://news.ycombinator.com/item?id=20369522](https://news.ycombinator.com/item?id=20369522)
.

------
tosh
A talk about Carp from ClojuTRE 2018

[https://www.youtube.com/watch?v=BQeG6fXMk28](https://www.youtube.com/watch?v=BQeG6fXMk28)

------
StreamBright
Wow, this is exactly what I was looking for. Christmas came early. We were
debating if there is a way to create a lisp with no-GC using a borrow checker
and also have ML style type system. The answer is, yes!

------
ghosthamlet
Another Statically Typed toy Lisp:
[https://gist.github.com/chrisdone/516489f4f27846712225](https://gist.github.com/chrisdone/516489f4f27846712225)

------
wwwhizz
The amount of parentheses is dizzying.

~~~
StreamBright
Once you are counting the amount of parentheses in a Python vs in a LISP
program doing the same and realise the the Python version has more you give up
on your parentheses phobia pretty quickly.

~~~
sk0g
I'd like to see a proper example demonstrating this, because from what I saw
on the linked project's README, the Python version would have about a third of
the parentheses.

------
blondin
i mean, is code written in lisp-like functional style maintainable? it always
takes a few seconds more per line of code for it to register if it does at
all... versus code written in say imperative or declarative style.

i mean what could this possibly mean? "(bg rend &(rgb (/ @state 2) (/ @state
3) (/ @state 4))))"

~~~
vincent-toups
I prefer s-expressions, for what its worth, to almost any syntax. I've also
been programming in Lisp dialects for more than a decade, so I've had time to
get used to them. But I still find them more readable than any other kind of
language.

~~~
vnorilo
And more writable, since your editor can take advantage of the consistent
structure via paredit et al.

FWIW, I split my time 2:1 between C++ and Clojure these days, and the context
switch to s-exprs is always easier, even though I spend less time working in
them.

