halunke 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d34373e62580207f15e635b87cbbba8187f43aa5
+  data.tar.gz: '08eebf0cc515092ff533c44a271d7fc4b3c4a451'
+SHA512:
+  metadata.gz: 41960737ac425cc20b7183ab8a506e64e11c55a7dab81d00abfa120d32b9b770e1500f69e595b0d4a73c19d5442e96adb2cfaf06ddace218b71415ec9df66a58
+  data.tar.gz: f00d5bae53b39ae1c26b7bcde7ad8c16917b7e04a94c358680fc98850ead5e40284ec72cb3d1a6fb8802306dcbcb4d645236369b76fd9917b29ce26af4dbe1b0

data/.editorconfig

@@ -0,0 +1,23 @@
+# This is an EditorConfig file
+# http://EditorConfig.org
+# It configures your editor or IDE according to the project standards
+
+# top-most EditorConfig file
+root = true
+
+# These rules apply to all files
+[*]
+# Unix-style newlines
+end_of_line = lf
+# Newline at the end of the file (See: https://robots.thoughtbot.com/no-newline-at-end-of-file)
+insert_final_newline = true
+# Set default charset
+charset = utf-8
+# 2 space indentation
+indent_style = space
+indent_size = 2
+# Trim trailing whitespace
+trim_trailing_whitespace = true
+
+[*{.md,.markdown,.mdown}]
+indent_size = 4

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at lucas@dohmen.io. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in halunke.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    halunke (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    racc (1.4.14)
+    rake (12.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16.1)
+  halunke!
+  minitest (~> 5.11.3)
+  racc (~> 1.4.14)
+  rake (~> 12.3.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Lucas Dohmen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Halunke
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/halunke`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'halunke'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install halunke
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/halunke. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Halunke project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/halunke/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Compile Lexer with Ragel'
+task :compile do
+  sh 'ragel -R -o lib/halunke/lexer.rb lib/halunke/lexer.rl'
+  sh 'racc -o lib/halunke/parser.rb lib/halunke/grammar.y'
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.deps = [:compile]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "halunke"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/exe/halunke

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "halunke/interpreter"
+require "readline"
+
+interpreter = Halunke::Interpreter.new
+
+puts "Halunke REPL. Ctrl+d to quit"
+while (line = Readline.readline(">> ", true))
+  value = interpreter.eval(line)
+  puts "=> #{value}"
+end

data/halunke.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "halunke/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "halunke"
+  spec.version       = Halunke::VERSION
+  spec.authors       = ["Lucas Dohmen"]
+  spec.email         = ["lucas@dohmen.io"]
+
+  spec.summary       = %q{The Halunke programming language}
+  spec.description   = %q{A prototype for an OO language that embraces ideas like immutability and Lispyness}
+  spec.homepage      = "https://github.com/moonglum/halunke"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16.1"
+  spec.add_development_dependency "rake", "~> 12.3.0"
+  spec.add_development_dependency "minitest", "~> 5.11.3"
+  spec.add_development_dependency "racc", "~> 1.4.14"
+end

data/lib/halunke.rb

@@ -0,0 +1,4 @@
+require "halunke/version"
+
+module Halunke
+end

data/lib/halunke/grammar.y

@@ -0,0 +1,54 @@
+class Halunke::Parser
+
+token NUMBER
+token STRING
+token BAREWORD
+token OPEN_PAREN
+token CLOSE_PAREN
+token OPERATOR
+
+rule
+  Program:
+    /* empty */  { result = Nodes.new }
+  | Expressions  { result = val[0] }
+  ;
+
+  Expressions:
+    Expression { result = Nodes.new(val) }
+  ;
+
+  Expression:
+    Literal
+  | OPEN_PAREN Literal Literals CLOSE_PAREN { result = Halunke::MessageSendNode.new(val[1], MessageNode.new(val[2].nodes)) }
+  ;
+
+  Literals:
+    /* empty */      { result = Nodes.new }
+  | Literal Literals { result = Nodes.new([val[0]]).concat(val[1]) }
+  ;
+
+  Literal:
+    NUMBER   { result = NumberNode.new(val[0]) }
+  | STRING   { result = StringNode.new(val[0]) }
+  /* TODO: Are Operators just Barewords? */
+  | BAREWORD { result = BarewordNode.new(val[0]) }
+  | OPERATOR { result = BarewordNode.new(val[0]) }
+  ;
+
+end
+
+---- header
+
+require "halunke/lexer"
+require "halunke/nodes"
+
+---- inner
+
+def parse(code)
+  @tokens = Lexer.new.tokenize(code)
+  do_parse
+end
+
+def next_token
+  @tokens.shift
+end

data/lib/halunke/interpreter.rb

@@ -0,0 +1,28 @@
+require "halunke/parser"
+
+module Halunke
+  class Interpreter
+    def initialize
+      @parser = Parser.new
+      @context = {}
+      prelude
+    end
+
+    def eval(str)
+      nodes = @parser.parse(str)
+      nodes.eval(@context)
+    end
+
+    private
+
+    def prelude
+      @context[:Number] = Halunke::NativeClass.new(
+        "+" => Halunke::NativeFunction.new(->(receiver, args) { receiver.ruby_value + args.first.ruby_value })
+      )
+
+      @context[:String] = Halunke::NativeClass.new(
+        "reverse" => Halunke::NativeFunction.new(->(receiver, _args) { receiver.ruby_value.reverse })
+      )
+    end
+  end
+end

data/lib/halunke/lexer.rb

@@ -0,0 +1,380 @@
+
+# line 1 "lib/halunke/lexer.rl"
+=begin
+
+# line 24 "lib/halunke/lexer.rl"
+
+=end
+
+module Halunke
+  class Lexer
+    def initialize
+      
+# line 14 "lib/halunke/lexer.rb"
+class << self
+	attr_accessor :_lexer_actions
+	private :_lexer_actions, :_lexer_actions=
+end
+self._lexer_actions = [
+	0, 1, 0, 1, 1, 1, 2, 1, 
+	5, 1, 6, 1, 7, 1, 8, 1, 
+	9, 1, 10, 1, 11, 1, 12, 1, 
+	13, 2, 2, 3, 2, 2, 4
+]
+
+class << self
+	attr_accessor :_lexer_key_offsets
+	private :_lexer_key_offsets, :_lexer_key_offsets=
+end
+self._lexer_key_offsets = [
+	0, 1, 16, 17, 19
+]
+
+class << self
+	attr_accessor :_lexer_trans_keys
+	private :_lexer_trans_keys, :_lexer_trans_keys=
+end
+self._lexer_trans_keys = [
+	34, 32, 34, 40, 41, 43, 45, 95, 
+	9, 13, 48, 57, 65, 90, 97, 122, 
+	34, 48, 57, 95, 65, 90, 97, 122, 
+	0
+]
+
+class << self
+	attr_accessor :_lexer_single_lengths
+	private :_lexer_single_lengths, :_lexer_single_lengths=
+end
+self._lexer_single_lengths = [
+	1, 7, 1, 0, 1
+]
+
+class << self
+	attr_accessor :_lexer_range_lengths
+	private :_lexer_range_lengths, :_lexer_range_lengths=
+end
+self._lexer_range_lengths = [
+	0, 4, 0, 1, 2
+]
+
+class << self
+	attr_accessor :_lexer_index_offsets
+	private :_lexer_index_offsets, :_lexer_index_offsets=
+end
+self._lexer_index_offsets = [
+	0, 2, 14, 16, 18
+]
+
+class << self
+	attr_accessor :_lexer_trans_targs
+	private :_lexer_trans_targs, :_lexer_trans_targs=
+end
+self._lexer_trans_targs = [
+	1, 0, 1, 2, 1, 1, 3, 3, 
+	4, 1, 3, 4, 4, 1, 1, 0, 
+	3, 1, 4, 4, 4, 1, 1, 1, 
+	1, 1, 0
+]
+
+class << self
+	attr_accessor :_lexer_trans_actions
+	private :_lexer_trans_actions, :_lexer_trans_actions=
+end
+self._lexer_trans_actions = [
+	7, 0, 13, 5, 9, 11, 28, 28, 
+	0, 13, 25, 0, 0, 15, 7, 0, 
+	25, 23, 0, 0, 0, 17, 21, 19, 
+	23, 17, 0
+]
+
+class << self
+	attr_accessor :_lexer_to_state_actions
+	private :_lexer_to_state_actions, :_lexer_to_state_actions=
+end
+self._lexer_to_state_actions = [
+	0, 1, 0, 0, 0
+]
+
+class << self
+	attr_accessor :_lexer_from_state_actions
+	private :_lexer_from_state_actions, :_lexer_from_state_actions=
+end
+self._lexer_from_state_actions = [
+	0, 3, 0, 0, 0
+]
+
+class << self
+	attr_accessor :_lexer_eof_trans
+	private :_lexer_eof_trans, :_lexer_eof_trans=
+end
+self._lexer_eof_trans = [
+	23, 0, 24, 25, 26
+]
+
+class << self
+	attr_accessor :lexer_start
+end
+self.lexer_start = 1;
+class << self
+	attr_accessor :lexer_first_final
+end
+self.lexer_first_final = 1;
+class << self
+	attr_accessor :lexer_error
+end
+self.lexer_error = -1;
+
+class << self
+	attr_accessor :lexer_en_main
+end
+self.lexer_en_main = 1;
+
+
+# line 31 "lib/halunke/lexer.rl"
+      @tokens = []
+    end
+
+    def tokenize(data)
+      data.chomp!
+      eof = data.length
+
+      
+# line 143 "lib/halunke/lexer.rb"
+begin
+	p ||= 0
+	pe ||= data.length
+	cs = lexer_start
+	ts = nil
+	te = nil
+	act = 0
+end
+
+# line 39 "lib/halunke/lexer.rl"
+      
+# line 155 "lib/halunke/lexer.rb"
+begin
+	_klen, _trans, _keys, _acts, _nacts = nil
+	_goto_level = 0
+	_resume = 10
+	_eof_trans = 15
+	_again = 20
+	_test_eof = 30
+	_out = 40
+	while true
+	_trigger_goto = false
+	if _goto_level <= 0
+	if p == pe
+		_goto_level = _test_eof
+		next
+	end
+	end
+	if _goto_level <= _resume
+	_acts = _lexer_from_state_actions[cs]
+	_nacts = _lexer_actions[_acts]
+	_acts += 1
+	while _nacts > 0
+		_nacts -= 1
+		_acts += 1
+		case _lexer_actions[_acts - 1]
+			when 1 then
+# line 1 "NONE"
+		begin
+ts = p
+		end
+# line 185 "lib/halunke/lexer.rb"
+		end # from state action switch
+	end
+	if _trigger_goto
+		next
+	end
+	_keys = _lexer_key_offsets[cs]
+	_trans = _lexer_index_offsets[cs]
+	_klen = _lexer_single_lengths[cs]
+	_break_match = false
+	
+	begin
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + _klen - 1
+
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + ( (_upper - _lower) >> 1 )
+
+	        if data[p].ord < _lexer_trans_keys[_mid]
+	           _upper = _mid - 1
+	        elsif data[p].ord > _lexer_trans_keys[_mid]
+	           _lower = _mid + 1
+	        else
+	           _trans += (_mid - _keys)
+	           _break_match = true
+	           break
+	        end
+	     end # loop
+	     break if _break_match
+	     _keys += _klen
+	     _trans += _klen
+	  end
+	  _klen = _lexer_range_lengths[cs]
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + (_klen << 1) - 2
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + (((_upper-_lower) >> 1) & ~1)
+	        if data[p].ord < _lexer_trans_keys[_mid]
+	          _upper = _mid - 2
+	        elsif data[p].ord > _lexer_trans_keys[_mid+1]
+	          _lower = _mid + 2
+	        else
+	          _trans += ((_mid - _keys) >> 1)
+	          _break_match = true
+	          break
+	        end
+	     end # loop
+	     break if _break_match
+	     _trans += _klen
+	  end
+	end while false
+	end
+	if _goto_level <= _eof_trans
+	cs = _lexer_trans_targs[_trans]
+	if _lexer_trans_actions[_trans] != 0
+		_acts = _lexer_trans_actions[_trans]
+		_nacts = _lexer_actions[_acts]
+		_acts += 1
+		while _nacts > 0
+			_nacts -= 1
+			_acts += 1
+			case _lexer_actions[_acts - 1]
+when 2 then
+# line 1 "NONE"
+		begin
+te = p+1
+		end
+when 3 then
+# line 14 "lib/halunke/lexer.rl"
+		begin
+act = 1;		end
+when 4 then
+# line 19 "lib/halunke/lexer.rl"
+		begin
+act = 6;		end
+when 5 then
+# line 15 "lib/halunke/lexer.rl"
+		begin
+te = p+1
+ begin  emit(:STRING, data[ts+1...te-1])  end
+		end
+when 6 then
+# line 17 "lib/halunke/lexer.rl"
+		begin
+te = p+1
+ begin  emit(:OPEN_PAREN, data[ts...te])  end
+		end
+when 7 then
+# line 18 "lib/halunke/lexer.rl"
+		begin
+te = p+1
+ begin  emit(:CLOSE_PAREN, data[ts...te])  end
+		end
+when 8 then
+# line 20 "lib/halunke/lexer.rl"
+		begin
+te = p+1
+		end
+when 9 then
+# line 21 "lib/halunke/lexer.rl"
+		begin
+te = p+1
+ begin  raise "Could not lex '#{ data[ts...te] }'"  end
+		end
+when 10 then
+# line 16 "lib/halunke/lexer.rl"
+		begin
+te = p
+p = p - 1; begin  emit(:BAREWORD, data[ts...te])  end
+		end
+when 11 then
+# line 21 "lib/halunke/lexer.rl"
+		begin
+te = p
+p = p - 1; begin  raise "Could not lex '#{ data[ts...te] }'"  end
+		end
+when 12 then
+# line 21 "lib/halunke/lexer.rl"
+		begin
+ begin p = ((te))-1; end
+ begin  raise "Could not lex '#{ data[ts...te] }'"  end
+		end
+when 13 then
+# line 1 "NONE"
+		begin
+	case act
+	when 1 then
+	begin begin p = ((te))-1; end
+ emit(:NUMBER, data[ts...te].to_i) end
+	when 6 then
+	begin begin p = ((te))-1; end
+ emit(:OPERATOR, data[ts ... te]) end
+end 
+			end
+# line 323 "lib/halunke/lexer.rb"
+			end # action switch
+		end
+	end
+	if _trigger_goto
+		next
+	end
+	end
+	if _goto_level <= _again
+	_acts = _lexer_to_state_actions[cs]
+	_nacts = _lexer_actions[_acts]
+	_acts += 1
+	while _nacts > 0
+		_nacts -= 1
+		_acts += 1
+		case _lexer_actions[_acts - 1]
+when 0 then
+# line 1 "NONE"
+		begin
+ts = nil;		end
+# line 343 "lib/halunke/lexer.rb"
+		end # to state action switch
+	end
+	if _trigger_goto
+		next
+	end
+	p += 1
+	if p != pe
+		_goto_level = _resume
+		next
+	end
+	end
+	if _goto_level <= _test_eof
+	if p == eof
+	if _lexer_eof_trans[cs] > 0
+		_trans = _lexer_eof_trans[cs] - 1;
+		_goto_level = _eof_trans
+		next;
+	end
+end
+	end
+	if _goto_level <= _out
+		break
+	end
+	end
+	end
+
+# line 40 "lib/halunke/lexer.rl"
+
+      @tokens
+    end
+
+    private
+
+    def emit(type, value)
+      @tokens << [ type, value ]
+    end
+  end
+end

data/lib/halunke/lexer.rl

@@ -0,0 +1,50 @@
+=begin
+%%{
+  machine lexer;
+
+  number = ('+'|'-')?[0-9]+;
+  string = '"' [^"]* '"';
+  bareword = [a-zA-Z_]+;
+  open_paren = '(';
+  close_paren = ')';
+  operator = '+' | '-';
+
+  main := |*
+
+    number => { emit(:NUMBER, data[ts...te].to_i) };
+    string => { emit(:STRING, data[ts+1...te-1]) };
+    bareword => { emit(:BAREWORD, data[ts...te]) };
+    open_paren => { emit(:OPEN_PAREN, data[ts...te]) };
+    close_paren => { emit(:CLOSE_PAREN, data[ts...te]) };
+    operator => { emit(:OPERATOR, data[ts ... te]) };
+    space;
+    any => { raise "Could not lex '#{ data[ts...te] }'" };
+
+  *|;
+}%%
+=end
+
+module Halunke
+  class Lexer
+    def initialize
+      %% write data;
+      @tokens = []
+    end
+
+    def tokenize(data)
+      data.chomp!
+      eof = data.length
+
+      %% write init;
+      %% write exec;
+
+      @tokens
+    end
+
+    private
+
+    def emit(type, value)
+      @tokens << [ type, value ]
+    end
+  end
+end

data/lib/halunke/nodes.rb

@@ -0,0 +1,56 @@
+require "halunke/runtime"
+
+module Halunke
+  Nodes = Struct.new(:nodes) do
+    def initialize(nodes = [])
+      super(nodes)
+    end
+
+    def concat(other)
+      Nodes.new(nodes.concat(other.nodes))
+    end
+
+    def eval(context)
+      val = nil
+
+      nodes.each do |node|
+        val = node.eval(context)
+      end
+
+      val
+    end
+  end
+
+  LiteralNode = Struct.new(:value)
+
+  class NumberNode < LiteralNode
+    def eval(context)
+      context[:Number].create_instance(value)
+    end
+  end
+
+  class StringNode < LiteralNode
+    def eval(context)
+      context[:String].create_instance(value)
+    end
+  end
+
+  class BarewordNode < LiteralNode
+  end
+
+  MessageSendNode = Struct.new(:receiver, :message) do
+    def eval(context)
+      receiver.eval(context).receive_message(*message.eval(context))
+    end
+  end
+
+  MessageNode = Struct.new(:nodes) do
+    def eval(context)
+      case nodes.length
+      when 1 then [nodes[0].value, []]
+      when 2 then [nodes[0].value, [nodes[1].eval(context)]]
+      else raise "Not implemented"
+      end
+    end
+  end
+end

data/lib/halunke/parser.rb

@@ -0,0 +1,206 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.14
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+
+require "halunke/lexer"
+require "halunke/nodes"
+
+module Halunke
+  class Parser < Racc::Parser
+
+module_eval(<<'...end grammar.y/module_eval...', 'grammar.y', 46)
+
+def parse(code)
+  @tokens = Lexer.new.tokenize(code)
+  do_parse
+end
+
+def next_token
+  @tokens.shift
+end
+...end grammar.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+     6,     7,     8,     5,    10,     9,     6,     7,     8,    12,
+    15,     9,     6,     7,     8,   nil,   nil,     9,     6,     7,
+     8,   nil,   nil,     9 ]
+
+racc_action_check = [
+     0,     0,     0,     0,     1,     0,     5,     5,     5,    10,
+    13,     5,    11,    11,    11,   nil,   nil,    11,    14,    14,
+    14,   nil,   nil,    14 ]
+
+racc_action_pointer = [
+    -2,     4,   nil,   nil,   nil,     4,   nil,   nil,   nil,   nil,
+     9,    10,   nil,     4,    16,   nil,   nil ]
+
+racc_action_default = [
+    -1,   -12,    -2,    -3,    -4,   -12,    -8,    -9,   -10,   -11,
+   -12,    -6,    17,   -12,    -6,    -5,    -7 ]
+
+racc_goto_table = [
+     4,    13,     1,     2,    16,    11,     3 ]
+
+racc_goto_check = [
+     4,     5,     1,     2,     5,     4,     3 ]
+
+racc_goto_pointer = [
+   nil,     2,     3,     6,     0,   -10 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,    14,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  0, 9, :_reduce_1,
+  1, 9, :_reduce_2,
+  1, 10, :_reduce_3,
+  1, 11, :_reduce_none,
+  4, 11, :_reduce_5,
+  0, 13, :_reduce_6,
+  2, 13, :_reduce_7,
+  1, 12, :_reduce_8,
+  1, 12, :_reduce_9,
+  1, 12, :_reduce_10,
+  1, 12, :_reduce_11 ]
+
+racc_reduce_n = 12
+
+racc_shift_n = 17
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :NUMBER => 2,
+  :STRING => 3,
+  :BAREWORD => 4,
+  :OPEN_PAREN => 5,
+  :CLOSE_PAREN => 6,
+  :OPERATOR => 7 }
+
+racc_nt_base = 8
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "NUMBER",
+  "STRING",
+  "BAREWORD",
+  "OPEN_PAREN",
+  "CLOSE_PAREN",
+  "OPERATOR",
+  "$start",
+  "Program",
+  "Expressions",
+  "Expression",
+  "Literal",
+  "Literals" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 11)
+  def _reduce_1(val, _values, result)
+     result = Nodes.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 12)
+  def _reduce_2(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 16)
+  def _reduce_3(val, _values, result)
+     result = Nodes.new(val) 
+    result
+  end
+.,.,
+
+# reduce 4 omitted
+
+module_eval(<<'.,.,', 'grammar.y', 21)
+  def _reduce_5(val, _values, result)
+     result = Halunke::MessageSendNode.new(val[1], MessageNode.new(val[2].nodes)) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 25)
+  def _reduce_6(val, _values, result)
+     result = Nodes.new 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 26)
+  def _reduce_7(val, _values, result)
+     result = Nodes.new([val[0]]).concat(val[1]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 30)
+  def _reduce_8(val, _values, result)
+     result = NumberNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 31)
+  def _reduce_9(val, _values, result)
+     result = StringNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 33)
+  def _reduce_10(val, _values, result)
+     result = BarewordNode.new(val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.y', 34)
+  def _reduce_11(val, _values, result)
+     result = BarewordNode.new(val[0]) 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+  end   # module Halunke

data/lib/halunke/runtime.rb

@@ -0,0 +1,41 @@
+# This file is not tested directly right now,
+# because I'm not sure if this structure is good
+module Halunke
+  class NativeClass
+    def initialize(methods)
+      @runtime_methods = methods
+    end
+
+    def create_instance(ruby_value)
+      NativeObject.new(self, ruby_value)
+    end
+
+    def lookup(message)
+      @runtime_methods[message]
+    end
+  end
+
+  class NativeObject
+    attr_reader :ruby_value
+
+    def initialize(runtime_class, ruby_value)
+      @runtime_class = runtime_class
+      @ruby_value = ruby_value
+    end
+
+    def receive_message(message_name, message_value)
+      m = @runtime_class.lookup(message_name)
+      m.call(self, message_value)
+    end
+  end
+
+  class NativeFunction
+    def initialize(fn)
+      @fn = fn
+    end
+
+    def call(receiver, args)
+      @fn.call(receiver, args)
+    end
+  end
+end

data/lib/halunke/version.rb

@@ -0,0 +1,3 @@
+module Halunke
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: halunke
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lucas Dohmen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.11.3
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+description: A prototype for an OO language that embraces ideas like immutability
+  and Lispyness
+email:
+- lucas@dohmen.io
+executables:
+- halunke
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/halunke
+- halunke.gemspec
+- lib/halunke.rb
+- lib/halunke/grammar.y
+- lib/halunke/interpreter.rb
+- lib/halunke/lexer.rb
+- lib/halunke/lexer.rl
+- lib/halunke/nodes.rb
+- lib/halunke/parser.rb
+- lib/halunke/runtime.rb
+- lib/halunke/version.rb
+homepage: https://github.com/moonglum/halunke
+licenses:
+- MIT
+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.6.14
+signing_key: 
+specification_version: 4
+summary: The Halunke programming language
+test_files: []