b6c679afa6
Adding `#'module+` explicitly to the stop-list for local-expand stops the infinite recursion (problem 1 in the issue description). The code goes on to treat it like `#'module` and `#'module+`, namely as a non-action-producing form. Problem 2 in the issue description is interesting. I haven't done anything in particular to address the production of unbounded `X` -> `(begin X)` expansions, but it seems not currently to be a problem; and, weirdly (?), submodules in a `#lang syndicate` or `#lang syndicate/actor` module do not seem to inherit the `#%module-begin` of their container! That is, `(module+ main)`, `(module+ test)` etc. all seem to have a `racket/base` `#%module-begin`, though I've not looked very far into this. Most peculiar on this front is that if the `#,@(reverse final-forms)` precedes the `(module+ syndicate-main ...)`, and the module being processed includes, say, a `(module+ main)`, then for some reason the resulting `main` submodule *is* treated as having a `syndicate/lang` `#%module-begin` (thus causing problems as suggested in the issue description)! I *really* don't understand why that might be, and haven't spent very much time investigating after I noticed that so long as the `main`-required `syndicate-main` submodule preceded all other submodule declarations, things seemed to work out. This whole approach is still a bit dicey: for example, the following will erroneously treat `(foo quux)` as an expression yielding actions, rather than a struct declaration: #lang syndicate (define-syntax-rule (foo x) (struct x ())) (foo quux) |
||
---|---|---|
doc | ||
examples | ||
hs | ||
js | ||
racket | ||
README.md |
README.md
Syndicate: A Networked, Concurrent, Functional Programming Language
Syndicate is an actor-based concurrent language able to express communication, enforce isolation, and manage resources. Network-inspired extensions to a functional core represent imperative actions as values, giving side-effects locality and enabling composition of communicating processes.
Collaborating actors are grouped within task-specific networks (a.k.a. virtual machines) to scope their interactions. Conversations between actors are multi-party (using a publish/subscribe medium), and actors can easily participate in many such conversations at once.
Syndicate makes presence notifications an integral part of pub/sub through its shared dataspaces, akin to tuplespaces. Each shared dataspace doubles as the pub/sub subscription table for its network. Actors react to state change notifications reporting changes in a dataspace, including new subscriptions created by peers and removal of subscriptions when a peer exits or crashes. State change notifications serve to communicate changes in demand for and supply of services, both within a single network and across nested layers of networks-within-networks. Programs can give up responsibility for maintaining shared state and for scoping group communications, letting their containing network take on those burdens.
Contents
This repository contains
-
a Racket implementation of Syndicate (plus auxiliary modules) in
racket/syndicate/
-
an ECMAScript 5 implementation of Syndicate in
js/
-
larger example programs:
-
examples/platformer
, a 2D Platform game written in Syndicate for Racket. -
examples/netstack
, a TCP/IP stack written in Syndicate for Racket. It reads and writes raw Ethernet packets from the kernel using Linux- and OSX-specific APIs.
-
-
a sketch of a Haskell implementation of the core routing structures of Syndicate in
hs/
Copyright
Copyright © Tony Garnock-Jones 2010, 2011, 2012, 2013, 2014, 2015, 2016.