rquark 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b708c25549f1eec79d6d5b856110b96e0e2565fc
+  data.tar.gz: c57594b3c62fa984da21a8e52cf87d75356efed5
+SHA512:
+  metadata.gz: 89954af0306b8dbea34f9ea97634556d4304644d6c2db63f91bac81f94462b3894611609413b209124359e88f52c28587da7fe741da5679e517ced5725bf1456
+  data.tar.gz: c956ac76e8b1c68b35edb6411ad5dc58d45ae6276da334ffbf8343ba16ac47429c8cee8f52e5eea324bb474bab299e247fa5f76e261d13a3cd79959dc45ba272

data/bin/rquark

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/qrun'
+
+
+# setup base vm
+base_vm = QVM.new([], [], {})
+unless ARGV.include? '--only-core'
+  base_vm = qrun(File.read File.expand_path('../../lib/prelude.qrk', __FILE__))
+end
+
+# get script filenames
+script_names = ARGV.select { |a| a[0] != '-' }
+
+# run either REPL or scripts
+if script_names.empty?
+  qrepl base_vm
+else
+  script_names.each do |s|
+    qrun(File.read(s), base_vm.stack.dup, base_vm.bindings.dup)
+  end
+end

data/lib/prelude.qrk

@@ -0,0 +1,118 @@
+
+[ x | ] :drop def
+
+[ drop ] :comment def
+
+
+"## Handy Macros ##" comment
+
+[ q n | [ q match ] n def ] :mdef def
+
+[ call ] :; def
+
+
+"## Stack Manipulation Operators ##" comment
+
+[ x | x x ] :dup def
+
+[ x y | y x ] :swap def
+
+[ x y | y ] :nip def
+
+[ x y | x y x ] :dipdup def
+
+[ x y z | z x y ] :rot def
+
+[ x y z | y z x ] :-rot def
+
+[[ x | clear ]] :clear mdef
+
+
+"## Combinators ##" comment
+
+[ x y f | x f call y ] :dip def
+
+[ x y z f | x y f call z ] :double-dip def
+
+[ w x y z f | w x y f call z ] :triple-dip def
+
+[ x fa fb | x fa call x fb call ] :bi def
+
+[ x fa fb fc | x fa call a fb call x fc call ] :tri def
+
+[ q fa fb | q call fa call q call fb call ] :q-bi def
+
+[ x y fx fy | x fx call y fy call ] :bi-call def
+
+[ x y z fx fy fz | x fx call y fy call z fz call ] :tri-call def
+
+
+"## Numeric Operators ##" comment
+
+[ -1 * + ] :- def
+
+[ 1 + ] :++ def
+
+[ -1 + ] :-- def
+
+[ 1 swap [ [ dup ] dip * ] times-do swap drop ] :^ def
+
+[ swap < ] :> def
+
+[ x y | [ x y ] [<] [=] q-bi or ] :<= def
+
+[ x y | [ x y ] [>] [=] q-bi or ] :>= def
+
+
+"## String Operators ##" comment
+
+[ "" [ weld ] fold ] :multiWeld def
+
+
+"## Boolean Operators ##" comment
+
+[ x x | :true ] := def
+
+[ :true :true | :true ] :and def
+
+[[ :true x | :true ] [ x :true | :true ]] :or mdef
+
+[[ :true | :nil ] [ x | :true ]] :not mdef
+
+[ = not ] :!= def
+
+[ x y | [ x y ] [!=] [or] q-bi and ] :xor mdef
+
+
+"## Control Flow ##" comment
+
+[[ :true x | x call ] [ z x | ]] :if mdef
+
+[[ :true x y | x call ] [ z x y | y call ]] :if-else mdef
+
+[[ 0 f | ] [ n f | f call n 1 - f times-do ]] :times-do mdef
+
+[ p f | p call not [ f call p f while ] if ] :while def
+
+
+"## Quote Functions ##" comment
+
+[ @- drop ] :pattern def
+
+[ @- nip ] :body def
+
+[ @- swap >> [ swap @+ ] dip ] :@> def
+
+[ q x | q @- swap x << swap @+ ] :<@ def
+
+[[ [] x f | x ] [ xs x f | xs >> x f call f fold ]] :fold mdef
+
+[[ [] f | [] ] [ xs f | xs >> [ f map ] dip f call << ]] :map mdef
+
+[ [] [ swap << ] fold ] :reverse def
+
+[ reverse [ swap << ] fold reverse ] :concat def
+
+[ [] rot [ dup [ << ] dip ++ ] times-do drop ] :range def
+
+[ 1 swap range ] :iota def

data/lib/qeval.rb

@@ -0,0 +1,178 @@
+require 'qtypes'
+
+## Boilerplate ##
+
+QuarkError = Class.new(RuntimeError)
+
+$core_func = {}
+$core_func_type = {}
+
+def def_cf(name, type_sig, &code)
+  $core_func_type[name] = type_sig
+  $core_func[name] = code
+end
+
+def apply_core_func(name, vm, eval_func)
+  eq, expected, got = type_check(vm.stack, $core_func_type[name])
+  raise(QuarkError, "Type error with function #{name}\n  expected a stack of #{expected}\n  but got #{got}") if not eq
+  $core_func[name].call(vm, eval_func)
+end
+
+def apply_runtime_func(name, vm)
+  quote = vm.bindings[name]
+  vm.program.unshift(*[quote, QAtom.new('call')])
+end
+
+def pattern_match(stack_args, args)
+  return false if stack_args.length < args.length
+  return {} if args.length == 0
+  bindings = {}
+  args.zip(stack_args).each do |a, s|
+    if a.is_a? QAtom
+      return false if (bindings.has_key? a.val) && (bindings[a.val] != s)
+      bindings[a.val] = s
+    else
+      return false if a != s
+    end
+  end
+  return bindings
+end
+
+def deep_clone x
+  Marshal.load(Marshal.dump(x))
+end
+
+
+## Quark Core Functions ##
+
+def_cf('+', [:Num, :Num]) do |vm|
+  vm.stack.push QNum.new(vm.stack.pop.val + vm.stack.pop.val)
+end
+
+def_cf('*', [:Num, :Num]) do |vm|
+  vm.stack.push QNum.new(vm.stack.pop.val * vm.stack.pop.val)
+end
+
+def_cf('/', [:Num, :Num]) do |vm|
+  vm.stack.push QNum.new(vm.stack.pop.val / vm.stack.pop.val)
+end
+
+def_cf('<', [:Num, :Num]) do |vm|
+  smaller_than = vm.stack.pop.val > vm.stack.pop.val
+  vm.stack.push QSym.new(smaller_than ? 'true' : 'nil')
+end
+
+def_cf('print', [:Str]) do |vm|
+  print vm.stack.pop.val
+end
+
+def_cf('.', []) do |vm|
+  puts vm.stack.join(' ')
+end
+
+def_cf('>>', [:Quote]) do |vm|
+  vm.stack.push vm.stack.last.pop
+end
+
+def_cf('<<', [:Quote, :Any]) do |vm|
+  vm.stack[-2].push vm.stack.pop
+end
+
+def_cf('@+', [:Quote, :Quote]) do |vm|
+  q1, q2 = vm.stack.pop(2)
+  vm.stack.push QQuote.new q1.body, q2.body
+end
+
+def_cf('@-', [:Quote]) do |vm|
+  q = vm.stack.pop
+  vm.stack.push QQuote.new [], q.pattern
+  vm.stack.push QQuote.new [], q.body
+end
+
+def_cf('show', [:Any]) do |vm|
+  vm.stack.push QStr.new(vm.stack.pop.to_s)
+end
+
+def_cf('call', [:Quote]) do |vm|
+  quote = vm.stack.pop
+  args = vm.stack.pop(quote.pattern.length)
+  if bindings=pattern_match(args, quote.pattern)
+    vm.program.unshift(*quote.bind(bindings).body)
+  else vm.stack.push QSym.new('nil') end
+end
+
+def_cf('match', [:Quote]) do |vm|
+  quotes = vm.stack.pop.body
+  quotes.each do |q|
+    if bindings=pattern_match(vm.stack.last(q.pattern.length), q.pattern)
+      vm.stack.pop(q.pattern.length)
+      vm.program.unshift(*q.bind(bindings).body)
+      break
+    end
+  end
+end
+
+def_cf('chars', [:Str]) do |vm|
+  chars = vm.stack.pop.val.chars.map { |c| QStr.new c }
+  vm.stack.push QQuote.new([], chars)
+end
+
+def_cf('weld', [:Str, :Str]) do |vm|
+  string_a = vm.stack.pop.val
+  string_b = vm.stack.pop.val
+  vm.stack.push QStr.new(string_b + string_a)
+end
+
+def_cf('def', [:Quote, :Sym]) do |vm|
+  name = vm.stack.pop.val
+  quote = vm.stack.pop
+  vm.bindings[name] = quote
+end
+
+def_cf('eval', [:Str]) do |vm, eval_func|
+  begin
+    eval_str = vm.stack.pop.val
+    vm2 = eval_func.call(eval_str, vm.stack.dup, vm.bindings.dup)
+    vm.stack, vm.bindings = vm2.stack, vm2.bindings
+    vm.stack.push QSym.new('ok')
+  rescue
+    vm.stack.push QSym.new('not-ok')
+  end
+end
+
+def_cf('type', [:Any]) do |vm|
+  type = type_to_qitem vm.stack.pop.qtype
+  vm.stack.push type
+end
+
+def_cf('load', [:Str]) do |vm|
+  begin
+    vm.stack.push QStr.new(File.read(vm.stack.pop.val))
+    vm.stack.push QSym.new 'ok'
+  rescue
+    vm.stack.push QSym.new 'not-ok'
+  end
+end
+
+def_cf('cmd', [:Str]) do |vm|
+  begin
+    vm.stack.push QStr.new(IO.popen(vm.stack.pop.val).read)
+    vm.stack.push QSym.new 'ok'
+  rescue
+    vm.stack.push QSym.new 'not-ok'
+  end
+end
+
+def_cf('write', [:Str, :Str]) do |vm|
+  begin
+    filename, content = vm.stack.pop.val, vm.stack.pop.val
+    File.open(filename, 'w+') { |f| f << content }
+    vm.stack.push QSym.new 'ok'
+  rescue
+    vm.stack.push QSym.new 'not-ok'
+  end
+end
+
+def_cf('exit', []) do |vm|
+  exit
+end

data/lib/qparse.rb

@@ -0,0 +1,42 @@
+require 'parslet'
+require 'qtypes'
+
+## Parsing ##
+
+class QuarkParse < Parslet::Parser
+  rule(:integer) { match('[0-9]').repeat(1) }
+  rule(:num) { (str("-").maybe >> integer >> (str('.') >> integer).maybe).as(:num) >> sep? } # Number
+  rule(:atom) { match('[^0-9\[\]|:"\' \n\t]').repeat(1).as(:atom) >> sep? } # Function or Variable
+  rule(:sym) { str(':') >> match('[^0-9\[\]|:"\' \n\t]').repeat(1).as(:sym) >> sep? } # Symbol
+  rule(:stringA) { str("'") >> match("[^']").repeat(0).as(:string) >> str("'") }
+  rule(:stringB) { str('"') >> match('[^"]').repeat(0).as(:string) >> str('"') }
+  rule(:string) { (stringA | stringB) >> sep? } # String
+  rule(:quote) {  # Quote
+    str("[") >> sep? >>
+    (qexpr >> sep? >> str("|") >> sep?).maybe.as(:pattern) >>
+    qexpr.as(:body) >> sep? >> str("]") >> sep?
+  }
+  rule(:qexpr) { sep? >> ((num | atom | sym | string | quote)).repeat(0) }
+  rule(:sep) { (match('\s') | match('\n') | match('\t')).repeat(1) }
+  rule(:sep?) { sep.maybe }
+  root :qexpr
+end
+
+class QuarkTransform < Parslet::Transform
+  rule(:num => simple(:x)) { QNum.new(x.to_f) }
+  rule(:atom => simple(:x)) { QAtom.new(x.to_s) }
+  rule(:sym => simple(:x)) { QSym.new(x.to_s) }
+  rule(:string => simple(:x)) { QStr.new(x.to_s) }
+  rule(:string => sequence(:x)) { QStr.new('') }
+  rule(:pattern => sequence(:a), :body => sequence(:b)) { QQuote.new(a, b) }
+  rule(:pattern => simple(:a), :body => sequence(:b)) { QQuote.new([], b) }
+  rule(:pattern => sequence(:a), :body => simple(:b)) { QQuote.new(a, []) }
+  rule(:pattern => simple(:a), :body => simple(:b)) { QQuote.new([], []) }
+end
+
+def qparse str
+  parsed = QuarkParse.new.parse(str)
+  QuarkTransform.new.apply parsed
+rescue Parslet::ParseFailed => e
+  e.cause.ascii_tree
+end

data/lib/qrun.rb

@@ -0,0 +1,54 @@
+require 'qtypes'
+require 'qparse'
+require 'qeval'
+
+## Evaluation ##
+
+QVM = Struct.new(:stack, :program, :bindings)
+
+def qrun(str, stack=[], bindings={})
+  qreduce QVM.new(stack, qparse(str), bindings)
+end
+
+def qreduce vm
+  until vm.program.empty?
+    item = vm.program.shift
+    if item.is_a? QAtom
+      if $core_func.has_key? item.val
+        apply_core_func(item.val, vm, ->(*x){qrun(*x)})
+      elsif vm.bindings.has_key? item.val
+        quote = vm.bindings[item.val]
+        vm.program.unshift(*[quote.dup, QAtom.new('call')])
+      else
+        raise QuarkError, "No such function: #{item}"
+      end
+    else
+      vm.stack.push item
+    end
+  end
+  return vm
+end
+
+def qrepl(vm)
+  loop do
+    print ':> '
+    begin
+      input = $stdin.gets.chomp
+      case input.strip
+      when '*q'
+        exit!
+      when '*f'
+        vm.bindings.sort.each { |k, v| puts "#{k}\n    #{v.to_s}\n\n"}
+      when /\*f\s+(.+)/
+        if vm.bindings.has_key? $1
+          puts vm.bindings[$1]
+        else puts "No such function: #{$1}" end
+      else
+        vm = qrun(input, vm.stack.dup, vm.bindings.dup)
+      end
+      puts vm.stack.map { |x| x.is_a?(QQuote) ? x.to_s(20) : x.to_s }.join(' ')
+    rescue Exception => e
+      puts e
+    end
+  end
+end

data/lib/qtypes.rb

@@ -0,0 +1,139 @@
+
+## Quark Values ##
+
+# parent class for all the quark primitive values
+class QVal
+
+  attr_accessor :val
+
+  def initialize(v)
+    @val = v
+  end
+
+  def to_s
+    @val.to_s
+  end
+
+  def ==(a)
+    return @val == a.val if a.is_a? self.class
+    false
+  end
+
+end
+
+# quark numbers
+class QNum < QVal
+
+  def to_s
+    @val.to_i == @val ? @val.to_i.to_s : @val.to_s
+  end
+
+  def qtype; :Num end
+end
+
+# quark functions/variables
+class QAtom < QVal
+  def qtype; :Atom end
+end
+
+# quark symbols
+class QSym < QVal
+
+  def to_s
+    ":#{@val.to_s}"
+  end
+
+  def qtype; :Sym end
+end
+
+# quark strings
+class QStr < QVal
+
+  def to_s
+    "\"#{@val.to_s}\""
+  end
+
+  def qtype; :Str end
+end
+
+# class for quark quotes
+class QQuote
+
+  attr_accessor :pattern, :body
+
+  def initialize(p, b)
+    @pattern = p
+    @body = b
+  end
+
+  def to_s(n=nil)
+    return "[]" if @body.empty? and @pattern.empty?
+    serialize = lambda do |arr|
+      xs = n ? arr.first(n) : arr
+      xs.map { |x| x.is_a?(QQuote) ? x.to_s(n) : x.to_s }.join(' ') + (n && arr.length > n ? ' ...' : '')
+    end
+    pattern_str = " #{serialize.call(@pattern)} |" if !@pattern.empty?
+    body_str = " #{serialize.call(@body)} " if !@body.empty?
+    "[#{pattern_str}#{body_str}]"
+  end
+
+  def dup
+    Marshal.load(Marshal.dump(self))
+  end
+
+  def ==(x)
+    if x.is_a? QQuote
+      (@pattern == x.pattern) && (@body == x.body)
+    else false end
+  end
+
+  def qtype; :Quote end
+
+  # pushes to quote body
+  def push x
+    @body.push x
+  end
+
+  # pops from quark body
+  def pop
+    @body.pop
+  end
+
+  # takes a hash of var strings to quark items and recursively subs its body
+  def bind bindings
+    @body.map! do |x|
+      if x.is_a? QQuote then x.bind bindings
+      elsif x.is_a? QAtom then bindings[x.val] || x
+      else x end
+    end
+    return self
+  end
+
+end
+
+
+## Type Checking ##
+
+# compares two qtype to see if they are equivelent
+# type comparison is not symmetric
+# `a` is the signature type, so (:Any, :Empty) will match, but (:Empty, :Any) won't
+def type_match(a, b)
+  return true if a == :Any
+  a == b
+end
+
+# matches a type signature against a data stack
+def type_check(stack, type_sig)
+  return false if stack.length < type_sig.length
+  return true if type_sig.length == 0
+  stack_type = stack.last(type_sig.length).map(&:qtype)
+  types_eq = type_sig.zip(stack_type)
+    .map { |sig, type| type_match(sig, type) }
+    .inject(true) { |a, b| a && b}
+  return types_eq, type_sig, stack_type
+end
+
+# converts a qtype to a qitem representation (used in the `type` function)
+def type_to_qitem t
+  return QSym.new(t.to_s)
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: rquark
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- "⊥"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: This is a ruby implementation of the Quark language
+email: 
+executables:
+- rquark
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rquark
+- lib/prelude.qrk
+- lib/qeval.rb
+- lib/qparse.rb
+- lib/qrun.rb
+- lib/qtypes.rb
+homepage: http://kdt.io/~/quark
+licenses:
+- CC0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Quark, A Functional, Purely Homoiconic, Concatenative Language
+test_files: []