haskell 0.2.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f7af12f3fa2dceabef05ccb39a3f7853c69ab0a
-  data.tar.gz: 93808939d0d3e5a156f03e826a6a79bdbb548b59
+  metadata.gz: ac0c087788b1e471523aed86d8dfd0c42be2503d
+  data.tar.gz: 610eff264b8bdc1903ea519e857a5346f461aad6
 SHA512:
-  metadata.gz: e1e2484689e7c753b2910b936391a3bcea009a48832855b8999ee2a74092215d50fb0747533e61fce8cc7895087539112ba38705f8d2336a03f01c16b2ff62c0
-  data.tar.gz: 00ffb2cb3a0786ca43a3701b396214cc29465573125bf949af52b210c9081d90338f48635924a23639f3e18c184bb6a0650ff7c05058e0c888a44b24c1a28c88
+  metadata.gz: 788e9b367f36ec0420f44fa89166768073332e8748aab5acd65f9c1796e1953367a2e9ed9bc5b738e0fdf53f6eb329237205e6a6dd819851f437b92264f7ccd5
+  data.tar.gz: ae3aa09d9fd3af02d5361bccc45f33d27f6e153b5f9a2a2810693493bd18c5fc8a33f4d35ccd5e19f6be4ff179346376f9533753fad70665614055f42081f174

data/README.md

@@ -1,107 +1,17 @@
-# Ruby with Type.
-
-Matz has mentioned Ruby3.0 with static type at some confluences. But almost all rubyists(include me) are not sure how typed Ruby is.
-
-But it's worth thinking more. This gem is kind of trial without so much side-effect.
+# Haskell On Ruby
 
 ```rb
 require 'haskell'
-
-# ex1
-class MyClass
-  def sum(x, y)
-    x + y
-  end
-  typesig sum: [Numeric, Numeric => Numeric]
-
-  def wrong_sum(x, y)
-    'string'
-  end
-  typesig wrong_sum: [Numeric, Numeric => Numeric]
+Haskell.compile %{
+  add :: Integer -> Integer -> Integer
+  add x y = x + y
+  result = add 1 2
+}
+
+while Haskell.compiling?
+...
 end
 
-MyClass.new.sum(1, 2)
+p Haskell.execute
 #=> 3
-
-MyClass.new.sum(1, 'string')
-#=> ArgumentError: Wrong type of argument, type of "str" should be Numeric
-
-MyClass.new.wrong_sum(1, 2)
-#=> TypeError: Expected wrong_sum to return Numeric but got "str" instead
-
-
-# ex2
-class People
-  type People >= Any, def marry(people)
-    # Your Ruby code as usual
-  end
-end
-typesig marry: [People => Any]
-
-People.new.marry(People.new)
-#=> no error
-
-People.new.marry('non people')
-#=> ArgumentError: Wrong type of argument, type of "non people" should be People
 ```
-
-## Feature
-### Typed method can coexist with non-typed method
-
-```ruby
-# It's totally OK!!
-class MyClass
-  def sum(x, y)
-    x + y
-  end
-  typesig sum: [Numeric, Numeric => Numeric]
-
-  def sum_without_type(x, y)
-    'string'
-  end
-end
-```
-
-### Duck typing
-
-```ruby
-
-class MyClass
-  def foo(any_obj)
-    1
-  end
-  typesig sum: [Any => Numeric]
-end
-
-# It's totally OK!!
-MyClass.new.foo(1)
-# It's totally OK!!
-MyClass.new.foo('str')
-```
-
-## Installation
-
-gem install haskell or add gem 'haskell' to your Gemfile.
-
-This gem requires Ruby 2.0.0+.
-
-### Contributing
-
-Fork it ( https://github.com/[my-github-username]/haskell/fork )
-
-Create your feature branch (`git checkout -b my-new-feature`)
-
-    $ bundle install --path vendor/bundle
-
-Commit your changes (`git commit -am 'Add some feature'`)
-
-    $ bundle exec rake test
-
-    > 5 runs, 39 assertions, 0 failures, 0 errors, 0 skips
-
-Push to the branch (`git push origin my-new-feature`)
-
-Create a new Pull Request
-
-## Credits
-[@chancancode](https://github.com/chancancode) first brought this to my attention. I've stolen some idea from him.

data/lib/haskell.rb

@@ -1,48 +1,73 @@
-# Builtin Contracts
-class  Any;     end
-module Boolean; end
-TrueClass.send(:include, Boolean)
-FalseClass.send(:include, Boolean)
-
-class Module
-  private
-  def __haskell__
-    prepend (@__haskell__ = Module.new) unless @__haskell__
-    @__haskell__
-  end
+module Haskell
+  # TODO:
+  class HaskellCompileError < StandardError; end
 
-  def typesig(hash)
-    meth = hash.keys.first
-    *arg_types, type_pair = hash.values.first
+  class << self
+    def invoke_sandbox!
+      file_path = File.expand_path('../', __FILE__)
+      $sandbox_path = "#{file_path}/haskell_executing_sandbox"
+      FileUtils.mkdir($sandbox_path) unless Dir.exist?($sandbox_path)
+    end
 
-    __haskell__.send(:define_method, meth) do |*args, &block|
-      ::Haskell.assert_arg_type(meth, args, arg_types << type_pair.keys.first)
-      rtn = super(*args, &block)
-      ::Haskell.assert_trn_type(meth, rtn, type_pair.values.first)
-      rtn
+    def revoke_sandbox!
+      FileUtils.rm_rf($sandbox_path)
     end
-    self
-  end
-end
 
-module Haskell
-  class << self
-    def assert_arg_type(meth, args, klasses)
-      args.each_with_index do |arg, i|
-        if wrong_type?(arg, klasses[i])
-          raise ArgumentError, "Wrong type of argument, type of #{arg.inspect} should be #{klasses[i]}"
+    def compile(hs_code)
+      FileUtils.touch("#{$sandbox_path}/COMPILING")
+      #TODO: need inform user prefer message
+      Thread.abort_on_exception = true
+      Thread.new do
+        begin
+          executable_code = executable_code(hs_code)
+          puts_notation(executable_code)
+          File.write("#{$sandbox_path}/tmp.hs", executable_code)
+          Kernel.system("ghc #{$sandbox_path}/tmp.hs")
+          raise HaskellCompileError unless compiled?
+        ensure
+          FileUtils.rm("#{$sandbox_path}/COMPILING")
         end
       end
+    rescue
+      raise "Something wrong...https://github.com/Azabuhs/Ruby/issues"
     end
 
-    def assert_trn_type(meth, rtn, klass)
-      if wrong_type?(rtn, klass)
-        raise TypeError, "Expected #{meth} to return #{klass} but got #{rtn.inspect} instead"
-      end
+    def compiling?
+      File.exist?("#{$sandbox_path}/COMPILING")
     end
 
-    def wrong_type?(obj, klass)
-      !(obj.is_a?(klass) || klass == Any)
+    def compiled?
+      File.exist?("#{$sandbox_path}/tmp")
+    end
+
+    def execute
+      `#{$sandbox_path}/tmp`.gsub(/\n\z/, '')
+    end
+
+  private
+
+    def executable_code(hs_code)
+      # TODO: other white space
+      hs_code =~/\A\n( *)/
+      hs_code.gsub!(/\n#{$1}/, "\n")
+<<-HASKELL_CODE
+module Main where
+#{hs_code}
+main = do putStrLn $ show result
+HASKELL_CODE
+    end
+
+    def puts_notation(executable_code)
+puts <<-NOTATION
+# GHC will compile below code
+###############################
+NOTATION
+
+puts '# ' + executable_code.gsub("\n", "\n# ")
+
+puts <<-NOTATION
+###############################
+NOTATION
     end
   end
 end

data/lib/haskell/version.rb

@@ -1,3 +1,3 @@
 module Haskell
-  VERSION = "0.2.3"
+  VERSION = "1.0.0"
 end

data/test/test_haskell.rb

@@ -0,0 +1,46 @@
+require 'minitest_helper'
+
+class TestHaskell < MiniTest::Unit::TestCase
+  def test_main
+    assert_equal_execute('3') {"
+      add :: Integer -> Integer -> Integer
+      add x y = x + y
+      result = add 1 2
+    "}
+
+    assert_equal_execute('[3.1415927,4.0]') {"
+      data Point = Pt Float Float deriving (Show)
+      data Shape = Circle Point Float | Rectangle Point Point deriving (Show)
+      surface :: Shape -> Float
+      surface (Circle _ r) | r > 0              = pi * r ^ 2
+                           | otherwise          = 0
+
+      surface (Rectangle (Pt x1 y1) (Pt x2 y2)) = (abs $ x2 - x1) * (abs $ y2 - y1)
+
+      result = [surface (Circle (Pt 0 0) 1), surface (Rectangle (Pt 2 3) (Pt 4 5))]
+    "}
+
+    assert_raise_compile_error {"
+      Error
+    "}
+  end
+
+  private
+    def assert_equal_execute(str, &block)
+      Haskell.invoke_sandbox!
+      Haskell.compile(block.call)
+      nil while Haskell.compiling?
+      assert_equal str, Haskell.execute
+      Haskell.revoke_sandbox!
+    end
+
+    def assert_raise_compile_error(&block)
+      Haskell.invoke_sandbox!
+      Haskell.compile(block.call)
+      nil while Haskell.compiling?
+    # TODO: more prefer test
+    rescue Haskell::HaskellCompileError
+      assert(true)
+      Haskell.revoke_sandbox!
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: haskell
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 1.0.0
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-07 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -85,7 +85,7 @@ files:
 - lib/haskell/version.rb
 - rubype.gemspec
 - test/minitest_helper.rb
-- test/test_rubype.rb
+- test/test_haskell.rb
 homepage: http://gogotanaka.me/
 licenses:
 - MIT
@@ -112,4 +112,4 @@ specification_version: 4
 summary: Ruby with type.
 test_files:
 - test/minitest_helper.rb
-- test/test_rubype.rb
+- test/test_haskell.rb

data/test/test_rubype.rb

@@ -1,107 +0,0 @@
-require 'minitest_helper'
-class TypePair
-  def to_s
-    "#{last_arg_type} => #{rtn_type}"
-  end
-end
-class TestHaskell < MiniTest::Unit::TestCase
-  def setup
-    @string  = 'str'
-    @numeric = 1
-    @symbol  = :test
-    @array   = [1, 2, 3]
-    @hash    = { test: :hash }
-  end
-
-  def test_correct_type
-    assert_correct_type [Numeric => Numeric], [@numeric], @numeric
-    assert_correct_type [Numeric => Array  ], [@numeric], @array
-    assert_correct_type [Numeric => String ], [@numeric], @string
-    assert_correct_type [Numeric => Hash   ], [@numeric], @hash
-    assert_correct_type [Numeric => Symbol ], [@numeric], @symbol
-    assert_correct_type [Numeric => Boolean], [@numeric], true
-    assert_correct_type [Numeric => Boolean], [@numeric], false
-
-    assert_correct_type [Boolean, Numeric => Numeric], [true, @numeric], @numeric
-    assert_correct_type [Boolean, Array   => Array  ], [true, @array  ], @array
-    assert_correct_type [Boolean, String  => String ], [true, @string ], @string
-    assert_correct_type [Boolean, Hash    => Hash   ], [true, @hash   ], @hash
-    assert_correct_type [Boolean, Symbol  => Symbol ], [true, @symbol ], @symbol
-  end
-
-  def test_wrong_return_type
-    assert_wrong_rtn [Numeric => Numeric], [@numeric], @array
-    assert_wrong_rtn [Numeric => Numeric], [@numeric], @string
-    assert_wrong_rtn [Numeric => Numeric], [@numeric], @hash
-    assert_wrong_rtn [Numeric => Numeric], [@numeric], @symbol
-    assert_wrong_rtn [Numeric => Numeric], [@numeric], true
-
-    assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], @array
-    assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], @string
-    assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], @hash
-    assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], @symbol
-    assert_wrong_rtn [Numeric, Numeric => Numeric], [@numeric, @numeric], true
-  end
-
-  def test_wrong_args_type
-    assert_wrong_arg [Numeric => Numeric], [@array ], @numeric
-    assert_wrong_arg [Numeric => Numeric], [@string], @numeric
-    assert_wrong_arg [Numeric => Numeric], [@hash  ], @numeric
-    assert_wrong_arg [Numeric => Numeric], [@symbol], @numeric
-    assert_wrong_arg [Numeric => Numeric], [true   ], @numeric
-
-    assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, @array ], @numeric
-    assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, @string], @numeric
-    assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, @hash  ], @numeric
-    assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, @symbol], @numeric
-    assert_wrong_arg [Numeric, Numeric => Numeric], [@numeric, true   ], @numeric
-  end
-
-  def test_any
-    assert_correct_type [Any => Any], [@array ], @numeric
-    assert_correct_type [Any => Any], [@string], @numeric
-    assert_correct_type [Any => Any], [@hash  ], @numeric
-    assert_correct_type [Any => Any], [@symbol], @numeric
-
-    assert_correct_type [Any, Any => Any], [@numeric, @array ], @numeric
-    assert_correct_type [Any, Any => Any], [@numeric, @string], @numeric
-    assert_correct_type [Any, Any => Any], [@numeric, @hash  ], @numeric
-    assert_correct_type [Any, Any => Any], [@numeric, @symbol], @numeric
-  end
-
-  private
-    def assert_equal_to_s(str, val)
-      assert_equal str, val.to_s
-    end
-
-    def assert_correct_type(type_list, args, val)
-      assert_equal val, define_test_method(type_list, args, val).call(*args)
-    end
-
-    def assert_wrong_arg(type_list, args, val)
-      assert_raises(ArgumentError) { define_test_method(type_list, args, val).call(*args) }
-    end
-
-    def assert_wrong_rtn(type_list, args, val)
-      assert_raises(TypeError) { define_test_method(type_list, args, val).call(*args) }
-    end
-
-    def define_test_method(type_list, args, val)
-      klass = Class.new.class_eval <<-RUBY_CODE
-        def call(#{arg_literal(args.count)})
-          #{obj_literal(val)}
-        end
-        typesig call: #{obj_literal(type_list)}
-      RUBY_CODE
-
-      klass.new
-    end
-
-    def obj_literal(obj)
-      "ObjectSpace._id2ref(#{obj.__id__})"
-    end
-
-    def arg_literal(count)
-      ('a'..'z').to_a[0..count-1].join(',')
-    end
-end