What Scheme does /prog/ use?

I have been using Chicken for a little bit. Used Racket for like 5 minutes. R6RS is PIG DISGUSTING!

That is all.

chicken when I'm doing call/cc stuff. scm otherwise.

javascript

javascheme

schemescript

I wrote my own. It supports all the features I need.

>>6
I want to be a cool hacker like you.

>>7
Well then write your own. It's not hard and it's a lot of fun. In fact, programming a Scheme interpreter in C is a lot like programming in Scheme once all the basic abstractions are laid out. Start with a basic generic object type.

typedef struct object {
    int type;
    union {
        struct {
            object *car;
            object *cdr;
        } pair;
        char *symbol;
        char *string;
        double number; /* or implement bignums if you want */
        ...
    } val;
} object;

Now write cons, car, cdr, symbol, string, number, etc. and you're ready to the write the parser.

Since code is data in Scheme, you can write a parser that simply translates text to data and not worry about executing it. Write it just like you would a recursive function in Scheme. The parse takes a "list" (either an array of chars or a FILE stream) and returns a tree (of objects) that represent the code as data.

You should also write display concurrently so you can have display(parse(stdin)); in your main loop until the parser is completed. Once the output is equivalent to the input, you're ready to move on.

Next step is eval. Once you have your generic Scheme object and all the necessary primitive-like constructors, predicates, accessors and mutators, you could translate the metacircular evaluator from SICP to C in a few hours. The MCE is not that elegant, however, and will certainly be slow as balls. The way it stores the environment for instance is too complex and can be greatly simplified. Primitive and compound procedures are better represented as native C structs contained in object rather than "tagged lists". MCE's eval however is a good starting point for learning how to implement the define, lambda, and if special forms.

Next, write apply. Binding primitives to your application will be time consuming and tedious, but it's rewarding once your able to start running real Scheme programs. Read R5RS for implementation details.

At this point, you can either write special forms for and, or, cond, let, begin, etc. or you can just implement define-syntax and do the rest in Scheme. It all depends on whether you want a pure C implementation or just a tiny C core. Both have pros and cons (no pun, etc. etc.).

Good luck.

>>8
An actual informative post on /prog/? I commend you.

chicken lyf

>>8
I'd argue that a bytecode (stack machine) compiler would be easier to write.  Your move.

>>11
A bytecode(stack machine) isn't the same thing as a compiler.

NO U. GAME OVER U STUPID KID!!!

I am FAGGOT. Fuck me.

keep fucking that chicken

>>15
Don't be j.

>>8,11

Here is my, pathological, scheme object scheme for 32-bit systems. This is pretty standard for most C-based implementations of scheme, and possibly, most LISPs for that matter. Notice the use of the struct hack and the size field in the manifest. This makes the compacting GC's job simpler in reckoning with objects on the heap, while placing on the allocator the burden of calculating and recording the size of each object.

typedef struct obj
{
    //manifest
    struct {
        unsigned int type   : 5;
        unsigned int gc     : 1;
        unsigned int vec    : 1;
        unsigned int pad    : 9;
        unsigned int size   : 16;
    };
    union
    {
        struct obj     *l;
        signed int      i;
        float           f;
        char            c;
    } datum[0];
} obj;

>>17
sexp

>>17
if you swap the l and the f you get: THE FORCED INDENTATION OF LISP CODE

:3

>>17
datum[0]
If you're making it variable sized, why use a hack like that? Instead use arrays directly and follow the convention that the first element in every array is the manifest.


union obj
{
    struct {
        unsigned int type   : 5;
        unsigned int gc     : 1;
        unsigned int vec    : 1;
        unsigned int pad    : 9;
        unsigned int size   : 16;
    }           manifest;
    union obj  *l;
    signed int  i;
    float       f;
    char        c;
};

>>20

Because, I found it easier to read and reason about, as I was writing it. However, I wouldn't imagine there's really any difference, at all.