atomy 0.1.1 → 0.6.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a5ee90eba9d13582347f3eaf9ca4dc9df87f82d
+  data.tar.gz: 36535d41525bf8bf12e3149a43ec7fc42adc9b3b
+SHA512:
+  metadata.gz: 2f1b3fcb454c9d0d98e1eb244c8b999d6db9b2bd9f4172058dbbd1ceada3ea8bd37f3d41a6fb4f2a6cf647514f9b67e066f44e9c9339cee57a9ea9aff98cdb57
+  data.tar.gz: 3eb67fcebe8d404c0acf13270e99c01604169d98222bfb979075630aaa6991d0940859eccbc7c14b1b6b6f06508834ae1d6b63431c206da30b5ba0657655fde5

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+group "test" do
+  gem "rspec"
+end
+
+group "development" do
+  gem "pry"
+  gem "benchmark-ips"
+  gem "rubinius-profiler"
+end

data/LICENSE.md

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/bin/atomy

@@ -1,134 +1,17 @@
-#!/usr/bin/env rbx
-
-base = File.expand_path "../../lib/", __FILE__
-kernel = File.expand_path "../../kernel/", __FILE__
-
-require 'readline'
-require 'optparse'
-
-require base + "/macros"
-require base + "/method"
-require base + "/util"
-require base + "/namespace"
-require base + "/compiler/compiler"
-require base + "/compiler/stages"
-require base + "/parser"
-require base + "/patterns"
-require base + "/code_loader"
-
-def require_atomy(*as)
-  before = Atomy::Namespace.get
-  begin
-    Atomy::CodeLoader.load_file *as
-  ensure
-    Atomy::Namespace.set(before)
-  end
-end
-
-options = {}
-
-unless ARGV.empty? || ARGV[0][0] != ?-
-  OptionParser.new do |o|
-    o.banner = "usage: atomy [options]"
-
-    o.on("-B", "--print-bytecode", "print out compiled bytecode") do |v|
-      options[:debug] = v
-    end
-
-    o.on("-e", "--evaluate EXPR", "evaluate EXPR and print the result") do |v|
-      options[:evaluate] = v
-    end
-
-    o.on("-s", "--before-start EXPR", "evaluate EXPR beforehand") do |v|
-      options[:start] = v
-    end
-
-    o.on("-l", "--load FILE", "load FILENAME and start the REPL") do |v|
-      options[:load] = v
-    end
-
-    o.on("-d", "--documentation DIR", "generate documentation with output to DIR") do |v|
-      Atomy::CodeLoader.documentation = v
-    end
-
-    o.on_tail("-h", "--help", "show this message") do
-      puts o
-      exit
-    end
-  end.parse!
+#!/usr/bin/env ruby
+# vim: set ft=ruby
+
+require "atomy"
+require "atomy/bootstrap"
+require "atomy/codeloader"
+require "atomy/parser"
+require "atomy/rubygems"
+
+file, *_ = ARGV
+
+if file
+  Atomy::CodeLoader.run_script(File.expand_path(file))
+else
+  repl = Atomy::CodeLoader.require("repl")
+  repl.repl
 end
-
-a = Time.now
-puts "loading kernel"
-require_atomy(kernel + "/boot.ay")
-puts Time.now - a
-
-Atomy::Namespace.ensure(:user)
-
-def run_atomy(options)
-  if str = options[:evaluate] || options[:start]
-    $0 = "(eval)"
-    res = Atomy::Compiler.evaluate(
-      str,
-      nil,
-      "(eval)",
-      1,
-      options[:debug]
-    )
-
-    if options[:evaluate]
-      res.send(Atomy.namespaced("atomy", "write").to_sym)
-      return
-    end
-  end
-
-  if file = options[:load] || ARGV[0]
-    $0 = file
-    require_atomy(file, ARGV[0] ? :run : :load, options[:debug])
-    return if ARGV[0]
-  end
-
-  if respond_to?(Atomy.namespaced("atomy", "repl").to_sym, true)
-    send(Atomy.namespaced("atomy", "repl").to_sym, File.expand_path("~/.atomy_history"))
-  else
-    $stderr.puts("main REPL startup failed! here's a basic one:")
-
-    history_file = File.expand_path("~/.atomy_history")
-
-    if File.exists?(history_file)
-      File.open(history_file, "r") do |f|
-        f.readlines.each do |l|
-          Readline::HISTORY << l.strip
-        end
-      end
-    end
-
-    begin
-      sane_history = []
-      while str = Readline.readline("> ")
-        next if str.empty?
-
-        sane_history << str
-
-        begin
-          res = Atomy::Compiler.evaluate str, TOPLEVEL_BINDING
-          if res.respond_to?(:pretty)
-            puts "=> #{res.pretty.render}"
-          else
-            puts "=> #{res.inspect}"
-          end
-        rescue StandardError => e
-          puts "ERROR!"
-          puts "#{e}:\n  #{e.message}"
-          puts e.backtrace
-        end
-      end
-    ensure
-      File.open(history_file, "a") do |f|
-        f.puts(*sane_history)
-      end
-    end
-  end
-end
-
-run_atomy(options)

data/kernel/array.ay

@@ -0,0 +1,6 @@
+use(require("core"))
+use(require("patterns"))
+
+pattern(~x . ~ys): pattern(`[~x, *~ys])
+
+macro(~x . ~ys): `([~x] + ~ys)

data/kernel/atomy.ay

@@ -0,0 +1,18 @@
+export(
+  require("core")
+  require("patterns")
+  require("define")
+  require("loop")
+  require("data")
+  require("array")
+  require("quotes")
+  require("interpolation")
+  require("regexp")
+  require("hash")
+  require("dynamic")
+  require("condition")
+  require("particles")
+  require("range")
+  require("io")
+  require("control-flow")
+  require("file"))

data/kernel/condition.ay

@@ -1,277 +1,177 @@
-namespace(atomy)
+use(require("core"))
+define = use(require("define"))
+use(require("data"))
+use(require("control-flow"))
+use(require("interpolation"))
+use(require("patterns"))
 
-title"Condition System"
+use(require("dynamic"))
 
-doc"
-  Rather than traditional exceptions, Atomy sports a condition/restart \
-  system modeled on Common Lisp's design. The native Ruby exception handling \
-  is available, but conditions and restarts are much more flexible.
-"
+io = use(require("io"))
+loaded-pretty = nil
+fn(pretty): &loaded-pretty = (loaded-pretty || require("pretty"))
+
+require("atomy/message_structure")
+
+data(Handler(@callback, @rest)):
+  BaseHandler()
 
 -- registered handlers/restarts
-dynamic(handlers, [])
-dynamic(restarts, [])
+const-set(.Handlers, dynamic(BaseHandler new))
+const-set(.Restarts, dynamic([]))
+
+fn(catcher(x)): ."restart:#{Atomy MessageStructure new(x) name}"
+
+data(Restart(@name, @action))
+
+def(Restart invoke(*args)):
+  throw(."restart:#{@name}", @action [*args])
+
+data(Condition):
+  Error(@backtrace):
+    SimpleError(@value)
+    ExceptionError(@exception)
+    NoRestartError(@restart)
+    PortError(@port):
+      EndOfFile
+
+  Warning(@backtrace):
+    SimpleWarning(@value)
+
+def(Condition name): class name
+
+def(ExceptionError name): @exception class name
+
+def(Condition message): inspect
+
+def(SimpleError(s & String) message): s
+def(SimpleError(v) message): pretty show(v)
+
+def(SimpleWarning(s & String) message): s
+def(SimpleWarning(v) message): pretty show(v)
+
+def(ExceptionError message): @exception message
+
+def(NoRestartError message): "unknown restart " + pretty show(@restart)
+
+def(EndOfFile message): "unexpected end-of-file for " + pretty show(@port)
+
+
+macro(~body bind: ~*handlers):
+  callback = `([signalled-condition]: signalled-condition match: ~*handlers)
+
+  `(with(Handlers = Handler new(~callback, ^Handlers)):
+      ~body rescue:
+        (e & StandardError): Self error(e))
+
+
+macro(with-restarts(~*restarts): ~*body):
+  branches = restarts collect [`(~name: ~*body)]:
+    [name, `(do: ~*body)]
+
+  rs = branches collect [n, e]:
+    structure = Atomy MessageStructure new(n)
+
+    `(Restart new(
+        ~(Atomy Code Symbol new(structure name))
+        [~*(structure arguments)] &~(structure proc-argument || 'nil) { ~e }))
+
+  with =
+    branches reduce(`{ do { ~*body } rescue: (e & StandardError): Self error(e) })
+      [x, [name, _]]:
+        `{ catch(~(Atomy Code Symbol new(catcher(name)))) ~x }
+
+  `(with(Restarts = ([~*rs] + ^Restarts)) ~with)
+
+
+def(restart(name, *args)):
+  ^Restarts each [r]:
+    when(r name == name):
+      r invoke(*args)
+
+  error(NoRestartError new(name))
 
-for-macro:
-  catcher(x) :=
-    Atomy::AST::Variable new(x line) $:
+
+def(BaseHandler signal(_)): nil
+def(Handler(callback, rest) signal(c)):
+  with(Handlers = rest):
+    callback [c]
+    rest signal(c)
+
+def(signal(c)): ^Handlers signal(c)
+
+def(error(x)):
+  e =
+    x match:
+      Exception:
+        ExceptionError new(x) tap [err]:
+          err backtrace = x locations
+
+      Error: x
+
+      _: SimpleError new(x)
+
+  unless(e backtrace):
+    e backtrace = Rubinius VM backtrace(1, true)
+
+  signal(e)
+
+  with-output-to(^(io ErrorPort)):
+    ^Debugger new(e) run
+
+
+def(warning(x)):
+  with-restarts(muffle-warning: nil):
+    w =
       x match:
-        Atomy::AST::Variable ->
-          "restart:" + x name
-
-        Atomy::AST::Send ->
-          "restart:" + x method-name
-
-data(Object):
-  Restart(@name, @action)
-
-Restart invoke(*args) :=
-  throw(("restart:" + @name to-s) to-sym, @action [*args])
-
-symbols(signal, warning, error, restart)
-
-section("Conditions"):
-  doc"
-    Condition system hierarchy. You should subclass one of these to create \
-    your own conditions.
-  " for:
-    data(Object):
-      Condition:
-        Error(@backtrace):
-          SimpleError(@value)
-          ExceptionError(@exception)
-          NoRestartError(@name)
-          PortError(@port):
-            EndOfFile
-
-        Warning(@backtrace):
-          SimpleWarning(@value)
-
-  doc"
-    Get the name of a condition. By default, this will be the class name, \
-    but you may override this for your own behaviour.
-  " for:
-    Condition name := class name
-
-    ExceptionError name := @exception class name
-
-  doc"
-    A human-friendly message displayed for the condition. Override this.
-  " for:
-    Condition message := inspect
-
-    SimpleError message := @value to-s
-    ExceptionError message := @exception message
-    SimpleWarning message := @value to-s
-    NoRestartError message := "unknown restart " + @name show
-    EndOfFile message := "unexpected end-of-file for " + @port show
-
-
-section("Handling"):
-  doc"
-    Invoke the \hl{name} restart, passing \hl{args} along to its callback.
-
-    See \hl{with-restarts}.
-  " spec {
-    name is-a?(Symbol)
-    => any
-  } for {
-    restart(name, *args) := do:
-      ^restarts each [r]:
-        when(r name == name):
-          r invoke(*args)
-
-      error(NoRestartError new(name))
-  } examples:
-    { with-restarts(foo -> 42):
-        signal(#bar)
-    } bind: #bar -> restart(#foo)
-
-
-  doc"
-    Register handlers for various signals for the duration of \hl{x}'s \
-    execution.
-
-    The body of \hl{y} is similar to \hl{match}; \hl{\italic{pattern} -> \
-    \italic{body}}.
-
-    The result is the result of \hl{body}.
-  " spec {
-    y contents all? [x]: x match { `(~_ -> ~_) -> true, _ -> false }
-    => any
-  } for {
-    macro(body bind(&y)):
-      names [a]:
-        callback = `([~a]: ~a match: ~*(y contents))
-        `(let(handlers = ^handlers + [~callback]):
-            ~body rescue:
-              (e: StandardError) -> error(e))
-  } examples:
-    { signal(#a) } bind: #a -> "got A!" print
-    { signal(#b) } bind: #a -> "got A!" print
-    { { signal(#a) } bind: #a -> "inner" print } bind: #a -> "outer" print
-
-
-  doc"
-    Register restarts available for the duration of \hl{body}'s execution.
-
-    The \hl{restarts} should be in the form of \
-    \hl{\italic{name}(*\italic{args}) -> \italic{body}}.
-
-    The result is the result of \hl{body}.
-  " spec {
-    => any
-  } for {
-    macro(with-restarts(*restarts, &block)):
-      rs = restarts collect [`(~n -> ~e)]:
-        n match:
-          Atomy::AST::Variable ->
-            `(Restart new(#~n, { ~e }))
-
-          Atomy::AST::Send -> do:
-            name = Atomy::AST::Variable new(0, n method-name)
-            `(Restart new(#~name, [~*(n arguments)] { ~e }))
-
-      body =
-        restarts reduce(
-          `{ ~block rescue: (e: StandardError) -> error(e) }
-        ) [x, `(~name -> ~_)]:
-          `{ catch(#~catcher(name), &~x) }
-
-      `(let(restarts = [~*rs] + ^restarts, &~body))
-  } examples:
-    { with-restarts(x -> 1, y -> 2):
-        signal(#a)
-    } bind: #a -> restart(#x)
-
-    { with-restarts(x -> 1, y -> 2):
-        signal(#a)
-    } bind: #a -> restart(#y)
-
-    { with-restarts(x(a) -> a * 7):
-        signal(#a)
-    } bind: #a -> restart(#x, 6)
-
-
-section("Signalling"):
-  doc"
-    Signal a value through all bound handlers, nearest-first, stopping when \
-    a restart is invoked.
-  " spec {
-    => nil
-  } for {
-    signal(c) := do:
-      ^handlers reverse-each [callback]:
-        callback [c]
-
-      nil
-  } examples:
-    signal(#foo)
-    { signal(#foo) } bind: #foo -> "got foo" print
-
-
-  doc"
-    Like \hl{signal}, except that if no restart is invoked, the current \
-    \hl{^debugger} is started.
-
-    If the given value is not an \hl{Error}, it is wrapped in a \
-    \hl{SimpleError}. If the value is a Ruby \hl{Exception}, it is wrapped \
-    in an \hl{ExceptionError}.
-  " spec {
-    => _
-  } for {
-    error(x) := do:
-      e =
-        x match:
-          Exception ->
-            ExceptionError new(x) tap [err]:
-              err backtrace = x locations
-
-          Error ->
-            x tap [err]:
-              err backtrace = Rubinius::VM backtrace(0)
-
-          _ ->
-            SimpleError new(x) tap [err]:
-              err backtrace = Rubinius::VM backtrace(0)
-
-      signal(e)
-
-      with-output-to(^error-port):
-        ^debugger run(e)
-  } examples:
-    error("Oh no!")
-    { error("Oh no!") } bind: Error -> "INCOMING" print
-
-
-  doc"
-    Like \hl{signal}, except that if no restart is invoked, the warning is \
-    printed to \hl{^error-port}.
-
-    If the given value is not a \hl{Warning}, it is wrapped in a \
-    \hl{SimpleWarning}. Warning messages can be muffled by binding for \
-    \hl{Warning} and invoking the \hl{#muffle-warning} restart.
-  " spec {
-    => nil
-  } for {
-    warning(x) :=
-      with-restarts(muffle-warning -> nil):
-        w =
-          x match:
-            Warning ->
-              x tap [wrn]:
-                wrn backtrace = Rubinius::VM backtrace(0)
-
-            _ ->
-              SimpleWarning new(x) tap [wrn]:
-                wrn backtrace = Rubinius::VM backtrace(0)
-
-        signal(w)
-
-        with-output-to(^error-port):
-          (w name + ": " + w message) print
-
-        nil
-  } examples:
-    warning("Suspicious!")
-    { warning("Quiet, you!") } bind: Warning -> restart(#muffle-warning)
-
-
-section("Debuggers"):
-  doc"
-    The default debugger. This will show the condition name, its message, \
-    and let the user pick from the available restarts.
-  " for:
-    class(DefaultDebugger):
-      class(<< self):
-        define(show-error-banner(e)):
-          ("-" * 78) print
-          (e name + ": " + e message) each-line [l]:
-            ("*** " + l) display
-
-          "\n" display
-
-        define(show-options-for(e)):
-          when(^restarts empty?):
-            exit(1)
-
-          "\n" display
-          "restarts:" print
-          ^restarts each-with-index [r, i]:
-            ("  :" + i to-s + " -> " + r name to-s) print
-
-        define(run(e)):
-          show-error-banner(e)
-
-          show-options-for(e)
-
-          "!> " display
-          ^restarts [gets to-i] invoke
-
-  doc"
-    The current debugger. \hl{run} will be called with the condition as an \
-    argument.
-  " spec {
-    respond-to?(#run)
-  } for:
-    dynamic(debugger, DefaultDebugger)
+        Warning: x
+
+        _: SimpleWarning new(x)
+
+    w backtrace = Rubinius VM backtrace(1, true)
+
+    signal(w)
+
+    with-output-to(^(io ErrorPort)):
+      puts(i"#{w name}: #{w message}")
+
+    nil
+
+
+data(DefaultDebugger(@error))
+
+def(DefaultDebugger(e) show-banner):
+  puts("An error occurred:")
+
+  [msg, *desc] = e message to-s split("\n")
+
+  puts(i"    #{msg} (#{e name})")
+
+  desc each [l]:
+    puts(l)
+
+def(DefaultDebugger(e) show-restarts):
+  puts("")
+  puts("restarts:")
+  ^Restarts each-with-index [r, i]:
+    puts(i"  :#{i} -> #{r name}")
+
+def(DefaultDebugger(e) show-backtrace):
+  puts(Rubinius Backtrace backtrace(e backtrace) show)
+
+def(DefaultDebugger(e) run):
+  show-banner
+
+  if(^Restarts empty?)
+    then:
+      puts("")
+      puts("Backtrace:")
+      show-backtrace
+      exit(1)
+    else:
+      show-restarts
+
+      print("!> ")
+      ^Restarts [gets to-i] invoke
+
+const-set(.Debugger, dynamic(DefaultDebugger))