atomy 0.1.1 → 0.6.3

data/kernel/data.ay

@@ -1,56 +1,100 @@
-macro(&x):
-  Atomy::AST::BlockPass new(x line, x)
+-- TODO: make this work:
+--
+-- module:
+--   data(A(@x))
+--   A(x) foo := x
+--
+-- right now pattern definitions can only be at the toplevel
 
-macro(*x):
-  Atomy::AST::Splat new(x line, x)
+use(require("core"))
+use(require("define"))
+use(require("control-flow"))
 
-macro(@(x: Variable)):
-  Atomy::AST::InstanceVariable new(x line, x name)
+-- patterns defined by dsl use 'with', so make sure it's exported
+export(use(require("patterns")))
 
-macro(@@(x: Variable)):
-  Atomy::AST::ClassVariable new(x line, x name)
+fn(define-class(root, e & Atomy Grammar AST Constant)):
+  define-class(root, `((~e)()))
 
-macro($'exception):
-  Atomy::AST::GlobalVariable new(line, "!")
+fn(define-class(root, x & `((~name)(~*as)))):
+  define-class(root, `(~x {}))
 
-macro($'path):
-  Atomy::AST::GlobalVariable new(line, ":")
+fn(define-class(root, `(~(n & Atomy Grammar AST Constant) { ~*cs }))):
+  define-class(root, `((~n)() { ~*cs }))
 
-macro($'separator):
-  Atomy::AST::GlobalVariable new(line, "/")
+fn(define-class(root, `((~name)(~*as): ~*cs))):
+  attrs = []
+  as each [x]:
+    x match:
+      (`@~_):
+        attrs << x
 
-macro($'0):
-  Atomy::AST::GlobalVariable new(line, "0")
+      `(@~_ = ~_):
+        attrs << x left
 
-macro($(x: String)):
-  Atomy::AST::GlobalVariable new(line, x value)
+  tmps = attrs collect [`@~name]: Atomy Grammar AST Unquote new(name)
 
-macro($(x: Constant)):
-  Atomy::AST::GlobalVariable new(x line, x identifier)
+  pat = name
+  attrs zip(tmps) [attr, tmp]:
+    &pat = `(~pat & with(~attr, ~tmp))
 
-macro($(x: Variable)):
-  Atomy::AST::GlobalVariable new(x line, x name)
+  cons = `((~name)(~*tmps))
 
-macro(#(x: Constant)):
-  Atomy::AST::Particle new(x line, x identifier)
+  pat-def =
+    `(pattern(~cons):
+        pattern(~make-quasiquote(pat)))
 
-macro(#(x: Variable)):
-  Atomy::AST::Particle new(x line, x name)
+  parent = (root || 'Object)
 
-macro(#(x: String)):
-  Atomy::AST::Particle new(x line, x value)
+  `(do:
+      ~parent class(~name):
+        attr-accessor(
+          ~*(attrs collect [a]:
+              `.~(a node)))
 
-macro(#(x: Primitive)):
-  Atomy::AST::Particle new(x line, x value to-s)
+        def(initialize(~*as)): nil
 
-macro(a .. b): `(Range new(~a, ~b))
-macro(a ... b): `(Range new(~a, ~b, true))
+        def(inspect):
+          result = (~(Atomy Code StringLiteral new(name text to-s)) + "(")
 
-macro(x for(e) in(c)): `(~c collect [~e]: ~x)
+          args = []
+          recursed = //Thread detect-recursion(self):
+            [~*attrs] each [v]:
+              args << v inspect
 
-macro(x for(e) in(c) if(t)):
-  names [tmp]:
-    `([] tap [~tmp]:
-        ~c each [~e]:
-          when(~t):
-            ~tmp << ~x)
+          when(recursed):
+            args << "..."
+
+          result << args join(", ")
+          result << ")"
+
+          Rubinius Type infect(result, self)
+
+          result
+
+      ~pat-def
+
+      ~*(cs collect [c]: define-class(name, c)))
+
+macro(data: ~*children):
+  `(Object data: ~*children)
+
+macro(data(~x)):
+  `(Object data(~x) {})
+
+macro(~root data(~x)):
+  `(~root data(~x) {})
+
+macro(data(~parent): ~*children):
+  `(Object data(~parent): ~*children)
+
+macro(~root data: ~*children):
+  `(do:
+      ~*(children collect [c]:
+          define-class(root, c))
+      nil)
+
+macro(~root data(~parent): ~*children):
+  `(do:
+      ~(define-class(root, `(~(parent): ~*children)))
+      nil)

data/kernel/define.ay

@@ -1,93 +1,84 @@
-macro(do(&b)): b body
-
-macro(x = y):
-  Atomy::AST::Assign new(x line, x, y)
-
-macro(x =! y):
-  Atomy::AST::Set new(x line, x, y)
-
-macro(x := y):
-  where = Atomy::Namespace define-target
-  Atomy::Namespace register(x namespace-symbol, where)
-
-  Atomy::CodeLoader when-load <<
-    [`(Atomy::Namespace register(~(x namespace-symbol), ~where)), true]
-
-  Atomy::AST::Define new(x line, x, y, where)
-
-macro(define(x, &y)):
-  `(~x := ~(y block-body))
-
-macro(x **= y): `(~x =! (~x ** ~y))
-macro(x *= y): `(~x =! (~x * ~y))
-macro(x <<= y): `(~x =! (~x << ~y))
-macro(x >>= y): `(~x =! (~x >> ~y))
-macro(x &&= y): `(~x =! (~x && ~y))
-macro(x &= y): `(~x =! (~x & ~y))
-macro(x ||= y): `(~x =! (~x || ~y))
-macro(x |= y): `(~x =! (~x | ~y))
-macro(x += y): `(~x =! (~x + ~y))
-macro(x -= y): `(~x =! (~x - ~y))
-macro(x /= y): `(~x =! (~x / ~y))
-macro(x ^= y): `(~x =! (~x ^ ~y))
-macro(x %= y): `(~x =! (~x % ~y))
-
-macro(x match(&b)):
-  Atomy::AST::Match new(line, x, b)
-
-macro(class(`(<< ~obj), &body)):
-  Atomy::AST::SingletonClass new(obj line, obj, body block-body)
-
-macro(class(`(~name < ~sup), &body)):
-  Atomy::AST::Class new(name line, name, body block-body, sup)
-
-macro(class(name, &body)):
-  Atomy::AST::Class new(name line, name, body block-body)
-
-macro(module(name, &body)):
-  Atomy::AST::Module new(name line, name, body block-body)
-
-macro(evaluate-when('compile, 'run, 'load, &x)):
-  x body evaluate
-  Atomy::CodeLoader when-load << [x block-body, true]
-  `(when(!(Atomy::CodeLoader compiled?) &&
-          Atomy::CodeLoader reason == #run):
-      ~*(x contents))
-
-macro(evaluate-when('run, 'compile, &x)):
-  x body evaluate
-  `(when(!(Atomy::CodeLoader compiled?) &&
-           Atomy::CodeLoader reason == #run):
-      ~*(x contents))
-
-macro(evaluate-when('compile, 'run, &x)):
-  x body evaluate
-  `(when(!(Atomy::CodeLoader compiled?) &&
-           Atomy::CodeLoader reason == #run):
-      ~*(x contents))
-
-macro(evaluate-when('compile, 'load, &x)):
-  x body evaluate
-  Atomy::CodeLoader when-load << [x block-body, true]
-  'nil
-
-macro(evaluate-when('compile, &x)):
-  x body evaluate
-  'nil
-
-macro(evaluate-when('run, &x)):
-  `(when(Atomy::CodeLoader reason == #run) { ~*(x contents) })
-
-macro(evaluate-when('load, &x)):
-  Atomy::CodeLoader when-load << [x block-body, false]
-  'nil
-
-macro(for-macro(&b)):
-  `(evaluate-when(compile, load):
-      ~b block call-on-instance(Atomy::Macro::Environment singleton-class))
-
-macro(let-macro(*ms, &body)):
-  macros = ms collect [`(~p = ~b)]:
-    Atomy::AST::Macro new(p line, p, b)
-
-  Atomy::AST::LetMacro new(line, body caller, macros)
+use(require("core"))
+
+require("atomy/message_structure")
+
+-- function definition
+macro(fn(~message): ~*body):
+  structure = Atomy MessageStructure new(message)
+
+  Atomy Code DefineFunction new(
+    structure name
+    `(do: ~*body)
+    structure receiver
+    structure arguments
+    structure default-arguments
+    structure splat-argument
+    structure post-arguments
+    structure proc-argument
+  )
+
+macro(fn(~dummy-message)):
+  structure = Atomy MessageStructure new(dummy-message)
+  Atomy Code DefineFunction new(structure name)
+
+
+-- method definition
+macro(def(~message): ~*body):
+  structure = Atomy MessageStructure new(message)
+
+  Atomy Code DefineMethod new(
+    structure name
+    `(do: ~*body)
+    structure receiver
+    structure arguments
+    structure default-arguments
+    structure splat-argument
+    structure post-arguments
+    structure proc-argument
+  )
+
+-- helper for adding a module to the constant scope
+with-module = Class new:
+  def(bytecode(gen, _)):
+    gen push-self
+    gen add-scope
+    gen push-nil
+
+current-module = Class new:
+  def(bytecode(gen, _)):
+    gen push-scope
+    gen send(.module, 0)
+
+-- module/class opening
+macro(~x open: ~*body):
+  `(~x module-eval:
+      ~(with-module new)
+      ~*body)
+
+-- anonymous class creation
+macro(class: ~*body): `(Object class: ~*body)
+
+macro(~parent class: ~*body):
+  `(//Class new(~parent) open:
+      ~*body
+      self)
+
+-- named class creation
+macro(class(~name): ~*body): `(Object class(~name): ~*body)
+
+macro(~parent class(~name): ~*body):
+  `(//Class new(~parent, .~name, ~(current-module new)) open:
+      ~*body
+      self)
+
+-- singleton class opening
+macro(singleton: ~*body): `(self singleton: ~*body)
+
+macro(~x singleton: ~*body):
+  `(~x singleton-class open: ~*body)
+
+-- module creation
+macro(module: ~*body):
+  `(//Module new open:
+      ~*body
+      self)

data/kernel/doc.ay

@@ -1,453 +1,286 @@
-namespace(atomy)
-
-title"Pretty-Printing"
-
+use(require("core"))
+use(require("data"))
+use(require("define"))
+use(require("control-flow"))
+use(require("array"))
+use(require("patterns"))
+condition = use(require("condition"))
+
+-- combinatorial structures
 data(Doc):
   Empty
-  Beside(@left, @right, @space?)
-  Above(@above, @below, @overlap?)
-  Nest(@body, @depth)
+  Cat(@x, @y)
+  Nest(@depth, @doc)
   Text(@value)
-
-section("Documents"):
-  doc"
-    A document is a structural collection of text. The following are the \
-    various types of documents, usually created with various combinators \
-    provided below.
-  "
-
-  doc"
-    The empty document, with a height and width of \hl{0}.
-  " spec { => "Class" } for: "Empty"
-
-  doc"
-    A document comprised of two documents positioned beside each other, with \
-    an optional space in-between.
-  " spec { => "Class" } for: "Beside(@left, @right, @space?)"
-
-  doc"
-    A document comprised of two documents positioned above and below each \
-    other, optionally overlapping if possible.
-  " spec { => "Class" } for: "Above(@above, @below, @overlap?)"
-
-  doc"
-    A document indented to a given depth.
-  " spec { => "Class" } for: "Nest(@body, @depth)"
-
-  doc"
-    A document containing arbitrary text, with a height of \hl{1}.
-  " spec { => "Class" } for: "Text(@value)"
-
-  doc"
-    Trivial emptiness check. \hl{true} for \hl{Empty}, \hl{false} for \
-    everything else.
-  " spec {
-    => "Boolean"
-  } for {
-    "Doc empty?"
-
-    Doc empty? := false
-    Empty empty? := true
-  } examples:
-    "doc { empty } empty?"
-    "doc { text(\"abc\") } empty?"
-    "doc { text(\"\") } empty?"
-
-
-  doc"
-    Calculate the width of the document, in characters.
-  " spec {
-    => "Integer"
-  } for {
-    "Doc width"
-
-    Empty width := 0
-    Text width := @value size
-    Beside width :=
-      if(@space?)
-        then: 1 + @left width + @right width
-        else: @left width + @right width
-    Nest width := (@body width + @depth)
-    Above width := [@above width, @below width] max
-  } examples:
-    "doc { empty } width"
-    "doc { text(\"abc\") } width"
-
-
-  doc"
-    Calculate the height of the document, in lines.
-
-    Note that an empty document has a height of 0.
-  " spec {
-    => "Integer"
-  } for {
-    "Doc height"
-
-    Empty height := 0
-    Text height := 1
-    Beside height := [@left height, @right height] max
-    Above height :=
-      if(@overlap? && @below kind-of?(Nest)
-          && @below depth > @above width)
-        then: @above height + @below height
-        else: 1 + @above height + @below height
-    Nest height := @body height
-  } examples:
-    "doc { empty } height"
-    "doc { text(\"abc\") } height"
-
-
-  doc"
-    Render the document as a \hl{String}.
-  " spec {
-    => "String"
-  } for {
-    "Doc render"
-
-    Text render := @value
-    Empty render := ""
-    Beside render :=
-      if(@space?)
-        then: @left render + " " + @right render
-        else: @left render + @right render
-    Above render := do:
-      a = @above render
-      b = @below render
-
-      if(@overlap? && @below kind-of?(Nest) &&
-          @below depth > @above width)
+  Raw(@value)
+  Line(@space?)
+  Union(@x-thunk, @y-thunk, @prefer? = false)
+  Column(@thunk) -- @thunk is (Integer -> Doc)
+  Nesting(@thunk) -- @thunk is (Integer -> Doc)
+
+-- simple documents (used internally)
+data(SDoc):
+  SEmpty
+  SText(@value, @rest-thunk)
+  SRaw(@value, @rest-thunk)
+  SLine(@space?, @indentation, @rest-thunk)
+
+fn(inject-right(xs, i = _) &block):
+  xs reverse inject(i) [x, y]: block [y, x]
+
+-- lazy values
+def(Union x): @x ||= @x-thunk call
+def(Union y): @y ||= @y-thunk call
+def(SText rest): @rest ||= @rest-thunk call
+def(SRaw  rest): @rest ||= @rest-thunk call
+def(SLine rest): @rest ||= @rest-thunk call
+
+-- constructors
+def(Empty <> y  ): y
+def(Doc <> Empty): self
+def(Doc <> y    ): Cat new(self, y)
+
+def(Proc <|> y): Union new(self, y)
+def(Doc  <|> y): Union new({ self }, { y })
+
+def(Proc <||> y): Union new(self, y, true)
+def(Doc  <||> y): Union new({ self }, { y }, true)
+
+def(Doc nest(i)): Nest new(i, self)
+
+-- flatten a document
+def(Empty       flatten): Self empty
+def(Cat(x, y)   flatten): x flatten <> y flatten
+def(Nest(i, x)  flatten): x flatten
+def(Text(s)     flatten): Self text(s)
+def(Raw(s)      flatten): Self raw(s)
+def(Line(true)  flatten): Self text(" ")
+def(Line(false) flatten): Self empty
+def(Union       flatten): x flatten
+def(Column(f)   flatten): Self column [x]: f [x] flatten
+def(Nesting(f)  flatten): Self nesting [x]: f [x] flatten
+
+-- hanging indentation
+def(Doc hang(i)): Self align(nest(i))
+
+-- full indentation
+def(Doc indent(i)): (Self text(" " * i) <> self) hang(i)
+
+-- p punctuate([d1, d2, ..., dn]) => [d1 <> p, d2 <> p, ..., dn]
+def(Doc punctuate([])    ): []
+def(Doc punctuate([d])   ): [d]
+def(Doc punctuate(d . ds)): [d <> self] + punctuate(ds)
+
+-- sep + punctuate
+def(Doc separate(ds)): Self align(Self sep(Self punctuate(ds)))
+
+-- concatenate two documents, with a space in-between
+def(Empty <+> y    ): y
+def(Doc   <+> Empty): self
+def(Doc   <+> y    ): (self <> Self space) <> y
+
+-- concatenates two documents, with a `softline' in between
+def(Empty </> y    ): y
+def(Doc   </> Empty): self
+def(Doc   </> y    ): (self <> Self softline) <> y
+
+-- concatenates two documents, with a `suggestline' in between
+def(Empty <\> y    ): y
+def(Doc   <\> Empty): self
+def(Doc   <\> y    ): (self <> Self suggestline) <> y
+
+-- concatenates two documents, with a `softbreak' in between
+def(Empty <//> y    ): y
+def(Doc   <//> Empty): self
+def(Doc   <//> y    ): (self <> Self softbreak) <> y
+
+-- concatenates two documents, with a `suggestbreak' in between
+def(Empty <\\> y    ): y
+def(Doc   <\\> Empty): self
+def(Doc   <\\> y    ): (self <> Self suggestbreak) <> y
+
+-- concatenates two documents, with a `line' in between
+def(Empty <$> y    ): y
+def(Doc   <$> Empty): self
+def(Doc   <$> y    ): (self <> Self line) <> y
+
+-- concatenates two documents, with a `linebreak' in between
+def(Empty <$$> y    ): y
+def(Doc   <$$> Empty): self
+def(Doc   <$$> y    ): (self <> Self linebreak) <> y
+
+-- predeclare so pick-union can use it
+fn(fit)
+
+-- chose the side of a Union that best fits the given width
+fn(pick-union(w, k, i, ds, x, y, prefer?)):
+  flattened = fit(w, k, [i, x] . ds, prefer?)
+  if(flattened fits?(w - k))
+    then: flattened
+    else:
+      condition signal(.no-fit)
+      fit(w, k, [i, y] . ds, prefer?)
+
+-- helper for `best' by linearizing documents
+fn(fit(_, _, [], pref = false)): SEmpty new
+fn(fit(w, k, [i, d] . ds, pref = false)):
+  d match:
+    Empty      : fit(w, k, ds, pref)
+    Cat(x, y)  : fit(w, k, [[i, x], [i, y]] + ds, pref)
+    Nest(j, x) : fit(w, k, [i + j, x] . ds, pref)
+    Text(s)    : SText new(s, { fit(w, k + s size, ds, pref) })
+    Raw(s)     : SRaw new(s, { fit(w, k, ds, pref) })
+    Line(s)    : SLine new(s, i, { fit(w, i, ds, false) })
+    Column(f)  : fit(w, k, [i, f[k]] . ds, pref)
+    Nesting(f) : fit(w, k, [i, f[i]] . ds, pref)
+    Union:
+      if(d prefer? && !pref)
         then:
-          b slice!(0, a size)
-          a + b
-        else:
-          a + "\n" + b
-    Nest render := do:
-      b = @body render
-      x = ""
-      b each-line [l]:
-        x << " " * @depth + l
-      x
-  } examples:
-    "doc { empty } render"
-    "doc { text(\"abc\") } render"
-    "'(1 + 1) pretty render"
-
-
-section("Constructing"):
-  doc"
-    Position one document beside another, separated by a space, unless either\
-    side is empty.
-  " spec {
-    => "Doc"
-  } for {
-    "(left: Doc) <+> (right: Doc)"
-
-    (l: Doc) <+> (r: Doc) := Beside new(l, r, true)
-    (d: Doc) <+> Empty := d
-    Empty    <+> (d: Doc) := d
-    (l: Doc) <+> (n: Nest) := (l <+> n body)
-    (l: Doc) <+> (a: Above) := do:
-      first = l <+> a above
-      rest = a below nest(l width + 1)
-      Above new(first, rest, a overlap?)
-  } examples:
-    "doc { text(\"x\") <+> value(42) }"
-    "doc { empty <+> value(42) }"
-
-
-  doc"
-    Position one document beside another unless either side is empty.
-  " spec {
-    => "Doc"
-  } for {
-    "(left: Doc) <> (right: Doc)"
-
-    (l: Doc) <> (r: Doc) := Beside new(l, r, false)
-    (d: Doc) <> Empty := d
-    Empty    <> (d: Doc) := d
-    (l: Doc) <> (n: Nest) := l <> n body
-    (l: Doc) <> (a: Above) := do:
-      first = l <> a above
-      rest = a below nest(l width)
-      Above new(first, rest, a overlap?)
-  } examples:
-    "doc { text(\"x\") <> value(42) }"
-    "doc { empty <> value(42) }"
-
-
-  doc"
-    Position one document above another, unless either are empty.
-
-    If the last line of the first argument stops at least one position before\
-    the first line of the second begins, these two lines are overlapped.
-  " spec {
-    => "Doc"
-  } for {
-    "(above: Doc) // (below: Doc)"
-
-    (a: Doc) // (b: Doc) := Above new(a, b, true)
-    (a: Doc) // Empty := a
-    Empty // (b: Doc) := b
-  } examples:
-    "doc { text(\"hi\") // text(\"there\") nest(1) }"
-    "doc { text(\"hi\") // text(\"there\") nest(5) }"
-
-
-  doc"
-    Position one document above another, without overlapping, unless either \
-    are empty.
-  " spec {
-    => "Doc"
-  } for {
-    "(above: Doc) /+/ (below: Doc)"
-
-    (a: Doc) /+/ (b: Doc) := Above new(a, b, false)
-    (a: Doc) /+/ Empty := a
-    Empty /+/ (b: Doc) := b
-  } examples:
-    "doc { text(\"hi\") /+/ text(\"there\") nest(1) }"
-    "doc { text(\"hi\") /+/ text(\"there\") nest(5) }"
-
-
-  doc"
-    Indent the document to the given \hl{depth}. For \hl{Nest}, this just \
-    increases its indentation level.
-  " spec {
-    "depth is-a?(Integer)"
-    => "Doc"
-  } for {
-    "Doc nest(depth)"
-
-    Nest nest(i) := Nest new(@body, @depth + i)
-    (d: Doc) nest(i) := Nest new(d, i)
-  } examples:
-    "doc { text(\"hi\") nest(5) }"
-    "doc { text(\"hi\") nest(5) nest(6) }"
-
-
-  doc"
-    Intersperse \hl{delimiter} document through \hl{documents}.
-  " spec {
-    "documents all?(&#is-a?(Doc))"
-    => "List"
-  } for {
-    "(delimiter: Doc) punctuate(documents: List)"
-
-    Doc punctuate([]) := []
-    Doc punctuate([d]) := [d]
-    (delim: Doc) punctuate(d . ds) :=
-      (delim punctuate(ds)) unshift(d <> delim)
-  } examples:
-    "doc { semi punctuate([value(1), value(2), value(3)]) }"
-    "doc { hsep(semi punctuate([value(1), value(2), value(3)])) }"
-
-
-section("Helpers"):
-  doc"
-    Shortcut for \hl{Doc onto(&body)}. This provides the various helper \
-    methods below, which are also available in the \hl{Pretty} module.
-  " for:
-    "doc(&body)"
-    macro(doc(&body)):
-      `(Doc onto(&~body))
-
-  module(Pretty):
-    section("Shortcuts"):
-      doc"
-        These shortcuts are primarily for quickly creating \hl{Text} \
-        documents, especially for things commonly found in syntax.
-      "
-
-      doc"
-        Create a \hl{Text} document with the given contents.
-      " spec {
-        "s is-a?(String)"
-        => "Doc"
-      } for:
-        "text(s)"
-        text(s) := Text new(s)
-
-      doc"
-        Create a \hl{Text} document with \hl{x inspect}.
-      " spec {
-        => "Doc"
-      } for:
-        "value(x)"
-        value(x) := Text new(x inspect)
-
-      doc"
-        Shortcut for \hl{text(\";\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "semi"
-        semi := text(";")
-
-      doc"
-        Shortcut for \hl{text(\",\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "comma"
-        comma := text(",")
-
-      doc"
-        Shortcut for \hl{text(\":\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "colon"
-        colon := text(":")
-
-      doc"
-        Shortcut for \hl{text(\" \")}.
-      " spec {
-        => "Doc"
-      } for:
-        "space"
-        space := text(" ")
-
-      doc"
-        Shortcut for \hl{text(\"=\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "equals"
-        equals := text("=")
-
-      doc"
-        Shortcut for \hl{text(\"(\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "lparen"
-        lparen := text("(")
-
-      doc"
-        Shortcut for \hl{text(\")\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "rparen"
-        rparen := text(")")
-
-      doc"
-        Shortcut for \hl{text(\"[\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "lbrack"
-        lbrack := text("[")
-
-      doc"
-        Shortcut for \hl{text(\"]\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "rbrack"
-        rbrack := text("]")
-
-      doc"
-        Shortcut for \hl{text(\"\{\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "lbrace"
-        lbrace := text("{")
-
-      doc"
-        Shortcut for \hl{text(\"\}\")}.
-      " spec {
-        => "Doc"
-      } for:
-        "rbrace"
-        rbrace := text("}")
-
-    section("Wrapping"):
-      doc"
-        More shortcuts for common cases in pretty-printing, dealing with \
-        wrapping a document in delimiters.
-      "
-
-      doc"
-        Wrap a document in parentheses.
-      " spec {
-        => "Doc"
-      } for:
-        "parens(d)"
-        parens(d) := lparen <> d <> rparen
-
-      doc"
-        Wrap a document in brackets (\code{[]}).
-      " spec {
-        => "Doc"
-      } for:
-        "brackets(d: Doc)"
-        brackets(d) := lbrack <> d <> rbrack
-
-      doc"
-        Wrap a document in braces (\code{\{\}}).
-      " spec {
-        => "Doc"
-      } for:
-        "braces(d: Doc)"
-        braces(d) := lbrace <> d <> rbrace
-
-      doc"
-        Wrap a document in single-quotes.
-      " spec {
-        => "Doc"
-      } for:
-        "quotes(d: Doc)"
-        quotes(d) := text("'") <> d <> text("'")
-
-      doc"
-        Wrap a document in double-quotes.
-      " spec {
-        => "Doc"
-      } for:
-        "double-quotes(d: Doc)"
-        double-quotes(d) := text("\"") <> d <> text("\"")
-
-    section("Combining"):
-      doc"
-        Helpers for creating a single document from many.
-      "
-
-      doc"
-        An empty document. The identity for \hl{<>}, \hl{<+>}, \hl{//}, \
-        \hl{/+/}, and anywhere in the following methods.
-      " spec {
-        => "Doc"
-      } for:
-        "empty"
-        empty := Empty new
-
-      doc"
-        Reduce a list of documents with \hl{<>}.
-      " spec {
-        "ds all?(&#is-a?(Doc))"
-        => "Doc"
-      } for:
-        "hcat(ds)"
-        hcat(ds) := ds inject(empty) [a, b]: a <> b
-
-      doc"
-        Reduce a list of documents with \hl{<+>}.
-      " spec {
-        "ds all?(&#is-a?(Doc))"
-        => "Doc"
-      } for:
-        "hsep(ds)"
-        hsep(ds) := ds inject(empty) [a, b]: a <+> b
-
-      doc"
-        Reduce a list of documents with \hl{//}.
-      " spec {
-        "ds all?(&#is-a?(Doc))"
-        => "Doc"
-      } for:
-        "vcat(ds)"
-        vcat(ds) := ds inject(empty) [a, b]: a // b
-
-Doc extend(Pretty)
+          with-restarts(use-fit: fit(w, k, [i, d y] . ds, false)) {
+            pick-union(w, k, i, ds, d x, d y, true)
+          } bind:
+            .no-fit: condition restart(.use-fit)
+        else: pick-union(w, k, i, ds, d x, d y, pref)
+
+-- find the best configuration to fit document X in width w
+def(Doc best(w, k)): fit(w, k, [[0, self]])
+
+-- test that a document can fit in a given width
+def(SText fits?(w)): (w >= 0) && rest fits?(w - @value size)
+def(SRaw  fits?(w)): (w >= 0) && rest fits?(w)
+def(SDoc  fits?(w)): w >= 0
+
+-- rendering to a string
+def(SEmpty layout): ""
+def(SText  layout): @value + rest layout
+def(SRaw   layout): @value + rest layout
+def(SLine  layout): ("\n" + (" " * @indentation)) + rest layout
+
+-- rendering to a string
+def(Cat(x, y)  layout): x layout + y layout
+def(Empty      layout): ""
+def(Text(s)    layout): s
+def(Raw(s)     layout): s
+def(Line       layout): "\n"
+def(Union      layout): y layout
+def(Nest(i, d) layout):
+  d match:
+    Cat(x, y)  : x nest(i) layout + y nest(i) layout
+    Empty      : ""
+    Text(s)    : s
+    Raw(s)     : s
+    Line       : "\n" + (" " * i)
+    Nest(e, x) : Nest new(i + e, x) layout
+    Union      : Nest new(i, d y) layout
+
+-- trivial emptiness check
+def(Empty empty?): true
+def(Doc   empty?): false
+
+-- pretty-printing with a maximum width
+def(Doc render(width = 70)): best(width, 0) layout
+
+-- trivial constructors
+def(empty): Empty new
+def(text(s)): Text new(s to-s)
+def(raw(s)): Raw new(s to-s)
+def(line): Line new(true)
+def(linebreak): Line new(false)
+def(column &f): Column new(f)
+def(nesting &f): Nesting new(f)
+def(group(x)): { x flatten } <|> { x }
+def(preferred-group(x)): { x flatten } <||> { x }
+def(softline): group(line)
+def(softbreak): group(linebreak)
+def(suggestline): preferred-group(line)
+def(suggestbreak): preferred-group(linebreak)
+
+-- render x with the nesting level set to the current column
+def(align(x)):
+  column [k]:
+    nesting [i]:
+      x nest(k - i)
+
+-- wrap `x' in `left' and `right'
+def(enclose(left, right, x)): (left <> x) <> right
+
+-- punctuate `xs' with `delim', separating with a space, and wrapping with
+-- `left` and `right`
+def(enclose-sep(left, right, delim, xs)):
+  enclose(left, right, align(sep(delim punctuate(xs))))
+
+-- punctuate `xs' with `delim', and wrapping with `left` and `right`
+def(enclose-cat(left, right, delim, xs)):
+  enclose(left, right, align(cat(delim punctuate(xs))))
+
+-- separating lists
+def(hsep(xs)): inject-right(xs, empty) [x, y]: x <+> y
+def(vsep(xs)): inject-right(xs, empty) [x, y]: x <$> y
+def(sep(xs)): group(vsep(xs))
+def(fill-sep(xs)): inject-right(xs, empty) [x, y]: x </> y
+def(suggest-sep(xs)): inject-right(xs, empty) [x, y]: x <\> y
+
+-- concatenating lists
+def(hcat(xs)): inject-right(xs, empty) [x, y]: x <> y
+def(vcat(xs)): inject-right(xs, empty) [x, y]: x <$$> y
+def(cat(xs)): group(vcat(xs))
+def(fill-cat(xs)): inject-right(xs, empty) [x, y]: x <//> y
+def(suggest-cat(xs)): inject-right(xs, empty) [x, y]: x <\\> y
+
+-- fill a document with whitespace to width `i'
+def(fill(i, d)):
+  width(d) [w]:
+    if(w >= i)
+      then: empty
+      else: text(" " * (i - w))
+
+-- fill a document with whitespace to width `i', breaking onto a new line if
+-- the document gets too long
+def(fill-break(i, d)):
+  width(d) [w]:
+    if(w > i)
+      then: linebreak nest(i)
+      else: text(" " * (i - w))
+
+-- call `f' with the width of the passed document, and render the result
+-- after it
+def(width(d) &f):
+  column [c1]: d <> column [c2]: f [c2 - c1]
+
+-- helper documents
+def(lparen): text("(")
+def(rparen): text(")")
+def(langle): text("<")
+def(rangle): text(">")
+def(lbrace): text("{")
+def(rbrace): text("}")
+def(lbracket): text("[")
+def(rbracket): text("]")
+def(squote): text("'")
+def(dquote): text("\"")
+def(semi): text(";")
+def(colon): text(":")
+def(comma): text(",")
+def(space): text(" ")
+def(dot): text(".")
+def(backslash): text("\\")
+def(equals): text("=")
+
+-- helper for creating text from a string that may contain newlines
+def(string(s)): hcat(line punctuate(s split("\n") collect [x]: text(x)))
+
+-- wrappers
+def(parens(x)): (lparen <> x) <> rparen
+def(angles(x)): (langle <> x) <> rangle
+def(braces(x)): (lbrace <> x) <> rbrace
+def(brackets(x)): (lbracket <> x) <> rbracket
+def(squotes(x)): (squote <> x) <> squote
+def(dquotes(x)): (dquote <> x) <> dquote
+
+-- helpers for common syntax
+def(list(xs)):
+  enclose(lbracket, rbracket, align(fill-sep(comma punctuate(xs))))
+def(tupled(xs)):
+  enclose(lparen, rparen, align(fill-sep(comma punctuate(xs))))
+def(semi-braces(xs)):
+  enclose-sep(lbrace, rbrace, semi, xs)