rpl 0.4.0 → 0.7.0

data/lib/rpl/types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rpl/types/boolean'
+require 'rpl/types/name'
+require 'rpl/types/list'
+require 'rpl/types/string'
+require 'rpl/types/program'
+require 'rpl/types/numeric'
+
+module Types
+  module_function
+  def new_object( type_class, value )
+    if type_class.can_parse?( value )
+      type_class.new( value )
+    else
+      RplString.new( "\"Error: cannot create #{type_class} with value #{value}\"" )
+    end
+  end
+end

data/lib/rpl/{core → words}/branch.rb

@@ -1,38 +1,37 @@
 # frozen_string_literal: true
 
 module RplLang
-  module Core
+  module Words
     module Branch
+      include Types
+
       def populate_dictionary
         super
 
         @dictionary.add_word( ['ift'],
                               'Branch',
                               '( t pt -- … ) eval pt or not based on the value of boolean t',
-                              proc do
-                                run( '« nop » ifte' )
-                              end )
+                              Types.new_object( RplProgram, '« « nop » ifte »' ) )
 
         @dictionary.add_word( ['ifte'],
                               'Branch',
                               '( t pt pf -- … ) eval pt or pf based on the value of boolean t',
                               proc do
-                                args = stack_extract( [:any, :any, %i[boolean]] )
+                                args = stack_extract( [:any, :any, [RplBoolean]] )
 
-                                run( args[ args[2][:value] ? 1 : 0 ][:value] )
+                                run( args[ args[2].value ? 1 : 0 ].value )
                               end )
 
         @dictionary.add_word( ['times'],
                               'Branch',
                               '( p n -- … ) eval p n times while pushing counter on stack before',
                               proc do
-                                args = stack_extract( [%i[numeric], :any] )
+                                args = stack_extract( [[RplNumeric], :any] )
 
-                                args[0][:value].to_i.times do |i|
-                                  counter = { value: BigDecimal( i, @precision ), type: :numeric, base: 10 }
-                                  @stack << counter
+                                args[0].value.to_i.times do |counter|
+                                  @stack << Types.new_object( RplNumeric, counter )
 
-                                  run( args[1][:value] )
+                                  run( args[1].value )
                                 end
                               end )
 
@@ -40,13 +39,12 @@ module RplLang
                               'Branch',
                               '( p n1 n2 -- … ) eval p looping from n1 to n2 while pushing counter on stack before',
                               proc do
-                                args = stack_extract( [%i[numeric], %i[numeric], :any] )
+                                args = stack_extract( [[RplNumeric], [RplNumeric], :any] )
 
-                                ((args[1][:value].to_i)..(args[0][:value].to_i)).each do |i|
-                                  counter = { value: BigDecimal( i, @precision ), type: :numeric, base: 10 }
-                                  @stack << counter
+                                ((args[1].value.to_i)..(args[0].value.to_i)).each do |counter|
+                                  @stack << Types.new_object( RplNumeric, counter )
 
-                                  run( args[2][:value] )
+                                  run( args[2].value )
                                 end
                               end )
       end

data/lib/rpl/{core → words}/filesystem.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module RplLang
-  module Core
+  module Words
     module FileSystem
+      include Types
+
       def populate_dictionary
         super
 
@@ -10,29 +12,26 @@ module RplLang
                               'Filesystem',
                               '( filename -- content ) read file and put content on stack as string',
                               proc do
-                                args = stack_extract( [%i[string]] )
+                                args = stack_extract( [[RplString]] )
 
-                                path = File.absolute_path( args[0][:value] )
+                                path = File.absolute_path( args[0].value )
 
-                                @stack << { type: :string,
-                                            value: File.read( path ) }
+                                @stack << Types.new_object( RplString, "\"#{File.read( path )}\"" )
                               end )
 
         @dictionary.add_word( ['feval'],
                               'Filesystem',
                               '( filename -- … ) read and run file',
-                              proc do
-                                run( 'fread eval' )
-                              end )
+                              Types.new_object( RplProgram, '« fread eval »' ) )
 
         @dictionary.add_word( ['fwrite'],
                               'Filesystem',
                               '( content filename -- ) write content into filename',
                               proc do
-                                args = stack_extract( [%i[string], :any] )
+                                args = stack_extract( [[RplString], :any] )
 
-                                File.write( File.absolute_path( args[0][:value] ),
-                                            args[1][:value] )
+                                File.write( File.absolute_path( args[0].value ),
+                                            args[1].value )
                               end )
       end
     end

data/lib/rpl/words/general.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module RplLang
+  module Words
+    module General
+      include Types
+
+      def populate_dictionary
+        super
+
+        @dictionary.add_word( ['nop'],
+                              'General',
+                              '( -- ) no operation',
+                              proc {} )
+
+        @dictionary.add_word( ['help'],
+                              'General',
+                              '( w -- s ) pop help string of the given word',
+                              proc do
+                                args = stack_extract( [[RplName]] )
+
+                                word = @dictionary.words[ args[0].value ]
+
+                                @stack << Types.new_object( RplString, "\"#{args[0].value}: #{word.nil? ? 'not a core word' : word[:help]}\"" )
+                              end )
+
+        @dictionary.add_word( ['words'],
+                              'REPL',
+                              'DEBUG',
+                              proc do
+                                @dictionary.words
+                                           .to_a
+                                           .group_by { |word| word.last[:category] }
+                                           .each do |cat, words|
+                                  puts cat
+                                  puts "    #{words.map(&:first).join(', ')}"
+                                end
+                              end )
+
+        @dictionary.add_word( ['quit'],
+                              'General',
+                              '( -- ) Stop and quit interpreter',
+                              proc {} )
+
+        @dictionary.add_word( ['version'],
+                              'General',
+                              '( -- n ) Pop the interpreter\'s version number',
+                              proc do
+                                @stack << Types.new_object( RplString, "\"#{@version}\"" )
+                              end )
+
+        @dictionary.add_word( ['uname'],
+                              'General',
+                              '( -- s ) Pop the interpreter\'s complete indentification string',
+                              proc do
+                                @stack << Types.new_object( RplString, "\"Rpl Interpreter version #{@version}\"" )
+                              end )
+
+        @dictionary.add_word( ['history'],
+                              'REPL',
+                              '',
+                              proc {} )
+
+        @dictionary.add_word( ['edit'],
+                              'General',
+                              '( -- s ) Pop the interpreter\'s complete indentification string',
+                              proc do
+                                args = stack_extract( [:any] )
+
+                                value = args[0].to_s
+                                tempfile = Tempfile.new('rpl')
+
+                                begin
+                                  tempfile.write( value )
+                                  tempfile.rewind
+
+                                  `$EDITOR #{tempfile.path}`
+
+                                  edited_value = tempfile.read
+                                ensure
+                                  tempfile.close
+                                  tempfile.unlink
+                                end
+
+                                @stack << Types.new_object( args[0].class, edited_value )
+                              end )
+
+        @dictionary.add_word( ['.s'],
+                              'REPL',
+                              'DEBUG',
+                              proc { pp @stack } )
+
+        @dictionary.add_word( ['.d'],
+                              'REPL',
+                              'DEBUG',
+                              proc { pp @dictionary } )
+
+        @dictionary.add_word( ['.v'],
+                              'REPL',
+                              'DEBUG',
+                              proc { pp @dictionary.vars } )
+
+        @dictionary.add_word( ['.lv'],
+                              'REPL',
+                              'DEBUG',
+                              proc { pp @dictionary.local_vars_layers } )
+      end
+    end
+  end
+end

data/lib/rpl/{core → words}/logarithm.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module RplLang
-  module Core
+  module Words
     module Logarithm
+      include Types
+
       def populate_dictionary
         super
 
@@ -10,9 +12,7 @@ module RplLang
                               'Logs on reals and complexes',
                               '( … -- ℇ ) push ℇ',
                               proc do
-                                @stack << { type: :numeric,
-                                            base: 10,
-                                            value: BigMath.E( @precision ) }
+                                @stack << Types.new_object( RplNumeric, BigMath.E( RplNumeric.precision ) )
                               end )
 
         # @dictionary.add_word( ['ln'],

data/lib/rpl/{core → words}/mode.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module RplLang
-  module Core
+  module Words
     module Mode
+      include Types
+
       def populate_dictionary
         super
 
@@ -10,15 +12,15 @@ module RplLang
                               'Mode',
                               '( a -- ) set precision to a',
                               proc do
-                                args = stack_extract( [%i[numeric]] )
+                                args = stack_extract( [[RplNumeric]] )
 
-                                @precision = args[0][:value]
+                                RplNumeric.precision = args[0].value
                               end )
         @dictionary.add_word( ['default'],
                               'Mode',
                               '( -- ) set default precision',
                               proc do
-                                @precision = default_precision
+                                RplNumeric.default_precision
                               end )
         @dictionary.add_word( ['type'],
                               'Mode',
@@ -26,8 +28,7 @@ module RplLang
                               proc do
                                 args = stack_extract( [:any] )
 
-                                @stack << { type: :string,
-                                            value: args[0][:type].to_s }
+                                @stack << Types.new_object( RplString, "\"#{args[0].class.to_s[10..-1]}\"" )
                               end )
 
         # @dictionary.add_word( ['std'],