taoism 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6257a4a47d084d1a3bdaab39c08ab216ddd729fad2f508da85a79775043539bf
-  data.tar.gz: 4d156fb2970893a73fe4898c316dc33d96785e9cb48ee7ddf1dfa343521afff0
+  metadata.gz: e3888b31accff3d78029eaba044b83ef112863b85b2b4c6ee84865f3af918330
+  data.tar.gz: ea0fbbb5539fbda01d5f2c40eb8f2a1067e451c6a7cc9c0b16e47c3b981080d6
 SHA512:
-  metadata.gz: 8f4fc03e11db86e3c85fab8fae14509036d1579bd166b97cfa582dc2673fcb8fb0941d75da3278884b9dc431188a1877f3b385ebac91fe711ed820357b13f323
-  data.tar.gz: 9f3d220093d56d8423c9e8f34263b4ee949931cdcd6c7253c857d8c4568e3605e9e052d1a6181e57a215f6b251aa26f3e12b38f86e08cf66e494904bb691e283
+  metadata.gz: 5569c903178515e6f8658be27acbb1868b7517422111bf8a30f0c441e83879d531c4ab52067e1b62b0f7ac22be6d61008fee4021b227d419cd323f5c09584e85
+  data.tar.gz: 76776999d05166456d75b43bbf0d62b5ebad747a0271bb17c867b181dbd0d9aef90fd9945b1b74c7388ed3e595c84d440fea7d6370a9e9c40d0bcf5c6aa29045

data/bin/tao

@@ -1,2 +1,47 @@
 #!/usr/bin/env ruby
-require 'tao'
+require 'taoism'
+
+source = if $stdin.tty?
+  files = ARGV.reject { _1.start_with?('-') }
+
+  if files.empty?
+    puts "Tao is a toy language."
+    exit 0
+  end
+
+  filepath = files.first
+
+  if files[1]
+    $stderr.puts "skipped: #{files[1..].join(', ')}"
+  end
+
+  if File.exist?(filepath)
+    File.read(filepath)
+  else
+    $stderr.puts "No such file - #{filepath}"
+    exit 1
+  end
+else
+  ARGF.read
+end
+
+begin
+  lexer = Taoism::Lexer.new(source)
+  parser = Taoism::Parser.new(lexer)
+
+  ast = parser.parse
+
+  if parser.errors.empty?
+    evaluator = Taoism::Evaluator.new
+    evaluator.evaluate(ast)
+  else
+    parser.errors.each { |e| $stderr.puts e }
+    exit 1
+  end
+rescue Taoism::Runtime::Error => err
+  $stderr.puts "Error: #{err.message}"
+  exit 1
+rescue StandardError => err
+  $stderr.puts "Internal error: #{err.message}"
+  exit 1
+end

data/bin/taoism

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'taoism'
+require 'taoism/console'
+
+Taoism::Console.new.run

data/lib/taoism/console.rb

@@ -0,0 +1,72 @@
+module Taoism
+  class Console
+    PS1 = 'taoism:%03d> '
+    PS2 = 'taoism:%03d* '
+
+    def initialize
+      @evaluator = Evaluator.new
+      @line_no = 1
+    end
+
+    def run
+      require 'readline'
+
+      loop do
+        input = read_input
+        break unless input
+
+        break if input.strip == 'exit'
+        evaluate(input)
+      end
+    end
+
+    def read_input
+      ps1 = PS1 % @line_no
+      ps2 = PS2 % @line_no
+
+      input = Readline.readline(ps1, true)
+      return if input.nil?
+      input = input.chomp
+
+      had_continuation = false
+
+      while unclosed?(input)
+        had_continuation = true
+        line = Readline.readline(ps2, false)
+
+        break unless line
+        input << "\n" << line.chomp
+      end
+
+      if had_continuation
+        Readline::HISTORY.pop
+        Readline::HISTORY << input
+      end
+
+      @line_no += 1
+      input
+    end
+
+    def evaluate(input)
+      lexer = Lexer.new(input)
+      parser = Parser.new(lexer)
+
+      ast = parser.parse
+
+      if parser.errors.empty?
+        result = @evaluator.evaluate(ast)
+        puts Runtime.repr(result)
+      else
+        parser.errors.each do |err|
+          $stderr.puts "Error: #{err}"
+        end
+      end
+    rescue Runtime::Error, Runtime::Return, Runtime::Leave => err
+      $stderr.puts "Error: #{err.message}"
+    end
+
+    def unclosed?(input)
+      input.count('{') > input.count('}')
+    end
+  end
+end

data/lib/taoism/environment.rb

@@ -0,0 +1,44 @@
+module Taoism
+  class Environment
+    def initialize(outer = nil)
+      @outer = outer
+      @scope = {}
+    end
+
+    def define(name, value, mutable:)
+      if @scope.key?(name)
+        raise Runtime::Error, "already defined variable: #{name}"
+      end
+
+      @scope[name] = { value: value, mutable: mutable }
+    end
+
+    def get(name)
+      if @scope.key?(name)
+        @scope[name][:value]
+      elsif @outer
+        @outer.get(name)
+      else
+        raise Runtime::Error, "undefined variable: #{name}"
+      end
+    end
+
+    def set(name, value)
+      if @scope.key?(name)
+        if @scope[name][:mutable]
+          @scope[name][:value] = value
+        else
+          raise Runtime::Error, "cannot assign to immutable variable"
+        end
+      elsif @outer
+        @outer.set(name, value)
+      else
+        raise Runtime::Error, "undefined variable: #{name}"
+      end
+    end
+
+    def has?(name)
+      @scope.key?(name) or @outer&.has?(name)
+    end
+  end
+end

data/lib/taoism/evaluator.rb

@@ -0,0 +1,385 @@
+module Taoism
+  class Evaluator
+    def initialize
+      @global = Environment.new
+      @methods = {}
+      @builtins = {
+        'io.println' => proc { |arg| puts arg.to_s }
+      }
+      @in_loop = false
+      @in_function = false
+    end
+
+    def evaluate(node, env = @global)
+      case node
+      when Nodes::Program
+        node.stmts.map { |s| evaluate(s, env) }.last
+      when Nodes::Block
+        inner = Environment.new(env)
+        last = nil
+
+        node.stmts.each { |s| last = evaluate(s, inner) }
+        last
+      when Nodes::ExprStmt  then evaluate(node.expr, env)
+      when Nodes::IntLit    then node.value
+      when Nodes::FloatLit  then node.value
+      when Nodes::StringLit
+        node.value.gsub(/\\(\\|"|n|r|t|0|\((\w+)\))/) do
+          case $1
+          when '\\' then '\\'
+          when '"'  then '"'
+          when 'n'  then "\n"
+          when 'r'  then "\r"
+          when 't'  then "\t"
+          when '0'  then "\0"
+          else
+            env.get($2).then { |v|
+              v.is_a?(String) ? v : Runtime.repr(v)
+            }
+          end
+        end
+      when Nodes::BoolLit   then node.value
+      when Nodes::NoneLit   then nil
+      when Nodes::ListLit
+        node.elements.map { |e| evaluate(e, env) }
+      when Nodes::Identifier then env.get(node.name)
+      when Nodes::Let
+        val = evaluate(node.value, env)
+        env.define(node.name, val, mutable: node.mutable)
+        val
+      when Nodes::LetPair
+        values = evaluate(node.expr, env)
+
+        unless values.is_a?(Array)
+          raise Runtime::Error, "cannot destructure #{values}"
+        end
+
+        if values.length < 2
+          raise Runtime::Error, "cannot destructure #{values}, expected at least 2 elements"
+        end
+
+        env.define(node.first, values[0], mutable: false)
+        env.define(node.second, values[1], mutable: false)
+        values
+      when Nodes::Assign
+        val = evaluate(node.value, env)
+
+        case node.target
+        when Nodes::Identifier
+          env.set(node.target.name, val)
+        when Nodes::DotExpr
+          target = evaluate(node.target.target, env)
+
+          unless target.is_a?(Runtime::Instance)
+            raise Runtime::Error, "field access on non-instance"
+          end
+
+          unless target.fields.key?(node.target.name)
+            raise Runtime::Error, "undefined field: #{node.target.name}"
+          end
+
+          target.fields[node.target.name] = val
+        when Nodes::Index
+          target = evaluate(node.target.target, env)
+
+          unless target.is_a?(Array) || target.is_a?(String)
+            raise Runtime::Error, "index assignment on non-indexable"
+          end
+
+          index = evaluate(node.target.index, env)
+
+          unless index.is_a?(Integer)
+            raise Runtime::Error, "index must be an integer: #{index}"
+          end
+
+          if target.is_a?(String)
+            unless val.is_a?(String)
+              raise Runtime::Error, "index value must be a string"
+            end
+
+            unless index.between?(-target.length, target.length)
+              raise Runtime::Error, "index out of range: #{index}"
+            end
+          elsif index < -target.length
+            raise Runtime::Error, "index out of range: #{index}"
+          end
+
+          target[index] = val
+        else
+          raise Runtime::Error, "invalid assignment target"
+        end
+
+        val
+      when Nodes::Const
+        val = evaluate(node.value, env)
+        env.define(node.name, val, mutable: false)
+        val
+      when Nodes::BinaryOp
+        left = evaluate(node.left, env)
+        case node.op
+        when :and then left && evaluate(node.right, env)
+        when :or  then left || evaluate(node.right, env)
+        else
+          right = evaluate(node.right, env)
+
+          if %i(+ - * / % < <= > >=).include?(node.op)
+            unless Types.numeric?(left) && Types.numeric?(right)
+              raise Runtime::Error, "cannot apply #{node.op} to #{Types.typeof(left)} and #{Types.typeof(right)}"
+            end
+          end
+
+          if %i(/ %).include?(node.op) && right == 0
+            raise Runtime::Error, "cannot divide by zero"
+          end
+
+          left.send(node.op, right)
+        end
+      when Nodes::UnaryOp
+        operand = evaluate(node.operand, env)
+
+        if node.op == :'-'
+          unless Types.numeric?(operand)
+            raise Runtime::Error, "cannot negate #{Types.typeof(operand)}"
+          end
+
+          -operand
+        else
+          !operand
+        end
+      when Nodes::If
+        if evaluate(node.cond, env)
+          evaluate(node.then_body, env)
+        elsif node.else_body
+          evaluate(node.else_body, env)
+        else
+        end
+      when Nodes::Switch
+        val = evaluate(node.value, env)
+        result = nil
+        matched = false
+
+        node.arms.each do |arm|
+          if evaluate(arm.pattern, env) == val
+            result = evaluate(arm.value, env)
+            matched = true
+            break
+          end
+        end
+
+        if !matched && node.else_body
+          result = evaluate(node.else_body, env)
+        end
+
+        result
+      when Nodes::Loop
+        prev = @in_loop
+        @in_loop = true
+
+        begin
+          loop do
+            begin
+              evaluate(node.body, Environment.new(env))
+            rescue Runtime::Leave
+              break
+            end
+          end
+        ensure
+          @in_loop = prev
+        end
+      when Nodes::Leave
+        unless @in_loop
+          raise Runtime::Error, "leave outside loop"
+        end
+
+        raise Runtime::Leave
+      when Nodes::Return
+        result = evaluate(node.value, env)
+        raise Runtime::Return.new(result)
+      when Nodes::FunDef
+        fn = Runtime::Function.new(
+          node.name, node.params, node.body, env, node.receiver
+        )
+
+        if node.receiver
+          type_name = node.receiver.type_name
+
+          unless env.has?(type_name) && env.get(type_name).is_a?(Runtime::DataType)
+            raise Runtime::Error, "undefined type: #{type_name}"
+          end
+
+          fn_name = "#{type_name}.#{node.name}"
+
+          if @methods[fn_name]
+            raise Runtime::Error, "already defined method: #{fn_name}"
+          end
+
+          @methods[fn_name] = fn
+        end
+
+        if node.name && node.receiver.nil?
+          env.define(node.name, fn, mutable: false)
+        end
+
+        fn
+      when Nodes::Call
+        args = node.args.map { |a| evaluate(a, env) }
+
+        if node.callee.is_a?(Nodes::DotExpr)
+          if node.callee.target.is_a?(Nodes::Identifier)
+            key = "#{node.callee.target.name}.#{node.callee.name}"
+            if fn = @builtins[key]
+              return fn.call(*args)
+            end
+          end
+
+          target = evaluate(node.callee.target, env)
+
+          unless target.is_a?(Runtime::Instance)
+            raise Runtime::Error, "method call on non-instance"
+          end
+
+          key = "#{target.type}.#{node.callee.name}"
+          fn = @methods[key]
+
+          unless fn
+            raise Runtime::Error, "undefined method: #{key}"
+          end
+
+          if args.length != fn.params.length
+            raise Runtime::Error, arity_error(fn.params.length, args.length)
+          end
+
+          call_env = Environment.new(fn.closure)
+          call_env.define(fn.receiver.param_name, target, mutable: true)
+
+          fn.params.each_with_index do |p, i|
+            call_env.define(p, args[i], mutable: true)
+          end
+
+          prev = @in_function
+          @in_function = true
+
+          begin
+            evaluate(fn.body, call_env)
+          rescue Runtime::Return => ret
+            ret.value
+          ensure
+            @in_function = prev
+          end
+        else
+          callee = evaluate(node.callee, env)
+          case callee
+          when Runtime::Function
+            if args.length != callee.params.length
+              raise Runtime::Error, arity_error(callee.params.length, args.length)
+            end
+
+            call_env = Environment.new(callee.closure)
+            callee.params.each_with_index do |p, i|
+              call_env.define(p, args[i], mutable: true)
+            end
+
+            prev = @in_function
+            @in_function = true
+
+            begin
+              evaluate(callee.body, call_env)
+            rescue Runtime::Return => ret
+              ret.value
+            ensure
+              @in_function = prev
+            end
+          when Runtime::DataType
+            fields = {}
+
+            if args.length > callee.fields.length
+              raise Runtime::Error, arity_error("at most #{callee.fields.length}", args.length)
+            end
+
+            callee.fields.each_with_index do |f, i|
+              fields[f.name] = args.length > i ? args[i] : evaluate(f.default, env)
+            end
+
+            Runtime::Instance.new(callee.name, fields)
+          else
+            raise Runtime::Error, "not callable: #{callee.inspect}"
+          end
+        end
+      when Nodes::DotExpr
+        target = evaluate(node.target, env)
+
+        if target.is_a?(Runtime::Instance)
+          unless target.fields.key?(node.name)
+            raise Runtime::Error, "undefined field: #{node.name}"
+          end
+
+          target.fields[node.name]
+        else
+          raise Runtime::Error, "field access on non-instance"
+        end
+      when Nodes::Index
+        target = evaluate(node.target, env)
+        index = evaluate(node.index, env)
+
+        unless index.is_a?(Integer)
+          raise Runtime::Error, "index must be an integer: #{index}"
+        end
+
+        unless target.is_a?(Array) || target.is_a?(String)
+          raise Runtime::Error, "index access on non-indexable"
+        end
+
+        target[index]
+      when Nodes::DataDef
+        node.fields.each do |field|
+          next if field.default.nil?
+          unless literal?(field.default)
+            raise Runtime::Error, "field default must be a literal: #{field.name}"
+          end
+        end
+
+        value = Runtime::DataType.new(node.name, node.fields)
+        env.define(node.name, value, mutable: false)
+        value
+      when Nodes::Try
+        unless @in_function
+          raise Runtime::Error, "try outside function"
+        end
+
+        result = evaluate(node.call, env)
+
+        unless result.is_a?(Array) && result.length == 2
+          raise Runtime::Error, "try requires [val, err] tuple"
+        end
+
+        val, err = result
+        return val if err.nil?
+        raise Runtime::Return.new(err)
+      when Nodes::Package then nil
+      when Nodes::Import  then nil
+      when nil            then nil
+      else
+        raise Runtime::Error, "unknown node: #{node.class}"
+      end
+    end
+
+    def arity_error(expected, got)
+      "expected #{expected} argument(s) but got #{got}"
+    end
+
+    def literal?(node)
+      case node
+      when Nodes::IntLit,
+           Nodes::FloatLit,
+           Nodes::StringLit,
+           Nodes::BoolLit,
+           Nodes::NoneLit
+        true
+      when Nodes::ListLit
+        node.elements.all? { |el| literal?(el) }
+      else
+        false
+      end
+    end
+  end
+end