typed.rb 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10a8acbaa2e89eb19d043a4b29ccc1a9e9f58712
-  data.tar.gz: 5cfd5c3ee30993b30d82558d168c675c2fe6b859
+  metadata.gz: bb42b861c759a6aaa03b52fd351f5a1615d5232a
+  data.tar.gz: 1d76b7a85bdd7758d28b54a1506734c123e2384c
 SHA512:
-  metadata.gz: 3233c50ea7798b565d1b5a24ded1a608a5b018821e47b390788ceb3108d183970a726622c973e31f3fbbae64d33faf70fe3bc376888a134df62d2772500a19e7
-  data.tar.gz: 8b0e4212b51a79d643e682618cbbee275a4dbeb2f762d9aeabc14c633f2a1e682e948a5a23c31ebe26a78d889bcf9f56f0a3304cadccd7c4a53d71e4f2e7ab27
+  metadata.gz: 133005549d678a09477e777dc944e6cc3300bd89fee267f529d92986e20757170d4005dfa0385b4ec4722507458f0b52d2315f6355dcbac2aea135c1ac09bd83
+  data.tar.gz: 6bcbbe9cb52ffd37a466fec62fae0a11d6e14c04f25e3c66e4b4918c283f4d70faed9eb2e43210cc7cec08fac76234c543989ade1933791eed743e47850fd331

data/README.md

@@ -1,4 +1,4 @@
-#Typed.rb [![Build Status](https://circleci.com/gh/antoniogarrote/typed.rb.png?circle-token=:circle-token)](https://circleci.com/gh/antoniogarrote/typed.rb/tree/master)
+#Typed.rb [![Build Status](https://circleci.com/gh/antoniogarrote/typed.rb.png?circle-token=:circle-token)](https://circleci.com/gh/antoniogarrote/typed.rb/tree/master) [![Coverage Status](https://coveralls.io/repos/github/antoniogarrote/typed.rb/badge.svg?branch=master)](https://coveralls.io/github/antoniogarrote/typed.rb?branch=master)
 
 Gradual type checker for Ruby.
 
@@ -15,7 +15,7 @@ module Monoid
 
   ts '#mempty / -> [T]'
   abstract(:mempty)
-  
+
 end
 
 
@@ -53,3 +53,108 @@ end
   moncat([1,2,3], Sum.new)
 }
 ```
+
+
+## Introduction
+
+Typed.rb is an attempt to build a gradual type checker for the Ruby programming language.
+
+Typed.rb provides a mechanism to add type annotations to Ruby program's classes, modules and methods, and makes it possible to type-check the annotated code statically.
+Types annotations has no impact on performance during the execution of the program. Typed ruby code is valid regular ruby code.
+Typed.rb leverages gradual typing for Ruby, this means that typed and untyped code can be freely mixed.
+
+In it's current implementation Typed.rb includes the following components:
+
+- A type signature language to annotate classes, modules and methods.
+- A small run-time library that introduces a few extensions to ruby core types, like the type annotations method or the application of type parameters, it introduces some new types like Boolean and Pair and the notion of abstract methods.
+- Type annotations for the Ruby Standard Library.
+- A gradual type checker that can be executed statically to check the provided annotations.
+
+Typed.rb tries to typecheck most of the static subset of Ruby with as few type annotations as possible, however, due to the highly dynamic nature of Ruby some compromises need to be made and the whole dynamic set of the language, say, dynamically evaluated methods and classes cannot be type-checked.
+
+Typed.rb is still an ongoing effort and should be considered pre-alpha.
+
+
+## Type system
+
+Typed.rb type system's matches Ruby type system with a few exceptions:
+
+- A ```unit``` matching the runtime ```NilClass``` class has been added to the type signature language. It is inhabited by a single instalce ```nil``` and it's a subclass of all other types. ```unit``` must always be used in type signatures
+- A ```dynamic``` type that by-passes type checking will be generated byt the type-checker when no typing information is available for a given method or type. Type checking untyped code will produce the ```dynamic``` type as a result. ```dynamic``` must never diractely used in a type annotation.
+- A ```Boolean ``` type has been added inhabited by only two values ```true``` and ```false``` and matching both run-time classes ```TrueClass``` and ```FalseClass``` has been added to the type signature language. ```Boolean``` must always be used in type signatures
+- A polymorphic ```Pair[T][U]``` extending ```Array``` type has been added to the type signature language and to the runtime. Function and blocks receiving or returning arrays of two elements can be annotated as using the ```Pair``` type
+- A ```Showable``` type with no methods has been added as mixin into the ```String``` and ```Symbol``` class and can be used to annotate methods receiving an instance of any of these two classes
+
+
+## Type annotations
+
+To introduce a new type annotation, the ```BasicObject#ts``` method can be used. They can appear in any part of the source code without taking in cosideration the location of the method being annotated, however as a rule, we try to add the type annotation before the definition of the method being annotated.
+The method receives a string with the type signature and returns unit. At run-time the method is a noop.
+
+A type signature for a method is composed of the following parts:
+
+```
+Type?(#/.)method[T]* / ArgumentType? (-> ArgumentType)* -> &BlockType? -> ReturnType
+```
+
+For example, the type signature of the ```#ts``` method itself is ```BasicObject#ts / String -> unit```.
+
+The main components of a type signature are:
+
+- ```Type``` (optional), type the method belongs to. If the type part of the signature is ommitted, the current wrapping class or module is considered to be the target of the method
+- ```(#/.)``` instance/class indicator. Instance level methods are prefixed with ```#```, class level methods are prefixed with ```.```
+- ```method``` message this method is handling
+- ```[T]*``` method type variables for polymorphic methods
+- ```/``` signature separator, a fixed character ```/``` separating the method information from the actual type arguments and return type information
+- ```ArgumentType? (-> ArgumentType)* -> ReturnType``` an arrow (```->```) separated list of types representing the types of the input arguments and the output type of the method
+
+If the method has no input arguments, the only return type can be expressed with a type with an initial ```->```. For example, a method with no arguments and returning ```nil``` can be expressed as ```-> unit```.
+Higher order methods accepting procs or lambdas as inputs can be expressed between parentheses ```(ArgumentType? (-> ArgumentType)* -> ReturnType)```. Methods yielding a block can be expressed with final input argument of function type prefixed with a ```&```.
+For example, the ```Enumerable#map``` method from the Ruby Standard Library accepting a block and parametric on the return value of that block has the following type annotation:
+
+```
+ts '#map[E] / &([T] -> [E]) -> Array[E]'
+```
+
+Methods accepting a variable number of arguments can be expressed using a suffix ellipsis ```...``` after the type of the vararg type. For instance, a method adding any number of integers could be expressed with the following type annotation:
+
+```
+ts '#my_sum / Integer... -> Integer'
+```
+
+More than one type annotation can be provided for the same method, but the arity of the annotations must be unique. Optional blocks are taking into consideration to compute the arity of the annotation.
+
+In order to annotate classes and modules, the ```BasicObject#ts``` method is also used. Again, the type annotation can appear in any location of the source code but by convention we try to locate them before the implementation of the type if it is available.
+
+Type annotations are only required for polymorphic types.
+
+The type signature for a class/module has the following components:
+
+```
+type TypeName[T]? (super BaseType[U]*)?
+```
+
+- ```type``` prefix for all type annotations
+- ```TypeName``` name of the class/module
+- ```[T]*``` type variables for the polymorphic type
+- ```(super BaseType[U]*)?``` base polymorphic class/module for the type
+
+
+## Type inference and minimal typing
+
+Typed.rb will try to perform automatic type inference for the following language constructs and don't need to be annotated:
+
+- global variables
+- instance variables
+- local variables
+- constants
+
+To know more about the type inferance mechanism, check the implementation of the unification algorithm used by the type checker in ```lib/typed/types/polymorphism/unification.rb```.
+
+Class and modules only need to be annotated if they are defined as polymorphic. All methods must be annotated.
+
+## Running the type-checker
+
+To execute the type checker, the ```bin/typed.rb``` script can be used. The script accepts a list of options and path to the entry-point of the source code to be type-checked. Currently the only option available is ```--missing-type``` that will force the type-checker to produce a warning every single time a default dynamic type is introduced due to lack of typing information.
+
+The script will produce some error report output and return an appropriate exit value according to the result of the the check.

data/lib/typed/language.rb

@@ -87,6 +87,7 @@ module TypedRb
       TypingContext.clear(:top_level)
       check_result = nil
       errors = {}
+      errors_accum = {}
       ordered_files.each do |file|
         $TYPECHECK_FILE = file
         expr = File.open(file, 'r').read
@@ -95,9 +96,13 @@ module TypedRb
           print '.'.green
         rescue TypedRb::Types::UncomparableTypes, TypedRb::TypeCheckError => e
           print 'E'.red
-          errors_for_file = errors[file] || []
-          errors_for_file << e
-          errors[file] = errors_for_file
+          hash = e.to_s.hash
+          unless errors_accum[hash]
+            errors_accum[hash] = true
+            errors_for_file = errors[file] || []
+            errors_for_file << e
+            errors[file] = errors_for_file
+          end
         end
       end
       top_level_errors = []
@@ -105,8 +110,12 @@ module TypedRb
         ::BasicObject::TypeRegistry.check_super_type_annotations
         @unification_result = run_unification
       rescue TypedRb::Types::UncomparableTypes, TypedRb::TypeCheckError => e
-        print 'E'.red
-        top_level_errors << e
+        hash = e.to_s.hash
+        unless errors_accum[hash]
+          errors_accum[hash] = true
+          print 'E'.red
+          top_level_errors << e
+        end
       end
       puts "\n"
       total_errors = all_errors(top_level_errors, errors)
@@ -134,8 +143,12 @@ module TypedRb
           puts error.message.red
         end
         warnings_for_file.each do |warning|
-          puts "\n"
-          puts warning.message.yellow
+          hash = warning.to_s.hash
+          unless errors_accum[hash]
+            errors_accum[hash] = true
+            puts "\n"
+            puts warning.message.yellow
+          end
         end
       end
       top_level_errors.each do |error|

data/lib/typed/model/tm_fun.rb

@@ -87,7 +87,7 @@ module TypedRb
           function_arg_type = function_type.from[i]
           # Generic arguments are parsed by runtime without checking constraints since they are not available at parsing type.
           # We need to run unification in them before using the type to detect invalid type argument applications.
-          function_arg_type = function_arg_type.self_materialize if function_arg_type.is_a?(Types::TyGenericSingletonObject)
+          function_arg_type = function_arg_type.self_materialize.as_object_type if function_arg_type.is_a?(Types::TyGenericSingletonObject)
           context = case arg.first
                     when :arg, :restarg
                       context.add_binding(arg[1], function_arg_type)
@@ -157,8 +157,9 @@ module TypedRb
         # TODO:
         # A TyObject(Symbol) should be returned not the function type
         # x = def id(x); x; end / => x == :id
-        error_message = "Error type checking function type #{owner}##{name}: Wrong return type, expected #{function_type.to}, found #{body_return_type}."
-        fail Types::UncomparableTypes.new(function_type.to, body_return_type, node)
+        error_message = ". Wrong return type, expected #{function_type.to}, found #{body_return_type}."
+        body_return_type.compatible?(function_type_to, :lt)
+        fail Types::UncomparableTypes.new(function_type.to, body_return_type, node, error_message)
       end
     end
   end

data/lib/typed/prelude.rb

@@ -21,6 +21,7 @@ class BasicObject
   ts '#singleton_method_undefined / Symbol -> unit'
   ts '#ts / String -> unit'
   ts '#cast / BasicObject -> BasicObject -> BasicObject'
+  ts '#abstract / Symbol -> Symbol'
 end
 
 class Object

data/lib/typed/runtime.rb

@@ -24,7 +24,6 @@ class BasicObject
     from
   end
 
-  ts '#abstract / Symbol -> Symbol'
   def abstract(name)
     define_method(name) { |*args| raise "Invoking abstract method #{name}"}
   end

data/lib/typed/types/polymorphism/type_variable.rb

@@ -44,8 +44,6 @@ module TypedRb
         def compatible?(type, relation = :lt)
           if @bound
             @bound.compatible?(type, relation)
-          elsif incompatible_vars?(type)
-            false
           else
             add_constraint(relation, type)
             true
@@ -117,21 +115,6 @@ module TypedRb
         def bound_to_generic?
           bound && bound.respond_to?(:generic?) && bound.generic?
         end
-
-        private
-
-        def incompatible_vars?(type)
-          if type.is_a?(TypeVariable)
-            left_var = bound || self
-            right_var = type.bound || type
-
-            left_var.is_a?(TypeVariable) &&
-              right_var.is_a?(TypeVariable) &&
-              left_var.variable != right_var.variable &&
-              (TypingContext.bound_generic_type_var?(left_var) &&
-               TypingContext.bound_generic_type_var?(right_var))
-          end
-        end
       end
     end
   end

data/lib/typed/types/polymorphism/type_variable_register.rb

@@ -161,10 +161,13 @@ module TypedRb
             var_constraints = @constraints[variable_name] || []
             var_constraints << [relation_type, type]
             @constraints[variable_name] = var_constraints
-          elsif parent
+          elsif parent.include?(variable_name)
             parent.add_constraint(variable_name, relation_type, type)
           else
-            fail StandardError, "Cannot find variable #{variable_name} to add a constraint"
+            key = [:local, nil, variable_name]
+            type_variables_register[key] = TypeVariable.new(variable_name, gen_name: false)
+            @constraints[variable_name] = [relation_type, type]
+            # fail StandardError, "Cannot find variable #{variable_name} to add a constraint"
           end
         end
 

data/lib/typed/types/polymorphism/unification.rb

@@ -47,7 +47,7 @@ module TypedRb
           begin
             value_l <= value_r ? value_l : fail(UnificationError, error_message)
           rescue ArgumentError
-            raise(Types::UncomparableTypes.new(value_l, value_r))
+            raise(Types::UncomparableTypes.new(value_l, value_r, nil, ", #{value_l} is not a subtype of #{value_r}"))
           end
         end
 

data/lib/typed/types/ty_existential_type.rb

@@ -7,6 +7,9 @@ module TypedRb
 
       def initialize(ruby_type, node = nil)
         super(ruby_type, node)
+        @hierarchy = [ruby_type] + Module.ancestors
+        @classes = @hierarchy.select { |klass| klass.instance_of?(Class) }
+        @modules = @hierarchy.select { |klass| klass.instance_of?(Module) }
       end
 
       def check_inclusion(self_type)

data/lib/typed/types/ty_object.rb

@@ -2,16 +2,16 @@ module TypedRb
   module Types
     class UncomparableTypes < TypeCheckError
       attr_reader :from, :to
-      def initialize(from, to, node = nil)
+      def initialize(from, to, node = nil, msg='')
         nodes = [from.node, to.node].compact
         if node
-          super("Cannot compare types #{from} <=> #{to}", node)
+          super("Cannot compare types #{from} <=> #{to}#{msg}", node)
         elsif nodes.size == 2
-          super("Cannot compare types #{from} <=> #{to}", nodes)
+          super("Cannot compare types #{from} <=> #{to}#{msg}", nodes)
         elsif nodes.size == 1
-          super("Cannot compare types #{from} <=> #{to}", nodes.first)
+          super("Cannot compare types #{from} <=> #{to}#{msg}", nodes.first)
         else
-          super("Cannot compare types #{from} <=> #{to}", nil)
+          super("Cannot compare types #{from} <=> #{to}#{msg}", nil)
         end
       end
     end

data/lib/typed/version.rb

@@ -1,3 +1,5 @@
 module TypedRb
-  VERSION = '0.0.14'
+  unless defined?(VERSION)
+    VERSION = '0.0.15'
+  end
 end

data/spec/lib/examples/monoid/monoid_error1.rb

@@ -0,0 +1,44 @@
+ts 'type Monoid[T]'
+module Monoid
+  ts '#mappend / [T] -> [T] -> [T]'
+  abstract(:mappend)
+
+  ts '#mempty / -> [T]'
+  abstract(:mempty)
+end
+
+
+ts 'type Sum[String] super Monoid[T]'
+class Sum
+
+  include Monoid
+
+  def mappend(a,b)
+    a + b
+  end
+
+  def mempty
+    0
+  end
+
+end
+
+
+ts '#sum / Array[Integer] -> Integer'
+def sum(xs)
+  monoid = Sum.new
+  zero = monoid.mempty
+  xs.reduce(zero) { |a,b| monoid.mappend(a,b) }
+end
+
+
+ts '#moncat[T] / Array[T] -> Monoid[T] -> [T]'
+def moncat(xs, m)
+  zero = m.mempty
+  xs.reduce(zero) { |a,b| m.mappend(a,b) }
+end
+
+->() {
+  moncat([1,2,3], Sum.new)
+}
+

data/spec/lib/examples/monoid/monoid_error2.rb

@@ -0,0 +1,44 @@
+ts 'type Monoid[T]'
+module Monoid
+  ts '#mappend / [T] -> [T] -> [T]'
+  abstract(:mappend)
+
+  ts '#mempty / -> [T]'
+  abstract(:mempty)
+end
+
+
+ts 'type Sum[Integer] super Monoid[T]'
+class Sum
+
+  include Monoid
+
+  def mappend(a,b)
+    a + b
+  end
+
+  def mempty
+    '0'
+  end
+
+end
+
+
+ts '#sum / Array[Integer] -> Integer'
+def sum(xs)
+  monoid = Sum.new
+  zero = monoid.mempty
+  xs.reduce(zero) { |a,b| monoid.mappend(a,b) }
+end
+
+
+ts '#moncat[T] / Array[T] -> Monoid[T] -> [T]'
+def moncat(xs, m)
+  zero = m.mempty
+  xs.reduce(zero) { |a,b| m.mappend(a,b) }
+end
+
+->() {
+  moncat([1,2,3], Sum.new)
+}
+

data/spec/lib/examples/monoid/monoid_error3.rb

@@ -0,0 +1,44 @@
+ts 'type Monoid[T]'
+module Monoid
+  ts '#mappend / [T] -> [T] -> [T]'
+  abstract(:mappend)
+
+  ts '#mempty / -> [T]'
+  abstract(:mempty)
+end
+
+
+ts 'type Sum[Integer] super Monoid[T]'
+class Sum
+
+  include Monoid
+
+  def mappend(a,b)
+    a + b
+  end
+
+  def mempty
+    0
+  end
+
+end
+
+
+ts '#sum / Array[String] -> Integer'
+def sum(xs)
+  monoid = Sum.new
+  zero = monoid.mempty
+  xs.reduce(zero) { |a,b| monoid.mappend(a,b) }
+end
+
+
+ts '#moncat[T] / Array[T] -> Monoid[T] -> [T]'
+def moncat(xs, m)
+  zero = m.mempty
+  xs.reduce(zero) { |a,b| m.mappend(a,b) }
+end
+
+->() {
+  moncat([1,2,3], Sum.new)
+}
+

data/spec/lib/examples/monoid/monoid_error4.rb

@@ -0,0 +1,44 @@
+ts 'type Monoid[T]'
+module Monoid
+  ts '#mappend / [T] -> [T] -> [T]'
+  abstract(:mappend)
+
+  ts '#mempty / -> [T]'
+  abstract(:mempty)
+end
+
+
+ts 'type Sum[Integer] super Monoid[T]'
+class Sum
+
+  include Monoid
+
+  def mappend(a,b)
+    a + b
+  end
+
+  def mempty
+    0
+  end
+
+end
+
+
+ts '#sum / Array[Integer] -> Integer'
+def sum(xs)
+  monoid = Sum.new
+  zero = monoid.mempty
+  xs.reduce(zero) { |a,b| monoid.mappend(a,b) }
+end
+
+
+ts '#moncat[T] / Array[T] -> Monoid[T] -> [T]'
+def moncat(xs, m)
+  zero = m.mempty
+  xs.reduce(zero) { |a,b| m.mappend(a,b) }
+end
+
+->() {
+  moncat([1,'2',3], Sum.new)
+}
+

data/spec/lib/language_spec.rb

@@ -50,7 +50,7 @@ describe TypedRb::Language do
     end
   end
 
-  context 'with monoid eample' do
+  context 'with monoid example' do
     let(:example) { 'monoid.rb' }
 
     it 'should be possible to type check the example correctly' do
@@ -61,4 +61,52 @@ describe TypedRb::Language do
       }.not_to raise_error
     end
   end
+
+  context 'with monoid error example, inconsistent type annotation' do
+    let(:example) { 'monoid/monoid_error1.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with monoid error example, inconsistent type annotation' do
+    let(:example) { 'monoid/monoid_error2.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with monoid error example, inconsistent type annotation' do
+    let(:example) { 'monoid/monoid_error3.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with monoid error example, inconsistent type annotation' do
+    let(:example) { 'monoid/monoid_error4.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
+    end
+  end
 end

data/spec/lib/typed_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../spec_helper'
+
+describe TypedRb do
+
+  describe '#log_dynamic_warning' do
+    it 'stores a warning if the :dynamic_warnings flag is enabled' do
+      TypedRb.options = {:dynamic_warnings => true }
+      TypedRb.dynamic_warnings.clear
+      TypedRb.log_dynamic_warning(nil, nil, nil)
+      expect(TypedRb.dynamic_warnings.count).to eq(1)
+
+      TypedRb.options = {}
+      TypedRb.dynamic_warnings.clear
+      TypedRb.log_dynamic_warning(nil, nil, nil)
+      expect(TypedRb.dynamic_warnings.count).to eq(0)
+    end
+  end
+
+end

data/spec/lib/typing/generics_spec.rb

@@ -1,6 +1,9 @@
 require_relative '../../spec_helper'
 
-describe 'generics use caes' do
+describe 'generics use case
+when 
+  
+end' do
   let(:language) { TypedRb::Language.new }
 
   it 'applies arguments to generic types' do
@@ -108,8 +111,7 @@ __END
 
     expect do
       language.check(code)
-    end.to raise_error(TypedRb::TypeCheckError,
-                       /TestGen2\:T\:\:\[\?,\?\] expected, TestGen2\:U\:\:\[\?,\?\]/)
+    end.to raise_error(TypedRb::TypeCheckError)
   end
 
   it 'type-checks correctly super type generics' do

data/spec/lib/typing/tm_fun_spec.rb

@@ -46,7 +46,7 @@ __CODE
   context 'with not matching arg type in function definition' do
     let(:code) do
       text = <<__CODE
-      class A
+      class ADefault
         ts '#f1 / Integer -> String'
         def f1(num='text')
           'String'

data/spec/lib/typing/tm_module_spec.rb

@@ -37,7 +37,7 @@ __CODE
     expect {
       language.check(code)
     }.to raise_error(TypedRb::Types::UncomparableTypes,
-                     'Cannot compare types Integer <=> String')
+                     /Cannot compare types Integer <=> String/)
   end
 
   it 'includes a module referencing instance variables in a class' do

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require 'pry'
 require 'simplecov'
 require 'rspec-prof'
+require 'coveralls'
+
+Coveralls.wear!
 
 SimpleCov.start do
   add_filter "/spec/"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Antonio Garrote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-21 00:00:00.000000000 Z
+date: 2016-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -148,6 +148,10 @@ files:
 - spec/lib/examples/counter.rb
 - spec/lib/examples/if.rb
 - spec/lib/examples/monoid.rb
+- spec/lib/examples/monoid/monoid_error1.rb
+- spec/lib/examples/monoid/monoid_error2.rb
+- spec/lib/examples/monoid/monoid_error3.rb
+- spec/lib/examples/monoid/monoid_error4.rb
 - spec/lib/language_spec.rb
 - spec/lib/model/tm_abs_spec.rb
 - spec/lib/model/tm_array_literal_spec.rb
@@ -183,6 +187,7 @@ files:
 - spec/lib/runtime/validations_spec.rb
 - spec/lib/runtime_spec.rb
 - spec/lib/type_signature/parser_spec.rb
+- spec/lib/typed_spec.rb
 - spec/lib/types/comparisons_spec.rb
 - spec/lib/types/polymorphism/generic_comparisons_spec.rb
 - spec/lib/types/polymorphism/type_variable_register_spec.rb