jade-lang 0.8.0 → 0.10.0

data/lib/jade/stdlib/intrinsics.rb

@@ -5,12 +5,45 @@ require 'jade/codegen/inlines'
 module Jade
   module Stdlib
     module Intrinsics
+      # A running app wants the implementations these files carry and not
+      # the declarations, which are what read type annotations.
+      def self.runtime_only!
+        @runtime_only = true
+      end
+
+      def self.declaring!
+        @runtime_only = false
+      end
+
+      def self.runtime_only?
+        @runtime_only ||= false
+      end
+
+      # A second load of the same file would otherwise store every symbol
+      # twice.
+      def self.extended(base)
+        base.instance_variable_set(:@symbols, nil)
+      end
+
+      def self.reload_for_declarations(files)
+        return unless runtime_only?
+
+        declaring!
+        files.each { load "#{__dir__}/#{it}.rb" }
+      end
+
+      def runtime_only?
+        Intrinsics.runtime_only?
+      end
+
       def generate_entry(registry)
         @entry = entry
           .then { load_env(it, registry) }
       end
 
       def variant(name, of:, args: [])
+        return if runtime_only?
+
         parent = @symbols
           &.find { it.is_a?(Symbol::Union) && it.name == of.to_s }
 
@@ -44,12 +77,14 @@ module Jade
       end
 
       def union(name, *type_params, constructor: false)
+        return if runtime_only?
+
         union_symbol = Symbol
           .union(name.to_s, type_params.map { Symbol.var(it, nil) }, [], nil)
           .with(module_name:)
           .tap { store(it) }
 
-        constructor_symbol = if constructor
+        if constructor
           Symbol.constructor(
             name.to_s,
             type_params.map { Symbol.var(it, nil) },
@@ -67,6 +102,8 @@ module Jade
         codegen = body || "Jade::Runtime.intr('#{qualified_fn_name}')"
         impl = runtime_impl(qualified_fn_name, params.size, block, body)
 
+        return Runtime.register(qualified_fn_name, &impl) if runtime_only?
+
         Symbol
           .stdlib_function(
             name.to_s,
@@ -118,6 +155,8 @@ module Jade
       end
 
       def interface(name, type_param, functions, default: {})
+        return if runtime_only?
+
         functions
           .map { |k, v| Symbol.parse(v).then { to_interface_function(name, k, it) }.with(module_name:) }
           .then { Symbol.interface(name, Symbol.parse(type_param), it, default, nil) }
@@ -144,6 +183,8 @@ module Jade
       end
 
       def implementation(interface_name, type, functions)
+        return register_native_impls(interface_name, type, functions) if runtime_only?
+
         interface = imports
           .map(&:symbols)
           .then { [symbols, *it] }
@@ -168,11 +209,17 @@ module Jade
           )
           .then { store(it) }
 
-        if (ruby_classes = @native_types&.[](type))
-          qualified_iface = "#{interface_to_ref(interface_name).module_name}.#{interface_name}"
-          qualified_fns   = functions.transform_values { "#{module_name}.#{it}" }
-          ruby_classes.each { Runtime.register_impl(qualified_iface, it, qualified_fns) }
-        end
+        register_native_impls(interface_name, type, functions)
+      end
+
+      # Dispatch on a native Ruby class is the only part of an
+      # implementation a running app can use.
+      def register_native_impls(interface_name, type, functions)
+        return unless (ruby_classes = @native_types&.[](type))
+
+        qualified_iface = "#{interface_to_ref(interface_name).module_name}.#{interface_name}"
+        qualified_fns = functions.transform_values { "#{module_name}.#{it}" }
+        ruby_classes.each { Runtime.register_impl(qualified_iface, it, qualified_fns) }
       end
 
       # Accepts both bare/qualified names ('Int', 'Basics.Int') and full type
@@ -198,6 +245,8 @@ module Jade
       end
 
       def import(module_name)
+        return if runtime_only?
+
         @imports = imports + [module_name]
       end
 
@@ -206,6 +255,8 @@ module Jade
       end
 
       def default_importing(imports)
+        return if runtime_only?
+
         @default_imports = if imports == :*
           exposes
         else
@@ -244,6 +295,8 @@ module Jade
         @symbols.concat << symbol
       end
 
+
+
       def module_name
         "#{self.name.split('::').last}"
       end

data/lib/jade/stdlib/list.rb

@@ -12,7 +12,7 @@ module Jade
 
       function(:singleton, { element: 'a' }, 'List(a)')
       function(:repeat, { element: 'a', times: 'Int' }, 'List(a)')
-      function(:range, { begin_: 'Int', end_: 'Int' }, 'List(a)')
+      function(:range, { begin_: 'Int', end_: 'Int' }, 'List(Int)')
       function(:"empty?", { list: 'List(a)' }, 'Bool')
       function(:head, { list: 'List(a)' }, 'Maybe(a)')
       function(:tail, { list: 'List(a)' }, 'List(a)')
@@ -170,6 +170,42 @@ module Jade
         ),
       )
 
+      function(
+        :sum,
+        { list: 'List(a)' },
+        'a',
+        constraints: [['Basics.Numeric', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list'],
+          body: [:call,
+            [:stdlib_fn, 'List.fold'],
+            [
+              [:var, 'list'],
+              [:call, [:impl_arg, 0, 'from_int'], [0]],
+              [:impl_arg, 0, '(+)'],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        :product,
+        { list: 'List(a)' },
+        'a',
+        constraints: [['Basics.Numeric', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['list'],
+          body: [:call,
+            [:stdlib_fn, 'List.fold'],
+            [
+              [:var, 'list'],
+              [:call, [:impl_arg, 0, 'from_int'], [1]],
+              [:impl_arg, 0, '(*)'],
+            ],
+          ],
+        ),
+      )
+
       function(
         'maximum_with',
         { list: 'List(a)', cmp: 'a, a -> Ordering' },

data/lib/jade/stdlib/number.rb

@@ -0,0 +1,47 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    # `non_zero` cannot live in Basics beside the `NonZero` type it builds,
+    # because its `Maybe` comes from a module that needs Basics first.
+    module Number
+      extend Intrinsics
+
+      import Basics
+
+      # What counts as zero is the type's business, so this dispatches
+      # rather than asking Ruby whether the value is `0`.
+      function(
+        :non_zero,
+        { n: 'a' },
+        'Maybe(NonZero(a))',
+        constraints: [['Basics.Numeric', 'a'], ['Basics.Eq', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['n'],
+          body: [:call,
+            [:stdlib_fn, 'Number.checked'],
+            [
+              [:var, 'n'],
+              [:call, [:impl_arg, 0, 'from_int'], [0]],
+              [:impl_arg, 1, '(==)'],
+            ]],
+        ),
+      )
+
+      # For anyone implementing `Numeric` themselves: the divisor arrives
+      # wrapped and the arithmetic needs it bare.
+      function(:unwrap, { n: 'NonZero(a)' }, 'a')
+
+      function(
+        :checked,
+        { n: 'a', zero: 'a', eq: 'a, a -> Bool' },
+        'Maybe(NonZero(a))',
+        private: true,
+      ) do |n, zero, eq|
+        eq.call(n, zero) ? Jade::Maybe::Nothing[] : Jade::Maybe::Just[n]
+      end
+
+      default_importing(['non_zero'])
+    end
+  end
+end

data/lib/jade/stdlib/range.rb

@@ -0,0 +1,211 @@
+require 'jade/stdlib/compiled'
+
+module Jade
+  module Stdlib
+    module Range
+      extend self
+      extend Compiled
+
+      def uri
+        'range.jd'
+      end
+
+      def imports
+        [Basics, Maybe, Tuple]
+      end
+
+      # `..` desugars to `Range.between`, so the module has to be in scope
+      # wherever the operator is legal, which is everywhere.
+      def default_imports
+        [Symbol.type_ref('Range', 'Range')]
+      end
+
+      def code
+        <<~JADE
+          module Range exposing (
+            Range,
+            all,
+            between,
+            bounded?,
+            clamp,
+            contains?,
+            empty,
+            empty?,
+            from,
+            intersect,
+            lower,
+            overlaps?,
+            to,
+            upper,
+          )
+
+          type Range(a)
+            = Empty
+            | Between(a, a)
+            | From(a)
+            | To(a)
+            | All
+
+
+          def empty -> Range(a)
+            Empty
+          end
+
+
+          def all -> Range(a)
+            All
+          end
+
+
+          def from(low: a) -> Range(a)
+            From(low)
+          end
+
+
+          def to(high: a) -> Range(a)
+            To(high)
+          end
+
+
+          def between(low: a, high: a) -> Range(a)
+            if low <= high then
+              Between(low, high)
+            else
+              Empty
+            end
+          end
+
+
+          def contains?(range: Range(a), value: a) -> Bool
+            case range
+            in Empty then False
+            in Between(low, high) then low <= value && value <= high
+            in From(low) then low <= value
+            in To(high) then value <= high
+            in All then True
+            end
+          end
+
+
+          def empty?(range: Range(a)) -> Bool
+            case range
+            in Empty then True
+            in Between(low, high) then high < low
+            in From(_) then False
+            in To(_) then False
+            in All then False
+            end
+          end
+
+
+          def bounded?(range: Range(a)) -> Bool
+            case range
+            in Empty then True
+            in Between(_, _) then True
+            in From(_) then False
+            in To(_) then False
+            in All then False
+            end
+          end
+
+
+          def lower(range: Range(a)) -> Maybe(a)
+            case range
+            in Empty then Nothing
+            in Between(low, _) then Just(low)
+            in From(low) then Just(low)
+            in To(_) then Nothing
+            in All then Nothing
+            end
+          end
+
+
+          def upper(range: Range(a)) -> Maybe(a)
+            case range
+            in Empty then Nothing
+            in Between(_, high) then Just(high)
+            in From(_) then Nothing
+            in To(high) then Just(high)
+            in All then Nothing
+            end
+          end
+
+
+          def intersect(left: Range(a), right: Range(a)) -> Range(a)
+            if empty?(left) || empty?(right) then
+              Empty
+            else
+              rebuild(
+                highest(lower(left), lower(right)),
+                lowest(upper(left), upper(right)),
+              )
+            end
+          end
+
+
+          def overlaps?(left: Range(a), right: Range(a)) -> Bool
+            intersect(left, right)
+              |> empty?
+              |> not
+          end
+
+
+          def clamp(range: Range(a), value: a) -> Maybe(a)
+            if empty?(range) then
+              Nothing
+            else
+              value
+                |> at_least(lower(range))
+                |> at_most(upper(range))
+                |> Just
+            end
+          end
+
+
+          def rebuild(low: Maybe(a), high: Maybe(a)) -> Range(a)
+            case (low, high)
+            in (Nothing, Nothing) then All
+            in (Just(l), Nothing) then From(l)
+            in (Nothing, Just(h)) then To(h)
+            in (Just(l), Just(h)) then between(l, h)
+            end
+          end
+
+
+          def highest(left: Maybe(a), right: Maybe(a)) -> Maybe(a)
+            case (left, right)
+            in (Nothing, _) then right
+            in (_, Nothing) then left
+            in (Just(l), Just(r)) then if l <= r then Just(r) else Just(l) end
+            end
+          end
+
+
+          def lowest(left: Maybe(a), right: Maybe(a)) -> Maybe(a)
+            case (left, right)
+            in (Nothing, _) then right
+            in (_, Nothing) then left
+            in (Just(l), Just(r)) then if l <= r then Just(l) else Just(r) end
+            end
+          end
+
+
+          def at_least(value: a, bound: Maybe(a)) -> a
+            case bound
+            in Nothing then value
+            in Just(low) then if value <= low then low else value end
+            end
+          end
+
+
+          def at_most(value: a, bound: Maybe(a)) -> a
+            case bound
+            in Nothing then value
+            in Just(high) then if high <= value then high else value end
+            end
+          end
+        JADE
+      end
+    end
+  end
+end

data/lib/jade/stdlib.rb

@@ -1,9 +1,15 @@
 require 'set'
+require 'jade/stdlib/intrinsics'
+
+# A runtime-only load skipped the declarations; the compiler needs them.
+Jade::Stdlib::Intrinsics.reload_for_declarations(Jade::Runtime::STDLIB)
+
 require 'jade/stdlib/basics'
 require 'jade/stdlib/maybe'
 require 'jade/stdlib/tuple'
 require 'jade/stdlib/list'
 require 'jade/stdlib/char'
+require 'jade/stdlib/number'
 require 'jade/stdlib/string'
 require 'jade/stdlib/result'
 require 'jade/stdlib/task'
@@ -16,6 +22,7 @@ require 'jade/stdlib/bytes'
 require 'jade/stdlib/calendar'
 require 'jade/stdlib/clock'
 require 'jade/stdlib/decimal'
+require 'jade/stdlib/range'
 require 'jade/stdlib/show'
 require 'jade/stdlib/debug'
 
@@ -24,21 +31,21 @@ module Jade
     extend self
 
     INTRINSICS = %w[
-      Basics String List Tuple Char Task
+      Basics Number String List Tuple Char Task
       Decode Encode
       Bytes
       Dict Set
       Show Debug
     ].freeze
-    COMPILED = %w[Maybe Result Decode.Params Calendar Clock Decimal].freeze
+    COMPILED = %w[Maybe Result Decode.Params Calendar Clock Decimal Range].freeze
     TOPLEVELS = (INTRINSICS + COMPILED).map { it.split('.', 2).first }.to_set.freeze
     STDLIBS = [
-      Stdlib::Basics, Stdlib::Maybe, Stdlib::Tuple, Stdlib::List, Stdlib::Char,
+      Stdlib::Basics, Stdlib::Maybe, Stdlib::Number, Stdlib::Tuple, Stdlib::List, Stdlib::Char,
       Stdlib::String, Stdlib::Result, Stdlib::Task,
       Stdlib::Dict, Stdlib::Set,
       Stdlib::Decode, Stdlib::Decode::Params, Stdlib::Encode,
       Stdlib::Bytes,
-      Stdlib::Calendar, Stdlib::Clock, Stdlib::Decimal, Stdlib::Show, Stdlib::Debug,
+      Stdlib::Calendar, Stdlib::Clock, Stdlib::Decimal, Stdlib::Range, Stdlib::Show, Stdlib::Debug,
     ]
     # Loaded into the registry but not auto-imported into user modules.
     EXTENSIONS = [

data/lib/jade/symbol/alias.rb

@@ -0,0 +1,11 @@
+module Jade
+  module Symbol
+    Alias = Data.define(:module_name, :name, :type_params, :body, :decl_span) do
+      include Base
+
+      def to_ref
+        TypeRef[module_name, name]
+      end
+    end
+  end
+end

data/lib/jade/symbol/parser.rb

@@ -44,7 +44,7 @@ module Jade
 
       def qualify(type)
         case type
-        in 'Int' | 'Float' | 'Bool' | 'Ordering' | 'Never'
+        in 'Int' | 'Float' | 'Bool' | 'Ordering' | 'Never' | 'NonZero'
           'Basics'
 
         in 'String' | 'Maybe' | 'List' | 'Result' | 'Task' | 'Char'

data/lib/jade/symbol.rb

@@ -1,5 +1,4 @@
 require 'jade/symbol/base'
-require 'jade/symbol/parser'
 
 require 'jade/symbol/anonymous_record'
 require 'jade/symbol/constructor'
@@ -16,6 +15,7 @@ require 'jade/symbol/record_type'
 require 'jade/symbol/stdlib_function'
 require 'jade/symbol/stdlib_implementation'
 require 'jade/symbol/struct'
+require 'jade/symbol/alias'
 require 'jade/symbol/type_application'
 require 'jade/symbol/partial_application'
 require 'jade/symbol/type_ref'
@@ -122,6 +122,14 @@ module Jade
       Struct[nil, name, type_params, nil, span]
     end
 
+    def predeclared_alias(name, type_params, span)
+      Alias[nil, name, type_params, nil, span]
+    end
+
+    def alias(name, type_params, body, span)
+      Alias[nil, name, type_params, body, span]
+    end
+
     def interface(name, type_var, functions, default, span)
       Interface[nil, name, type_var, functions, default, span]
     end
@@ -153,7 +161,11 @@ module Jade
       ]
     end
 
+    # The parser is the compiler's, and a running app never reads a type
+    # annotation, so it loads here rather than with the symbol classes.
     def parse(annotation)
+      require_relative 'symbol/parser'
+
       Lexer
         .tokenize(Source.new(uri: nil, text: annotation))
         .then { Parser.parse(it) }