Thursday, February 28, 2008
Tuesday, February 26, 2008
Monday, February 25, 2008
The Anarki repository is stored in a source control system called git. The repository is open for access and updates by Arc users. Accessing the repository is straightforward, and will be described below. Submitting changes to the repository is not much harder, but is beyond the scope of this document; one source of information is on arclanguage.org.
The repository is promptly updated when a new version of Arc is released. Most of the changes in the repository haven't been migrated back to the official Arc releases, so there is considerable divergence between the official Arc version and the Anarki version.
Installing git on LinuxOn Linux, git is in the "git-core" package. You can install this with "sudo apt-get git-core" on Ubuntu, or "sudo yum install git-core" on Red Hat.
Installing git on WindowsOn Windows, one option is Git on MSys, which can be downloaded from the msysgit site, under "Featured Downloads".
Using git to fetch AnarkiOnce git is installed, fetching the repository is surprisingly easy. Run "git clone git://github.com/nex3/arc.git", which will create a directory "arc-wiki" containing a copy of the repository. To get updates from the repository, run "git pull".
Browsing Anarki without gitYou can browse the repository directly by going to http://github.com/nex3/arc/tree/master. To view a file, click on the filename.
Once you've downloaded Anarki, you can see the cutting edge of Arc modifications. One of the most interesting features of the Anarki version is docstrings: "(help map)" will display documentation on the map function, for instance.
The stable Anarki branchA "stable" Anarki branch has also been created. This repository is close to the official Arc release, but with bug fixes and minimal new features. The stable repository lacks the experimental features and rapid changes of the regular repository.
To use the stable repository, check out Anarki as described above. Then run "git branch stable origin/stable" and "git checkout stable". All the experimental files and directories will disappear, and you will be left with the stable branch. For more information, see the arclanguage forum.
The Arc-to-C compilerAn Arc to C compiler is being developed in a separate repository:
git://github.com/sacado/arc2c.git, which can be accessed on the web at http://github.com/sacado/arc2c/tree/master.
Sunday, February 24, 2008
News.YC releaseThe key difference is the release of the News.YC source in news.arc. This 1769-line file apparently provides the full implementation of news.ycombinator.com. One interesting thing is that stories are ranked according to (score-1) / (age-in-hours ^ gravity), where gravity is 1.4 by default.
There are also some gifs to support the site. The following is a list of the new files in arc2:
- news.arc: the source for news.ycombinator.com.
- grayarrow.gif: gray uparrow
- graydown.gif: gray downarrow
- s.gif: 1x1 transparent spacer
- y18.gif: 1x1 spacer (same as s.gif)
- arc-list? fix for '()
- write, disp cleanup
- Renamed when-usermatch to when-umatch, when-usermatchr to when-umatch/r, matchform to uform.
- Removed pw from good-login record.
- (firstn nil xs) now returns xs
- (nthcdr nil xs) now returns xs
- trav renamed to treewise
- New function union on sequences.
- New function addtem to create a template.
- New functions hours-since and days-since.
- ensure-dir fix.
- Function only is now entirely different. Wraps a function to only call it if given args.
- Function plural moved to strings.arc. Now if w/bars were moved too...
- New function trav: takes an object and functions. Applies the functions to the object.
- New function defhook and hook to register and execute functions?
- Added orange as a color.
- para now takes arguments.
- Removed image-url and local-images*
- spacetable renamed to sptab.
- Added single-input and cdata.
- Added news.arc.
- Remove "frug" default account.
- Excludes .arc as a static filetype, to hide source.
- plural function moved here from arc.arc.
Tuesday, February 12, 2008
Saturday, February 9, 2008
:ainto the Arc REPL drops execution into Scheme, allowing easy examination of the internals:
> (= x 3) 3 arc> (= y '(1 (2 3) 4)) (1 (2 3) 4) arc> (def z () (pr "hello")) #<procedure: z> arc> :a > _x 3 > _y (1 (2 3 . nil) 4 . nil) > _z #<procedure: z>Arc's data and procedures are stored in the Scheme environment, with a few modifications. Arc symbols have an underscore prepended internally to avoid collisions with Scheme names. In the Arc language, the empty list is
nil, while the Scheme empty list is (). Thus, Arc lists are stored in Scheme terminated by the (arbitrary) symbol 'nil, as can be seen by the dotted notation above. Arc macros are stored as a vector of the symbol 'tagged, the symbol 'mac, and the procedure.
The REPLArc runs from a Read-Evaluate-Print Loop (REPL), which is started by executing the simple procedure tl:
(define (tl) (display "Use (quit) to quit, (tl) to return here after an interrupt.\n") (tl2))Note that the REPL runs in Scheme, not in Arc. tl is a wrapper around tl2, which is the real REPL implementation:
(define (tl2) (display "arc> ") (on-err (lambda (c) (set! last-condition* c) (display "Error: ") (write (exn-message c)) (newline) (tl2)) (lambda () (let ((expr (read))) (if (eqv? expr ':a) 'done (let ((val (arc-eval expr))) (write (ac-denil val)) (namespace-set-variable-value! '_that val) (namespace-set-variable-value! '_thatexpr expr) (newline) (tl2)))))))The arguments to on-err are an error procedure and the body procedure. The error procedure is executed if the main procedure encounters an exeception, similar to a try/catch block, but with the catch procedure first. The on-err procedure is implemented with continuations. If you're looking for the "mind-expanding" parts of Lisp, continuations will definitely interest you, but I will ignore on-err for now. The meat is the second lambda function. The Scheme read procedure reads the input and creates an object using the Scheme parser. The input is passed to arc-eval, which evaluates the input as an Arc form. The result is converted by arc-denil from the internal 'nil-terminated form to displayable form and written out. The tl2 procedure then calls itself; to the C programmer, this may look like a stack overflow waiting to happen. However, Scheme is tail-recursive so the stack doesn't grow, and the call acts like a simple loop. The Scheme variables _that and _thatexpr record the expression to help debugging.
arc-eval and acThe arc-eval procedure is the main entry point for executing an Arc form. It calls ac to convert the Arc form to a quoted Scheme form, and then does an eval on the Scheme expression:
(define (arc-eval expr) (eval (ac expr '()) (interaction-environment)))The arc-eval procedure can be executed directly from inside Scheme:
> (arc-eval '((fn (x) (+ x 1)) 42)) 43The ac procedure is the real meat of Arc, as it translates Arc to Scheme. Its second argument is the "environment", a list of symbols that are currently bound. At the REPL, this list is empty.
(define (ac s env) (cond ((string? s) (string-copy s)) ; to avoid immutable strings ((literal? s) s) ((eqv? s 'nil) (list 'quote 'nil)) ((ssyntax? s) (ac (expand-ssyntax s) env)) ((symbol? s) (ac-var-ref s env)) ((ssyntax? (xcar s)) (ac (cons (expand-ssyntax (car s)) (cdr s)) env)) ((eq? (xcar s) 'quote) (list 'quote (ac-niltree (cadr s)))) ((eq? (xcar s) 'quasiquote) (ac-qq (cadr s) env)) ((eq? (xcar s) 'if) (ac-if (cdr s) env)) ((eq? (xcar s) 'fn) (ac-fn (cadr s) (cddr s) env)) ((eq? (xcar s) 'set) (ac-set (cdr s) env)) ((pair? s) (ac-call (car s) (cdr s) env)) (#t (err "Bad object in expression" s))))Arc strings are copied to Scheme strings. Arc literals are unchanged. The Arc symbol 'nil is unchanged. Input with ssyntax (i.e. : or ~) is expanded and re-evaluated. Symbols are handled by ac-var-ref. Special operators quote, quasiquote, if, fn, and set are handled by separate procedures. Procedures are handled by ac-call.
xdefArc primitives are created with xdef, which enters a Scheme procedure into the namespace:
(define (xdef a b) (namespace-set-variable-value! (ac-global-name a) b) b)For example, the Arc newstring procedure is just the Scheme make-string procedure:
(xdef 'newstring make-string)Note that namespace-set-variable-value! is somewhat similar to define, except it takes a symbol such as 'a, rather than a variable such as a.