• 解析函数的阶段可以说是编译期。在这个阶段可以对函数代码进行优化。不过Ruby实现不支持。。。

  • Ruby语言的语法特性和执行方式其实是可以支持函数边界类型验证的(比如Racket就实现了),这个是属于可以做的事情。

  • C# partial应该可以做到这一点。

  • C语言特性以外的都不是必需品,但是作为现代通用编程语言,很多特性是保证开发效率和工程质量必须的。 烂语言有很多,比如Autoit,PHP,Perl,都能用,但是烂。

    函数式,类型系统都是极大提升开发效率和质量的,作为通用编程语言,是必须有的特性,没有理由不加。

  • 还是要用语言实现比较好。库写起来不好的。

  • 实现类型验证的简单过程:

    # 定义函数需要加上类型
    define_function :calculate, [Array(A)] do |objects|
      lambda {
        objects.map{|o| count_method.call(o)}.sum
      }
    end
    def define_function(name, types)
      Function.new(method: block.call, types: types)
    end
    
    # 解析调用到这个函数的代码的时候,会进行类型验证
    define_function :run do
      call_function(:calculate, :objects)
    end
    def call_function(func_name, args)
      func = get_function(func_name)
      type_checking(func, args)
      lambda { func.call(args) }
    end
    
    # 类型验证会去检查是否函数是否支持该类型,不支持的话就报错
    def type_checking(func, args)
      func.types.each_with_index do |type, i|
        unless args[i].kind_of?(type)
          raise TypeError
        end
      end
    end
    
    
  • 因为我就写了一句话,不明白是正常的。举个例子:

    def calculate(objects)
      objects.map(&:count).sum
    end
    
    class A
      def count; rand; end
    end
    
    class B
      def count; 10; end
    end
    
    calculate(12.times.map{A.new})
    calculate(12.times.map{B.new})
    

    在ruby里面,calculate就不晓得传进来的是什么东西,只会把count消息传给object,让object返回结果,object本身要实现接收:count然后执行对应方法的过程。

    • 优化1: 假设传进来的objects都是同样的类型,我们可以先取得count_method,这样不需要object动态查找count的method。

      def calculate(objects)
      # 假设objects都是同样类型
      count_method = objects.first.class.get_method(:count)
      objects.map{|o| count_method.call(o)}.sum
      end
      
    • 优化2:宏编译优化,查找count_method的过程在编译期的时候就完成了。

      def create_calculate(klass, objects)
      count_method = klass.get_method(:count)
      lambda { |objects|
      objects.map{|o| count_method.call(o)}.sum
      }
      end
      

    calculate_method = create_caculate(A) calculate_method.calculate(objects)

    
    上面这两个优化可以提升很多的效率。要知道代码里面大多数的东西都是在方法调用来调用去。
    
    
  • 很明显是执行的时候才会猜类型呀,能够动态定义函数,同时函数本身不带有类型信息,那么只能在执行时才可以知道传进来的参数类型。 我觉得你以为实现的方式是:函数是一个模板,类似:func(T arg),当然不可能是这样的。

  • 类型系统决定了可以编译期对代码进行优化,代码里面就不需要判断传进来的参数是什么类型了,直接调用对应类型的处理方法即可。这种优化并不代表需要静态编译系统。比如在ruby解析一个method的时候就把优化做掉。Typed Racket就是这样处理的。类型系统可选在C#里面就实现了,我文章里面有写。

  • 设置类型系统可选就可以了。