writeup v0
© 2014 George King.
Permission to use this file is granted in ploy/license.txt.


# Introduction

Ploy is an experimental programming language. It is somewhat similar to Lisp; the obvious differences are:
• The fundamental compound objects are typed structures and vectors, as opposed to cons pairs in Lisp;
• Macro expansion syntax is distinct from function call syntax ('<...>' and '(...)' respectively).
• Types are true objects that contain information describing the nature of their instances. 
• The runtime currently uses reference counting for memory management.

Ploy is currently in early development, and is released under the ISC license (similar to 2-clause BSD).

Contributions are welcome - there is a lot to do!

## General Direction
• Memory management via reference counting:
  • Partial/experimental support for collecting reference cycles via 'cycle coalescing'.
  • Weak references are not yet implemented.
• Ahead-of-time (AOT) compilation.
  • This implies no dynamic type or function creation.

## Features that work
• Tagged value/reference object implementation.
• Strong reference counting (leaks notwithstanding).
• basic macro expansion and code execution.
• a few core definitions.

## Work to do
• Semantics of nil/none and the Opt option/maybe type.
  • I think there should be some syntax dedicated to option checking.
  • Perhaps this syntax maybe generalized to first/rest variants of any union type.
• Semantics of void.
• Boolean semantics:
  • Should non-boolean types have implicit truthiness?
  • If so, should these be completely user-definable or are they constrained?
• Type semantics of special symbols like void, true, false.
• Type derivation.
• Argument splats?
• Start the compiler.

## Here are some language design questions to explore
• Does the distinct macro expansion syntax improve clarity? Does it reduce expressiveness?
• Does the simple syntax facilitate metaprogramming?
• Does the lack of traditional syntax (binary operators, dot accessors) hinder everyday programming?
• How well do various language features interact, in terms of semantics and implementation?
  • Reference counting, subject to reference cycle leaks.
  • constraints on mutability.
  • weak references.
  • closures, generators and coroutines.
  • compilation (specifically using LLVM).


# Requirements

Ploy is developed with the following tools:
• clang 3.5
• gnu bash 3.2.51
• gnu make 3.81
• python 3.4.1
• OS X 10.10

Ploy has not been tested with gcc, but it should be! There might be a few clang-specific flags used in tools/cc.sh; these should not be necessary for correct builds.


# Usage
  $ make
  # build both _bld/ploy and _bld/ploy-dbg (the debug build with assertions).

  $ sh/run.sh [src] [args...]
  # make and run the debug build with malloc debug environment variables set.

  $ make test
  # run the tests.

## Options
• -e '<exprs>': evaluate expressions and output the final result to stdout.
• -t: trace evaluation: prints out verbose debug info for every evaluation step.
• -b: bare mode: do not load the core files; useful for debugging changes to the interpreter.
• -s: stats: log all stats on exit.