jade-lang 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba543580eec5d50cae2249c010a03f7a56a96f276705b3b87df7f25f06ff8eeb
-  data.tar.gz: 15923caf94302e7326aef6cc8a0e581c349b7b46d54ae4898e6bd8d8529657cf
+  metadata.gz: 9b0d9367dd2a235c282b3e7bbeabc2ee7874fa6899fdbdd746c66d546279cf30
+  data.tar.gz: cf83815353b341a4834b5b17712148db973f96a3a914ac6aa2ae019a00ae84df
 SHA512:
-  metadata.gz: 3906343d3094e2b9142aebc9324722c584db45dfb0951d6546d917794559a8cb9249d9ff4243bb380dc383932e78b93609455743a9e349ec3b60086450693846
-  data.tar.gz: 841c318dc43aa3e99df702eba6ffda7621b5a8c0f97e9302f2d75ef2149a36bcc19a1287d26a3cef5091c1361508d333a964f9eb70094e30a5791e8c4f8394a9
+  metadata.gz: 1551750ffbca65f37071206e6eccc559f2d7ae81b5ecf0545c089bc3b0f8d36ba3cc3d98c4c33ce3b2c572c8a650d494c40c9d926f210a1f449c478257ca084c
+  data.tar.gz: 2ec0e124c2057bd34cf99728253b5dbd93765c77694a7f6ca0799be1c56eb1baa6d79e4cbc8268ad56a38fa811877defb5ccbd2f7538ce24e33958754ee90aa6

data/CHANGELOG.md

@@ -4,6 +4,48 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.1] - 2026-09-11
+
+### Added
+
+- **`Decode.decoder`, the derived decoder as a value.** `Decode.from_json` has
+  always picked a decoder off the return type, but there was no way to name
+  that decoder and hand it to a combinator — every project ended up with a
+  `uuid_decoder` and a `date_decoder` per module, reimplementing an instance
+  that already existed. `Decode.field("on", Decode.decoder)` now resolves the
+  `Decodable` instance from the position the decoder stands in, including
+  derived ones, and a type without an instance is a compile error naming the
+  type.
+
+- **`jade init`.** Writes `jade.json`, which is how every tool that runs
+  outside the app finds your sources, creates the source directory, and adds
+  `.jade/` to a `.gitignore` that has one. It refuses to overwrite an existing
+  manifest rather than discarding a source root and extension list that cannot
+  be recovered from the directory. Until now the first thing a new project met
+  was the error telling it to write that file by hand.
+
+### Fixed
+
+- **A function type printed as `(a) -> b`, which means something else.**
+  `Type::Function#to_s` parenthesised its parameters unconditionally, so
+  `jade q api` printed `List.fold : (List(a), b, (b, a) -> b) -> b`, a
+  signature whose outer parentheses read as a tuple argument. It prints the
+  bare form now, `List(a), b, (b, a -> b) -> b`, which is what the formatter
+  writes and what you can paste back into a file.
+
+  Parentheses around a comma list are a tuple everywhere, and a parameter
+  list is bare. A nested function type keeps parentheses of its own, told
+  apart from a tuple by the arrow inside them. `(Int) -> Int` also parses
+  now, which it did not: one element is not a tuple.
+
+- **A record update that does not fit crashed the compiler.** The unification
+  that closes an update was the one call with no error block, and
+  `State#unify` calls the block unconditionally when unification fails, so a
+  mismatch reached `nil.call` and took the compiler out with a `NoMethodError`
+  naming a line in `state.rb`. Changing a field's type is the usual way in;
+  anything the surrounding code cannot accept arrives the same way. It now
+  reads `This update produces Box(Int), but String was expected`.
+
 ## [0.10.0] - 2026-09-02
 
 ### Breaking

data/README.md

@@ -348,6 +348,7 @@ for us so far.
 A single `jade` binary fronts the toolchain:
 
 ```
+jade init                 # write jade.json and the source directory
 jade check [file...]      # type-check; exits 1 on errors, generates nothing
 jade fmt [-i|-c] [file]   # format .jd source (stdin or file)
 jade lsp                  # language server over stdio (hover, defn, refs, diagnostics)

data/docs/json.md

@@ -61,9 +61,23 @@ DecodeJson::Internal.user('{"name":"Ada"}')
 # => Err(MissingField("age"))
 ```
 
-The struct decoder is `Decode.succeed(User(_, _))` piped through one
-`Decode.required` per field — the `_` placeholders are the constructor's holes,
-filled left to right as each field decodes.
+The struct decoder is `Decode.succeed(User(_, _))` piped through one step per
+field — the `_` placeholders are the constructor's holes, filled left to right
+as each field decodes. `Decode.required` fails on a missing key;
+`Decode.optional` takes what a missing key stands for instead, which is a
+`Maybe` when that is the field's type:
+
+```jade
+Decode.succeed(Note(_, _, _))
+  |> Decode.required("body", Decode.nullable(Decode.string))
+  |> Decode.optional("kind", Decode.string, "note")
+  |> Decode.optional("archived_on", Decode.map(Decode.decoder, Just), Nothing)
+```
+
+A nullable field is a required one: the key has to be there, and `null` is a
+value the decoder admits. Pick the step at the field — once a step has run the
+pipeline holds the constructor's remaining arguments, so nothing downstream
+reaches back into one field.
 
 ## Encoding
 
@@ -146,6 +160,23 @@ end
 Reach for the explicit combinators above when the JSON shape doesn't match the
 struct one-to-one — renamed keys, nested lookups, optional fields.
 
+Those combinators still take derived decoders for the leaves. `Decode.decoder`
+is the instance for whatever type is expected of it, so a hand-built shape can
+be filled with types that already know how to read themselves:
+
+```jade
+def decoder -> Decoder(Movement)
+  Decode.succeed(Movement(_, _, _))
+    |> Decode.and_map(Decode.field("from_id", Decode.decoder))
+    |> Decode.and_map(Decode.field("to_id", Decode.decoder))
+    |> Decode.and_map(Decode.field("occurred_on", Decode.decoder))
+end
+```
+
+Two of those fields are `Uuid` and one is a `Date`; each resolves from the
+position it stands in. A type with no instance is a compile error naming the
+type, not a decoder that fails at runtime.
+
 Derivation reaches through the structural types to their elements, so anything
 built out of encodable parts is itself encodable:
 

data/lib/jade/cli/init.rb

@@ -0,0 +1,86 @@
+require 'fileutils'
+require 'json'
+
+require 'jade'
+
+module Jade
+  module CLI
+    # Writes the manifest every tool outside the app reads. Without one,
+    # the CLI and the language server have to guess where the sources are,
+    # which is why `Project::NotFound` says to write this file by hand.
+    module Init
+      module_function
+
+      IGNORED = '.jade/'.freeze
+
+      def run(argv)
+        usage if argv.any? { it == '-h' || it == '--help' }
+
+        source_root(argv)
+          .then { [it, File.expand_path(Project::MANIFEST)] }
+          .then { |root, manifest| write(root, manifest) }
+      end
+
+      def write(root, manifest)
+        refuse(manifest) if File.exist?(manifest)
+
+        File.write(manifest, "#{JSON.pretty_generate(config(root))}\n")
+        FileUtils.mkdir_p(root)
+
+        report(root, manifest)
+      end
+
+      # Only what the defaults do not already say. A manifest naming every
+      # setting reads as though each were a decision.
+      def config(root)
+        { 'source_roots' => [root], 'extensions' => [] }
+      end
+
+      def source_root(argv)
+        argv
+          .each_cons(2)
+          .find { |flag, _| flag == '--source-root' }
+          &.last || Project::DEFAULTS[:source_roots].first
+      end
+
+      def refuse(manifest)
+        warn "jade: #{File.basename(manifest)} already exists in #{File.dirname(manifest)}"
+        exit 1
+      end
+
+      def report(root, manifest)
+        puts <<~TXT
+          Wrote #{File.basename(manifest)} and #{root}/.
+
+          Put a module in #{root}/, then:
+
+            jade check              type-check it
+            jade fmt #{root}/x.jd#{' ' * [0, 7 - root.length].max}   format it
+
+          #{gitignore_note}
+        TXT
+      end
+
+      # Build and cache output, which nobody wants in a diff.
+      def gitignore_note
+        path = File.expand_path('.gitignore')
+        return "Add #{IGNORED} to .gitignore." unless File.exist?(path)
+        return "#{IGNORED} is already ignored." if File.read(path).match?(/^\.jade\b/)
+
+        File.write(path, "#{File.read(path).chomp}\n#{IGNORED}\n")
+        "Added #{IGNORED} to .gitignore."
+      end
+
+      def usage
+        warn <<~USAGE
+          Usage: jade init [--source-root DIR]
+
+          Writes jade.json, which is how every tool outside the app finds
+          your sources, and creates the source directory. Refuses to
+          overwrite an existing manifest.
+        USAGE
+        exit 1
+      end
+    end
+  end
+end

data/lib/jade/cli.rb

@@ -6,6 +6,7 @@ module Jade
       'check' => 'Check',
       'eject' => 'Eject',
       'fmt' => 'Fmt',
+      'init' => 'Init',
       'lsp' => 'Lsp',
       'q' => 'Q',
     }.freeze
@@ -40,6 +41,7 @@ module Jade
           check  Type-check the project (or the given files).
           eject  Write the project as Ruby that runs without the gem.
           fmt    Format .jd source (stdin or file).
+          init   Write jade.json and the source directory.
           lsp    Run the language server (stdio JSON-RPC).
           q      Headless query interface (hover/symbols/defn/refs/api).
 

data/lib/jade/codegen/function_call.rb

@@ -16,6 +16,9 @@ module Jade
         Inline.try_for(callee, args, dictionaries, registry)
           .then { return it if it }
 
+        constrained_constant(callee, dictionaries, registry)
+          .then { return it if it }
+
         return constructor_call(callee, args, registry) if constructor_callee?(callee, registry)
 
         [generate_many(args, registry), generate_dict_args(callee, dictionaries, registry)]
@@ -24,6 +27,18 @@ module Jade
           .then { "#{generate_callee(callee, args, registry, dictionaries)}#{invocation_op(callee, registry)}(#{it})" }
       end
 
+      # A constrained constant — `Decode.decoder` — has no parameters, so its
+      # dictionary slot holds the value itself rather than something to call.
+      # generate_callee already produced that value; invoking it would be
+      # calling a Decoder.
+      def constrained_constant(callee, dictionaries, registry)
+        symbol = resolve_callee_symbol(callee, registry)
+        return nil unless symbol.is_a?(Symbol::StdlibFunction)
+        return nil unless symbol.params.empty? && symbol.constraints.any?
+
+        generate_callee(callee, [], registry, dictionaries)
+      end
+
       def constructor_call(callee, args, registry)
         resolve_callee_symbol(callee, registry)
           .then { "::#{to_qualified(it.qualified_name)}" }

data/lib/jade/formatter/type.rb

@@ -26,11 +26,9 @@ module Jade
           end
 
         in AST::TypeFunction(params:, return_type:)
-          params_str = params.empty? ?
-            "()" :
-            params.map { format_atom(it) }.join(', ')
-
-          "#{params_str} -> #{format_atom(return_type)}"
+          params
+            .then { it.empty? ? '()' : it.map { |p| format_atom(p) }.join(', ') }
+            .then { "#{it} -> #{format_atom(return_type)}" }
 
         in AST::TypeRecord(fields:, row_var:)
           fields_str = fields.map { |k, v| "#{k}: #{format(v)}" }.join(", ")

data/lib/jade/frontend/type_checking/error/record_update_type_mismatch.rb

@@ -0,0 +1,21 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        # An update produces a record of its own, which then has to be the
+        # record the surrounding code wanted. Changing a field's type is the
+        # usual way to break that, and any other disagreement lands here too.
+        class RecordUpdateTypeMismatch < TypeMismatch
+          def message
+            "This update produces #{naming.annotated(@actual)}, " \
+              "but #{naming.annotated(@expected)} was expected"
+          end
+
+          def label
+            "produces #{naming[@actual]}, expected #{naming[@expected]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error.rb

@@ -19,6 +19,7 @@ require 'jade/frontend/type_checking/error/pattern_type_mismatch'
 require 'jade/frontend/type_checking/error/empty_range_pattern'
 require 'jade/frontend/type_checking/error/range_pattern_type'
 require 'jade/frontend/type_checking/error/record_access_type_mismatch'
+require 'jade/frontend/type_checking/error/record_update_type_mismatch'
 require 'jade/frontend/type_checking/error/unresolved_constraint'
 require 'jade/frontend/type_checking/error/implementation_type_mismatch'
 require 'jade/frontend/type_checking/error/missing_implementation'

data/lib/jade/frontend/type_checking/inference/record_update.rb

@@ -28,7 +28,14 @@ module Jade
               )
             end
 
-            after_state.unify_result(result, expected.type)
+            after_state.unify_result(result, expected.type) do
+              Error::RecordUpdateTypeMismatch.new(
+                state.env.entry_name,
+                node.range,
+                expected: it.expected,
+                actual: it.actual,
+              )
+            end
           end
         end
       end

data/lib/jade/parsing/type.rb

@@ -10,7 +10,7 @@ module Jade
       }
 
       parser(:type_atom) {
-        type_application | type_var | type_tuple | grouped(lazy { type_function })
+        type_application | type_var | type_tuple | grouped(lazy { type_expression })
       }
 
       parser(:type_tuple) {

data/lib/jade/stdlib/decode.rb

@@ -268,6 +268,17 @@ module Jade
 
       # Constrained helpers — pick the decoder via Decodable.
 
+      function(
+        'decoder',
+        {},
+        'Decoder(a)',
+        constraints: [['Decode.Decodable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: [],
+          body: [:impl_arg, 0, 'decoder'],
+        ),
+      )
+
       function(
         'from_value',
         { value: 'Value' },

data/lib/jade/symbol/stdlib_function.rb

@@ -8,7 +8,7 @@ module Jade
       end
 
       def constant?
-        params.empty? && constraints.empty?
+        params.empty?
       end
     end
   end

data/lib/jade/type/function.rb

@@ -1,27 +1,26 @@
 module Jade
   module Type
-    Function = Data.define(:args, :return_type, :display) do
+    Function = Data.define(:args, :return_type) do
       include Base
-      include Displayable
 
-      def initialize(args:, return_type:, display: nil)
-        super
-      end
-
-      def identity
-        [args, return_type]
-      end
+      # `Int, Int -> Int`, the spelling the formatter writes. Parentheses
+      # around a comma list are a tuple, so a nested function keeps its own.
+      def to_s
+        params = args.empty? ? '()' : args.map { delimited(it) }.join(', ')
 
-      def render
-        args
-          .map(&:to_s).join(', ')
-          .then { "(#{it})"} + " -> " + return_type.to_s
+        "#{params} -> #{delimited(return_type)}"
       end
 
       def unbound_vars
         (args.flat_map(&:unbound_vars) + return_type.unbound_vars)
           .to_set.to_a
       end
+
+      private
+
+      def delimited(type)
+        type.is_a?(Function) ? "(#{type})" : type.to_s
+      end
     end
   end
 end

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.10.0'
+  VERSION = '0.10.1'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -57,6 +57,7 @@ files:
 - lib/jade/cli/check.rb
 - lib/jade/cli/eject.rb
 - lib/jade/cli/fmt.rb
+- lib/jade/cli/init.rb
 - lib/jade/cli/lsp.rb
 - lib/jade/cli/q.rb
 - lib/jade/clock/runtime.rb
@@ -266,6 +267,7 @@ files:
 - lib/jade/frontend/type_checking/error/port_not_encodable.rb
 - lib/jade/frontend/type_checking/error/range_pattern_type.rb
 - lib/jade/frontend/type_checking/error/record_access_type_mismatch.rb
+- lib/jade/frontend/type_checking/error/record_update_type_mismatch.rb
 - lib/jade/frontend/type_checking/error/recursive_derivation.rb
 - lib/jade/frontend/type_checking/error/type_mismatch.rb
 - lib/jade/frontend/type_checking/error/unreachable_branch.rb