crystalruby 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db2722469a6d98fb5696b55dd0980337db19ce92fde42b4c1c023cfa6fd877d0
-  data.tar.gz: a2914be29451a124cca3dcdd83173e8f4713c5e1dbd1121c1c4179e6e8a55ea6
+  metadata.gz: 157d03e574c1ef5e06073e71c29e259741c26373113f2ae51c692b4aaef429f9
+  data.tar.gz: 94c1f670b52a39b78c961a3050c2587c540a1cb1593c30e87d6bd05d90a4d736
 SHA512:
-  metadata.gz: 9253f9b6b953021570fb31ee958e4ca2c798d3e586d5be8da59d5f26b895f1bce22672bbb1c0c14322732d61d9c4fe780d6833d9410d9e16732683862fd3330f
-  data.tar.gz: d14edd179ed85907f90038b303f409a6c3868b2cf2bbfd60695350886d67ee5bf9d98b2ee3e1d05421e3d55b9b3ce155f7d9b0d04d2c6bee0165f36e1598abc7
+  metadata.gz: 1b7972639977a290fd9a42b737edd1f3eec28a240a6e0e773619190bf646ec0707520d317ddf6e6152f507753b16fa66db0d2903c18fd23e58ebce4422e02555
+  data.tar.gz: bc3d03de05c21a14a6d6d9b6de76ff04efcd660999c0dd2c166cc306707d0f93be01053e34ba8a531c9e0a9154e887bb1c6796b141564e290e25d537eeab88b4

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [0.1.3] - 2024-04-10
+
+- Support exceptions thrown in Crystal being caught in Ruby
+- Support complex Ruby type passing (while preserving type checking), using `JSON` as serialization format.
+
 ## [0.1.0] - 2024-04-07
 
 - Initial release

data/README.md

@@ -1,6 +1,6 @@
-# CrystalRuby
+# crystalruby
 
-Crystal Ruby is a gem that allows you to write Crystal code, inlined in Ruby. All you need is a modern crystal compiler installed on your system.
+`crystalruby` is a gem that allows you to write Crystal code, inlined in Ruby. All you need is a modern crystal compiler installed on your system.
 
 You can then turn simple methods into Crystal methods as easily as demonstrated below:
 
@@ -120,8 +120,10 @@ end
 
 ## Types
 
-Currently only primitive types are supported. Structures are a WIP.
-To see the list of currently supported type mappings of FFI types to crystal types, you can check: `CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP`
+Currently primitive types are supported.
+Composite types are supported using JSON serialization.
+C-Structures are a WIP.
+To see the list of currently supported primitive type mappings of FFI types to crystal types, you can check: `CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP`
 E.g.
 
 ```ruby
@@ -151,7 +153,54 @@ CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP
  :string=>"String"}
 ```
 
-### Installing shards and writing non-embedded Crystal code
+## Composite Types (using JSON serialization)
+
+The library allows you to pass complex nested structures using JSON as a serialization format.
+The type signatures for composite types can use ordinary Crystal Type syntax.
+Type conversion is applied automatically.
+
+E.g.
+
+```ruby
+crystalize [a: json{ Int64 | Float64 | Nil }, b: json{ String | Array(Bool)  } ] => :void
+def complex_argument_types
+  puts "Got #{a} and #{b}"
+end
+
+crystalize [] => json{ Int32 | String | Hash(String, Array(NamedTuple(hello: Int32)) | Time)}
+def complex_return_type
+  return {
+    "hello" => [
+      {
+        hello: 1,
+      },
+    ],
+    "world" => Time.utc
+  }
+end
+```
+
+Type signatures validations are applied to both arguments and return types.
+
+```ruby
+[1] pry(main)> Foo.complex_argument_types(nil, "test")
+Got  and test
+=> nil
+
+[2] pry(main)> Foo.complex_argument_types(88, [true, false, true])
+Got 88 and [true, false, true]
+=> nil
+
+[3] pry(main)> Foo.complex_argument_types(88, [true, false, 88])
+ArgumentError: Expected Bool but was Int at line 1, column 15
+from crystalruby.rb:303:in `block in compile!'
+```
+
+## Exceptions
+
+Exceptions thrown in Crystal code can be caught in Ruby.
+
+## Installing shards and writing non-embedded Crystal code
 
 You can use any Crystal shards and write ordinary, stand-alone Crystal code.
 
@@ -169,6 +218,60 @@ Remember to require these installed shards after installing them. E.g. inside `.
 
 You can edit the default paths for crystal source and library files from within the `./crystalruby.yaml` config file.
 
+### Wrapping Crystal code in Ruby
+
+Sometimes you may want to wrap a Crystal method in Ruby, so that you can use Ruby before the Crystal code to prepare arguments, or after the Crystal code, to apply transformations to the result. A real-life example of this might be an ActionController method, where you might want to use Ruby to parse the request, perform auth etc., and then use Crystal to perform some heavy computation, before returning the result from Ruby.
+To do this, you simply pass a block to the `crystalize` method, which will serve as the Ruby entry point to the function. From within this block, you can invoke `super` to call the Crystal method, and then apply any Ruby transformations to the result.
+
+```ruby
+module MyModule
+  crystalize [a: :int32, b: :int32] => :int32 do |a, b|
+    # In this example, we perform automated conversion to integers inside Ruby.
+    # Then add 1 to the result of the Crystal method.
+    result = super(a.to_i, b.to_i)
+    result + 1
+  end
+  def add(a, b)
+    a + b
+  end
+end
+
+MyModule.add("1", "2")
+```
+
+### Release Builds
+
+You can control whether CrystalRuby builds in debug or release mode by setting following config option
+
+```ruby
+CrystalRuby.configure do |config|
+  config.debug = false
+end
+```
+
+By default, Crystal code is only JIT compiled. In production, you likely want to compile the Crystal code ahead of time. To do this, you can create a dedicated file which
+
+- Preloads all files Ruby code with embedded crystal
+- Forces compilation.
+
+E.g.
+
+```ruby
+# E.g. crystalruby_build.rb
+require "crystalruby"
+
+CrystalRuby.configure do |config|
+  config.debug = false
+end
+
+require_relative "foo"
+require_relative "bar"
+
+CrystalRuby.compile!
+```
+
+Then you can run this file as part of your build step, to ensure all Crystal code is compiled ahead of time.
+
 ### Troubleshooting
 
 The logic to detect when to JIT recompile is not robust and can end up in an inconsistent state. To remedy this it is useful to clear out all generated assets and build from scratch.
@@ -179,6 +282,26 @@ To do this execute:
 bundle exec crystalruby clean
 ```
 
+## Design Goals
+
+`crystalruby`'s primary purpose is provide ergonomic access to Crystal from Ruby, over FFI.
+For simple usage, advanced knowledge of Crystal should not be required.
+
+However, the abstraction it provides should remain simple, transparent, and easy to hack on and it should not preclude users from supplementing its capabilities with a more direct integration using ffi primtives.
+
+It should support escape hatches to allow it to coexist with code that performs a more direct [FFI](https://github.com/ffi/ffi) integration to implement advanced functionality not supported by `crystalruby`.
+
+The library is currently in its infancy. Planned additions are:
+
+- Replace existing checksum process, with one that combines results of inline and external crystal to more accurately detect when recompilation is necessary.
+- Support for automatic serialization of nested data structures (holding _ONLY_ primitives), using JSON as our serialization protocol (prioritizing portability over raw serialization performance. JSON generation and parsing is bundled into the stdlib in both languages).
+- Simple mixin/concern that utilises `FFI::Struct` for bi-directional passing of Ruby objects and Crystal objects (by value).
+- Install command to generate a sample build script, and supports build command (which simply verifies then invokes this script)
+- Call Ruby from Crystal using FFI callbacks (implement `.expose_to_crystal`)
+- Support long-lived synchronized objects (through use of synchronized memory arena to prevent GC).
+- Support for passing `crystalruby` types by reference (need to contend with GC).
+- Explore mechanisms to safely expose true parallelism using [FFI over Ractors](https://github.com/ffi/ffi/wiki/Ractors)
+
 ## Installation
 
 To get started, add this line to your application's Gemfile:
@@ -199,7 +322,7 @@ Or install it yourself as:
 $ gem install crystalruby
 ```
 
-Crystal Ruby requires some basic initialization options inside a crystalruby.yaml file in the root of your project.
+`crystalruby` requires some basic initialization options inside a crystalruby.yaml file in the root of your project.
 You can run `crystalruby init` to generate a configuration file with sane defaults.
 
 ```bash
@@ -221,7 +344,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/crystalruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/crystalruby/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/wouterken/crystalruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/wouterken/crystalruby/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -229,4 +352,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Crystalruby project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/crystalruby/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the `crystalruby` project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/wouterken/crystalruby/blob/master/CODE_OF_CONDUCT.md).

data/crystalruby.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "Embed Crystal code directly in Ruby."
   spec.homepage = "https://github.com/wouterken/crystalruby"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
+  spec.required_ruby_version = ">= 2.7.2"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
@@ -32,10 +32,10 @@ Gem::Specification.new do |spec|
 
   # Uncomment to register a new dependency of your gem
   # spec.add_dependency "example-gem", "~> 1.0"
-  spec.add_dependency 'ffi'
-  spec.add_dependency 'digest'
-  spec.add_dependency 'fileutils'
-  spec.add_dependency 'method_source'
+  spec.add_dependency "digest"
+  spec.add_dependency "ffi"
+  spec.add_dependency "fileutils"
+  spec.add_dependency "method_source"
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
 end

data/exe/crystalruby

@@ -13,6 +13,7 @@ def init
     crystal_lib_dir: "./crystalruby/lib"
     crystal_main_file: "main.cr"
     crystal_lib_name: "crlib"
+    crystal_codegen_dir: "generated"
   YAML
 
   # Create the file at the root of the current directory

data/lib/crystalruby/config.rb

@@ -1,5 +1,5 @@
-require 'singleton'
-require 'yaml'
+require "singleton"
+require "yaml"
 
 module CrystalRuby
   def self.config
@@ -9,15 +9,20 @@ module CrystalRuby
   # Define a nested Config class
   class Config
     include Singleton
-    attr_accessor :debug, :crystal_src_dir, :crystal_lib_dir, :crystal_main_file, :crystal_lib_name
+    attr_accessor :debug, :crystal_src_dir, :crystal_lib_dir, :crystal_main_file, :crystal_lib_name, :crystal_codegen_dir
 
     def initialize
-      # Set default configuration options
       @debug = true
-      if File.exist?("crystalruby.yaml")
-        @crystal_src_dir, @crystal_lib_dir, @crystal_main_file, @crystal_lib_name =
-        YAML.safe_load_file("crystalruby.yaml").values_at("crystal_src_dir","crystal_lib_dir","crystal_main_file", "crystal_lib_name")
+      config = if File.exist?("crystalruby.yaml")
+        YAML.safe_load(IO.read("crystalruby.yaml")) rescue {}
+      else
+        {}
       end
+      @crystal_src_dir     = config.fetch("crystal_src_dir", "./crystalruby/src")
+      @crystal_lib_dir     = config.fetch("crystal_lib_dir", "./crystalruby/lib")
+      @crystal_main_file   = config.fetch("crystal_main_file", "main.cr")
+      @crystal_lib_name    = config.fetch("crystal_lib_name", "crlib")
+      @crystal_codegen_dir = config.fetch("crystal_codegen_dir", "generated")
     end
   end
 

data/lib/crystalruby/template.rb

@@ -0,0 +1,13 @@
+require 'pry-byebug'
+module CrystalRuby
+  module Template
+    Dir[File.join(File.dirname(__FILE__), "templates", "*.cr")].each do |file|
+      template_name = File.basename(file, File.extname(file)).capitalize
+      const_set(template_name, File.read(file))
+    end
+
+    def self.render(template, context)
+      template % context
+    end
+  end
+end

data/lib/crystalruby/templates/function.cr

@@ -0,0 +1,20 @@
+module %{module_name}
+  def self.%{fn_name}(%{fn_args}) : %{fn_ret_type}
+    %{fn_body}
+  end
+end
+
+fun %{lib_fn_name}(%{lib_fn_args}): %{lib_fn_ret_type}
+  begin
+    %{convert_lib_args}
+    begin
+      return_value = %{module_name}.%{fn_name}(%{arg_names})
+      return %{convert_return_type}
+    rescue ex
+      CrystalRuby.report_error("RuntimeError", ex.message.to_s)
+    end
+  rescue ex
+    CrystalRuby.report_error("ArgumentError", ex.message.to_s)
+  end
+  return %{error_value}
+end

data/lib/crystalruby/templates/index.cr

@@ -0,0 +1,38 @@
+FAKE_ARG = "crystal"
+alias Callback = (Pointer(UInt8), Pointer(UInt8) -> Void)
+
+module CrystalRuby
+  @@initialized = false
+  def self.init
+    if @@initialized
+      return
+    end
+    @@initialized = true
+    GC.init
+    ptr = FAKE_ARG.to_unsafe
+    LibCrystalMain.__crystal_main(1, pointerof(ptr))
+  end
+
+  def self.attach_rb_error_handler(cb : Callback)
+    @@rb_error_handler = cb
+  end
+
+  def self.report_error(error_type : String, str : String)
+    handler = @@rb_error_handler
+    if handler
+      handler.call(error_type.to_unsafe, str.to_unsafe)
+    end
+  end
+end
+
+
+fun init(): Void
+  CrystalRuby.init
+end
+
+fun attach_rb_error_handler(cb : Callback) : Void
+  CrystalRuby.attach_rb_error_handler(cb)
+end
+
+%{type_modules}
+%{requires}

data/lib/crystalruby/typebuilder.rb

@@ -0,0 +1,179 @@
+require_relative "types"
+
+module CrystalRuby
+  module TypeBuilder
+    module_function
+
+    def with_injected_type_dsl(context, &block)
+      with_constants(context) do
+        with_methods(context, &block)
+      end
+    end
+
+    def with_methods(context)
+      restores = []
+      %i[Array Hash NamedTuple Tuple].each do |method_name|
+        old_method = begin
+          context.instance_method(method_name)
+        rescue StandardError
+          nil
+        end
+        restores << [context, method_name, old_method]
+        context.define_singleton_method(method_name) do |*args|
+          Types.send(method_name, *args)
+        end
+      end
+      yield
+    ensure
+      restores.each do |context, method_name, old_method|
+        context.define_singleton_method(method_name, old_method) if old_method
+      end
+    end
+
+    def with_constants(context)
+      previous_const_pairs = CrystalRuby::Types.constants.map do |type|
+        [type, begin
+          context.const_get(type)
+        rescue StandardError
+          nil
+        end]
+      end
+      CrystalRuby::Types.constants.each do |type|
+        begin
+          context.send(:remove_const, type)
+        rescue StandardError
+          nil
+        end
+        context.const_set(type, CrystalRuby::Types.const_get(type))
+      end
+      yield
+    ensure
+      previous_const_pairs.each do |const_name, const_value|
+        begin
+          context.send(:remove_const, const_name)
+        rescue StandardError
+          nil
+        end
+        context.const_set(const_name, const_value)
+      end
+    end
+
+    def build
+      result = yield
+      Types::Type.validate!(result)
+      Types::Typedef(result)
+    end
+  end
+end
+
+# class UnionType
+#   attr_reader :inner
+
+#   def initialize(*inner)
+#     @inner = inner
+#   end
+
+#   def |(other)
+#     UnionType.new(*inner, *other.inner)
+#   end
+
+#   def inspect
+#     elements = inner.map(&:inspect).join(" | ")
+#   end
+# end
+
+# class Type
+#   attr_reader :inner, :contains
+
+#   def initialize(name)
+#     @name = name
+#     @contains = contains
+#     @inner = [self]
+#   end
+
+#   def |(other)
+#     UnionType.new(*inner, *other.inner)
+#   end
+
+#   def inspect
+#     if @contains
+#       "#{@name}(#{@contains.inspect})"
+#     else
+#       @name
+#     end
+#   end
+# end
+
+# module_function
+
+# %w[
+#   Bool Uint8 Uint16 Uint32 Uint64 Int8 Int16 Int32 Int64 Float32 Float64 String Time Symbol
+#   Null
+# ].map do |t|
+#   cls = Class.new(Type)
+#   const_set(t, cls)
+#   define_method(t.downcase) do
+#     cls.new(t)
+#   end
+# end
+
+# def build(&blk)
+#   instance_exec(&blk)
+# end
+
+# def hash(key_type, value_type)
+#   Hash.new(key_type, value_type)
+# end
+
+# def array(type)
+#   Array.new(type)
+# end
+
+# def tuple(*types)
+#   Tuple.new(*types)
+# end
+
+# def named_tuple(type_hash)
+#   NamedTuple.new(type_hash)
+# end
+
+# def NamedTuple(type_hash)
+#   NamedTuple.new(type_hash)
+# end
+
+# class Hash < Type
+#   HASH_KEY_TYPES = %w[String Symbol].freeze
+#   def initialize(key_type, value_type)
+#     super("Hash")
+#     @key_type = key_type
+#     @value_type = value_type
+#     raise "Invalid key type" unless [Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,
+#                                      String].include?(key_type)
+#     raise "Invalid value type" unless value_type.is_a?(Type)
+#   end
+# end
+
+# class Array < Type
+#   def initialize(value_type)
+#     super("Array")
+#     @value_type = value_type
+#     raise "Invalid value type" unless value_type.is_a?(Type)
+#   end
+# end
+
+# class NamedTuple < Type
+#   def initialize(types_hash)
+#     raise "keys must be symbols" unless types_hash.keys.all? { |k| k.is_a?(Symbol) }
+#     raise "Invalid value type" unless types_hash.values.all? { |v| v.is_a?(Type) }
+
+#     super("NamedTuple")
+#     @types_hash = types_hash
+#   end
+# end
+
+# class Tuple < Type
+#   def initialize(*value_types)
+#     super("Tuple")
+#     raise "Invalid value type" unless value_types.all? { |v| v.is_a?(Type) }
+#   end
+# end

data/lib/crystalruby/typemaps.rb

@@ -26,6 +26,32 @@ module CrystalRuby
       :string => "String"     # String type
     }
 
+    ERROR_VALUE = {
+      :char => "0",        # In Crystal, :char is typically represented as Int8
+      :uchar => "0",      # Unsigned char
+      :int8 => "0",        # Same as :char
+      :uint8 => "0",      # Same as :uchar
+      :short => "0",      # Short integer
+      :ushort => "0",    # Unsigned short integer
+      :int16 => "0",      # Same as :short
+      :uint16 => "0",    # Same as :ushort
+      :int => "0",        # Integer, Crystal defaults to 32 bits
+      :uint => "0",      # Unsigned integer
+      :int32 => "0",      # 32-bit integer
+      :uint32 => "0",    # 32-bit unsigned integer
+      :long => "0", # Long integer, size depends on the platform (32 or 64 bits)
+      :ulong => "0", # Unsigned long integer, size depends on the platform
+      :int64 => "0",      # 64-bit integer
+      :uint64 => "0",    # 64-bit unsigned integer
+      :long_long => "0",  # Same as :int64
+      :ulong_long => "0", # Same as :uint64
+      :float => "0.0",    # Floating point number (single precision)
+      :double => "0.0",   # Double precision floating point number
+      :bool => "false",        # Boolean type
+      :void => "Void",        # Void type
+      :string => '""'     # String type
+    }
+
     C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge({
       :string => "UInt8*"
     })

data/lib/crystalruby/types/array.rb

@@ -0,0 +1,14 @@
+module CrystalRuby::Types
+  Array = Type.new(
+    :Array,
+    error: "Array type must have a type parameter. E.g. Array(Float64)"
+  )
+
+  def self.Array(type)
+    Type.validate!(type)
+    Type.new("Array", inner_types: [type], accept_if: [::Array]
+    ) do |a|
+      a.map!{|v| type.interpret!(v) }
+    end
+  end
+end

data/lib/crystalruby/types/bool.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  Bool = Type.new(:Bool, accept_if: [::TrueClass, ::FalseClass])
+end

data/lib/crystalruby/types/hash.rb

@@ -0,0 +1,15 @@
+module CrystalRuby::Types
+  Hash = Type.new(
+    :Hash,
+    error: "Hash type must have 2 type parameters. E.g. Hash(Float64, String)",
+  )
+
+  def self.Hash(key_type, value_type)
+    Type.validate!(key_type)
+    Type.validate!(value_type)
+    Type.new("Hash", inner_types: [key_type, value_type], accept_if: [::Hash]) do |h|
+      h.transform_keys!{|k| key_type.interpret!(k) }
+      h.transform_values!{|v| value_type.interpret!(v) }
+    end
+  end
+end

data/lib/crystalruby/types/named_tuple.rb

@@ -0,0 +1,25 @@
+module CrystalRuby::Types
+  NamedTuple = Type.new(
+    :NamedTuple,
+    error: "NamedTuple type must contain one or more symbol -> type pairs. E.g. NamedTuple(hello: Int32, world: String)"
+  )
+
+  def self.NamedTuple(types_hash)
+    types_hash.keys.each do |key|
+      raise "NamedTuple keys must be symbols" unless key.kind_of?(::Symbol) || key.respond_to?(:to_sym)
+    end
+    types_hash.values.each do |value_type|
+      Type.validate!(value_type)
+    end
+    keys = types_hash.keys.map(&:to_sym)
+    values = types_hash.values
+    Type.new("NamedTuple", inner_types: values, inner_keys: keys, accept_if: [::Hash]) do |h|
+      h.transform_keys!{|k| k.to_sym }
+      raise "Invalid keys for named tuple" unless h.keys.length == keys.length
+      raise "Invalid keys for named tuple" unless h.keys.all?{|k| keys.include?(k)}
+      h.each do |key, value|
+        h[key] = values[keys.index(key)].interpret!(value)
+      end
+    end
+  end
+end

data/lib/crystalruby/types/nil.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  Nil = Type.new(:Nil, accept_if: [::NilClass])
+end

data/lib/crystalruby/types/numbers.rb

@@ -0,0 +1,5 @@
+module CrystalRuby::Types
+  %i[Uint8 Uint16 Uint32 Uint64 Int8 Int16 Int32 Int64 Float32 Float64].each do |type_name|
+    const_set type_name, Type.new(type_name, accept_if: [::Numeric])
+  end
+end

data/lib/crystalruby/types/string.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  String = Type.new(:String, accept_if: [::String])
+end

data/lib/crystalruby/types/symbol.rb

@@ -0,0 +1,3 @@
+module CrystalRuby::Types
+  Symbol = Type.new(:Symbol, accept_if: [::String, ::Symbol])
+end

data/lib/crystalruby/types/time.rb

@@ -0,0 +1,6 @@
+module CrystalRuby::Types
+  require 'date'
+  Time = Type.new(:Time, accept_if: [::Time, ::String]) do |v|
+    DateTime.parse(v)
+  end
+end

data/lib/crystalruby/types/tuple.rb

@@ -0,0 +1,15 @@
+module CrystalRuby::Types
+  Tuple = Type.new(
+    :Tuple,
+    error: "Tuple type must contain one or more types E.g. Tuple(Int32, String)"
+  )
+
+  def self.Tuple(*types)
+    types.each do |value_type|
+      Type.validate!(value_type)
+    end
+    Type.new("Tuple", inner_types: types, accept_if: [::Array]) do |a|
+      a.map!.with_index{|v, i| self.inner_types[i].interpret!(v) }
+    end
+  end
+end