atomy 0.1.1

data/kernel/format/parser.ay

@@ -0,0 +1,13 @@
+namespace(atomy/format)
+
+module(Atomy::Format):
+  require(File expand-path("../../../lib/formatter.kpeg.rb", _FILE))
+
+  class(Parser):
+    class(<< self):
+      parse(source) :=
+        new(source) onto:
+          unless(parse):
+            raise-error
+
+          result

data/kernel/hashes.ay

@@ -0,0 +1,39 @@
+namespace(atomy)
+
+macro(#(l: List)):
+  keys = []
+  values = []
+
+  l elements each [p]:
+    p match:
+      `(~k -> ~v) -> do:
+        keys << k
+        values << v
+
+      Atomy::AST::Send -> do:
+        while(p respond-to?(#block) && p block):
+          keys << Atomy::AST::Particle new(p line, p method-name)
+          values << p block contents first
+          p =! p receiver
+
+  Atomy::AST::Hash new(line, keys, values)
+
+export:
+  class(Atomy::AST::Hash < Atomy::AST::Node):
+    children([#keys], [#values])
+    generate
+
+    bytecode(g) := do:
+      pos(g)
+
+      g push-cpath-top
+      g find-const(#Hash)
+      g push-int(@keys size)
+      g send(#new-from-literal, 1)
+
+      @keys each-with-index [n, i]:
+        g dup
+        n compile(g)
+        @values [i] compile(g)
+        g send("[]=" to-sym, 2)
+        g pop

data/kernel/io.ay

@@ -0,0 +1,244 @@
+namespace(atomy)
+
+-- condition kernel not loaded yet; predeclare this
+symbols(error)
+
+title"Input & Output"
+
+doc"Where to write normal output." for:
+  dynamic(output-port, $stdout)
+
+doc"Where to read input from." for:
+  dynamic(input-port, $stdin)
+
+doc"Where to write error/warning output." for:
+  dynamic(error-port, $stderr)
+
+section("Output"):
+  doc"
+    Write \hl{x to-s} to \hl{^output-port}, followed by a linebreak.
+  " spec {
+    => x
+  } for {
+    x print := x tap: ^output-port puts(x to-s)
+  } examples:
+    1 print
+    "hello" print
+
+  doc"
+    Write \hl{x to-s} to \hl{^output-port}.
+  " spec {
+    => x
+  } for {
+    x display := x tap: ^output-port send(#print, x to-s)
+  } examples:
+    1 display
+    "hello" display
+
+  doc"
+    Write \hl{x show} to \hl{^output-port}.
+  " spec {
+    => x
+  } for {
+    x write := x tap: ^output-port puts(x show)
+  } examples:
+    1 write
+    "hello" write
+
+  doc"
+    Set \hl{^output-port} to write output to \hl{filename} for the duration \
+    of \hl{action}, ensuring that the file is closed.
+
+    Returns the result of \hl{action}.
+  " spec {
+    filename is-a?(String)
+    mode is-a?(String)
+    => any
+  } for {
+    with-output-to((filename: String), mode = "w", &action) :=
+      let(output-port = File open(filename, mode)):
+        action ensuring:
+          ^output-port close
+  } examples:
+    with-output-to("foo"):
+      42 print
+
+    with-output-to("foo", "a"):
+      "hello" print
+
+    File open("foo", &#read)
+
+  doc"
+    Set \hl{^output-port} to write to \hl{io} for the duration of \hl{action}.
+
+    Returns the result of \hl{action}.
+  " spec {
+    => any
+  } for {
+    with-output-to(io, &action) :=
+      let(output-port = io, &action)
+  } examples:
+    require("stringio")
+    x = StringIO new
+    with-output-to(x):
+      "hello!" write
+    x string
+
+  doc"
+    Set \hl{^error-port} to write error output to \hl{filename} for the \
+    duration of \hl{action}, ensuring that the file is closed.
+
+    Returns the result of \hl{action}.
+  " spec {
+    filename is-a?(String)
+    mode is-a?(String)
+    => any
+  } for {
+    with-error-to((filename: String), mode = "w", &action) :=
+      let(error-port = File open(filename, mode)):
+        action ensuring:
+          ^error-port close
+  } examples:
+    with-error-to("foo", "a"):
+      warning(#some-warning)
+
+    File open("foo", &#read)
+
+  doc"
+    Set \hl{^error-port} to write to \hl{io} for the duration of \hl{action}.
+
+    Returns the result of \hl{action}.
+  " spec {
+    => any
+  } for {
+    with-error-to(io, &action) :=
+      let(error-port = io, &action)
+  } examples:
+    require("stringio")
+    x = StringIO new
+
+    with-error-to(x):
+      warning(#foo)
+
+    x string
+
+section("Input"):
+  doc"
+    Read a line of text from \hl{^input-port}, signalling \hl{EndOfFile} on \
+    end of file. Lines are separated by \hl{sep}. A separator of \hl{nil} \
+    reads the entire contents, and a zero-length separator reads the input \
+    one paragraph at a time (separated by two linebreaks).
+  " spec {
+    => String
+  } for {
+    read-line(sep = $separator) := do:
+      x = ^input-port gets(sep)
+
+      unless(x):
+        error(EndOfFile new(^input-port))
+
+      x
+  } examples:
+    with-input-from("foo"):
+      read-line
+
+  doc"
+    Read all lines of text from \hl{^input-port}. Lines are separated by \
+    \hl{sep}. A separator of \hl{nil} reads the entire contents as one \
+    segment, and a zero-length separator reads the input one paragraph at a \
+    time (separated by two linebreaks).
+  " spec {
+    => String
+  } for {
+    read-lines(sep = $separator) := do:
+      x = ^input-port readlines(sep)
+
+      unless(x):
+        error(EndOfFile new(^input-port))
+
+      x
+  } examples:
+    with-input-from("foo"):
+      read-lines
+
+  doc"
+    Read a single byte from \hl{^input-port}, signalling \hl{EndOfFile} on \
+    end of file.
+  " spec {
+    => Integer
+  } for {
+    read-byte := do:
+      x = ^input-port getc
+
+      unless(x):
+        error(EndOfFile new(^input-port))
+
+      x
+  } examples:
+    with-input-from("foo"):
+      read-byte
+
+  doc"
+    Same as \hl{read-byte chr}.
+  " spec {
+    => String
+  } for {
+    read-char := read-byte chr
+  } examples:
+    with-input-from("foo"):
+      read-char
+
+  doc"
+    Read at most \hl{length} bytes from \hl{^input-port}, or to the end of \
+    file if \hl{length} is \hl{nil}. If \hl{buffer} is given, the data read \
+    will be written to it.
+  " spec {
+    length nil? || length >= 0
+    buffer nil? || buffer is-a?(String)
+    => String || buffer || nil
+  } for {
+    read(length = nil, buffer = nil) :=
+      ^input-port send(#read, length, buffer)
+  } examples:
+    x = ""
+    with-input-from("foo"):
+      read(10)
+
+    with-input-from("foo"):
+      read(10, x)
+
+    x
+
+  doc"
+    Set \hl{^input-port} to read input from \hl{filename} for the duration \
+    of \hl{action}, ensuring that the file is closed.
+
+    Returns the result of \hl{action}.
+  " spec {
+    filename is-a?(String)
+    mode is-a?(String)
+    => any
+  } for {
+    with-input-from((filename: String), mode = "r", &action) :=
+      let(input-port = File open(filename, mode)):
+        action ensuring:
+          ^input-port close
+  } examples:
+    with-input-from("foo"):
+      read-line
+
+  doc"
+    Set \hl{^input-port} to write to \hl{io} for the duration of \hl{action}.
+
+    Returns the result of \hl{action}.
+  " spec {
+    => any
+  } for {
+    with-input-from(io, &action) :=
+      let(input-port = io, &action)
+  } examples:
+    require("stringio")
+    x = StringIO new("hello\ngoodbye\n")
+
+    with-input-from(x):
+      read-line

data/kernel/namespaces.ay

@@ -0,0 +1,63 @@
+macro(namespace(n: Variable)):
+  `(evaluate-when(compile, run, load):
+      Atomy::Namespace ensure(#~n))
+
+macro(let-when(when, *bindings, &b)):
+  tmps = names(bindings size)
+  save = []
+  set = []
+  restore = []
+
+  bindings zip(tmps) [[`(~n = ~v), tmp]]:
+    save << `(Atomy::STATE [#~tmp] = ^~n)
+    set << set-dynvar(n, v)
+    restore << set-dynvar(n, `(Atomy::STATE delete(#~tmp)))
+
+  names [res]:
+    `(let(~*bindings):
+        evaluate-when(~when):
+          ~*save
+          ~*set
+
+        ~res = ~(b body)
+
+        evaluate-when(~when):
+          ~restore
+
+        ~res)
+
+macro(in-namespace(n, &b)):
+  `(do:
+      evaluate-when(load):
+        Atomy::Namespace create(#~n)
+
+      let-when(compile, namespace = Atomy::Namespace ensure(#~n)):
+        ~(b body))
+
+macro(no-namespace(&b)):
+  `(let-when(compile, namespace = nil):
+      ~(b body))
+
+macro(export(&b)):
+  `(let-when(compile, define-in = "_"):
+      ~(b body))
+
+macro(export-to(n, &b)):
+  `(let-when(compile, define-in = ~(n name)):
+      ~(b body))
+
+macro(use(*ns)):
+  current = Atomy::Namespace get
+  where = current && current name
+
+  `(evaluate-when(compile, run, load):
+      ~*(ns collect [n]:
+          `(Atomy::Namespace get(~where) use(#~n))))
+
+macro(symbols(*ns)):
+  current = Atomy::Namespace get
+  where = current && current name
+
+  `(evaluate-when(compile, run, load):
+      ~*(ns collect [n]:
+          `(Atomy::Namespace register(#~n, ~where))))

data/kernel/node.ay

@@ -0,0 +1,48 @@
+namespace(atomy)
+
+export:
+  module(Atomy::AST):
+    '_ pattern :=
+      Atomy::Patterns::Any new
+
+    `(~h . ~t) pattern :=
+      Atomy::Patterns::HeadTail new(h to-pattern, t to-pattern)
+
+    `(~p = ~d) pattern :=
+      Atomy::Patterns::Default new(p to-pattern, d)
+
+    `(? ~t) pattern :=
+      Atomy::Patterns::Predicate new(Atomy::Patterns::Any new, t)
+
+    `(~p ? ~t) pattern :=
+      Atomy::Patterns::Predicate new(p to-pattern, t)
+
+    `(~a & ~b) pattern :=
+      Atomy::Patterns::And new(a to-pattern, b to-pattern)
+
+    `(~a | ~b) pattern :=
+      Atomy::Patterns::Or new(a to-pattern, b to-pattern)
+
+    `(with(~attr, ~p)) pattern :=
+      Atomy::Patterns::With new(attr, p to-pattern)
+
+    `@@~n pattern :=
+      Atomy::Patterns::NamedClass new(n name)
+
+    `$~n pattern :=
+      Atomy::Patterns::NamedGlobal new(n name)
+
+    `@~n pattern :=
+      Atomy::Patterns::NamedInstance new(n name)
+
+    `%~x pattern :=
+      Atomy::Patterns::RuntimeClass new(x, nil)
+
+    `&~x pattern :=
+      Atomy::Patterns::BlockPass new(x to-pattern)
+
+    `*~x pattern :=
+      Atomy::Patterns::Splat new(x to-pattern)
+
+    `(Particle [~*as]) pattern :=
+      Atomy::Patterns::List new(as collect [a]: a to-pattern)

data/kernel/operators.ay

@@ -0,0 +1,28 @@
+-- defining & assigning
+operator right 0 = := **= *= <<= >>= &&=
+                 &= ||= |= += -= /= ^= %=
+
+-- association
+operator right 1 <- ->
+
+-- predicate pattern
+operator right 2 ?
+
+-- ranges
+--operator 1 .. ...
+
+-- comparison
+operator 5 <=> < <= >= >
+operator 4 == !=
+operator 3 &&
+operator 2 ||
+
+-- math
+operator right 12 **
+operator 10 % * /
+operator 9 + -
+
+-- bitwise and shifting
+operator 8 << >>
+operator 6 ^ |
+operator 7 &

data/kernel/particles.ay

@@ -0,0 +1,53 @@
+namespace(atomy)
+
+for-macro:
+  wildcard('_) := '_undefined
+  wildcard(x) := x
+
+macro(#(x: Send)):
+  `(Particle [
+      ~(if(x private)
+          then: '_undefined
+          else: wildcard(x receiver))
+      ~(Atomy::AST::Particle new(0, x method-name))
+      ~*(x arguments collect [c]: wildcard(c))
+    ])
+
+macro(#(x: BinarySend)):
+  `(Particle [
+      ~(if(x private)
+          then: '_undefined
+          else: wildcard(x lhs))
+      ~(Atomy::AST::Particle new(0, x operator))
+      ~(wildcard(x rhs))
+    ])
+
+export:
+  class(Particle < Array):
+    call(*args) := to-proc [*args]
+
+    to-proc := [*args]:
+      x = dup
+
+      args each [a]:
+        idx = x find-index [a]:
+          a equal?(_undefined)
+
+        when(idx):
+          x [idx] = a
+
+      x first send(*(x drop(1)))
+
+    arity :=
+      select(&#equal?(_undefined)) size
+
+    receiver := at(0)
+
+    message := at(1)
+
+    arguments := drop(2)
+
+class(Symbol):
+  call(*args) := to-proc [*args]
+
+  arity := 1