jade-lang 0.1.0

data/lib/jade/stdlib/decode.rb

@@ -0,0 +1,315 @@
+require 'jade/stdlib/intrinsics'
+require 'jade/decode'
+
+module Jade
+  module Stdlib
+    module Decode
+      extend Intrinsics
+
+      import Maybe
+      import Result
+      import List
+      import Dict
+
+      union :DecodeError
+      variant :MissingField, of: :DecodeError, args: ['String']
+      variant :WrongType,    of: :DecodeError, args: ['String', 'String']
+      variant :AtField,      of: :DecodeError, args: ['String', 'DecodeError']
+      variant :AtIndex,      of: :DecodeError, args: ['Int', 'DecodeError']
+      variant :Multiple,     of: :DecodeError, args: ['List(DecodeError)']
+      variant :Custom,       of: :DecodeError, args: ['String']
+
+      union :Value
+      union :Decoder, 'a'
+
+      interface(
+        'Decodable',
+        'a',
+        { 'decoder' => 'Decoder(a)' },
+      )
+
+      # Primitives
+
+      function('string', {}, 'Decoder(String)') {
+        Jade::Decode::Decoder[Jade::Decode::Desc::Str[]]
+      }
+
+      function('int', {}, 'Decoder(Int)') {
+        Jade::Decode::Decoder[Jade::Decode::Desc::Int[]]
+      }
+
+      function('float', {}, 'Decoder(Float)') {
+        Jade::Decode::Decoder[Jade::Decode::Desc::Flt[]]
+      }
+
+      function('bool', {}, 'Decoder(Bool)') {
+        Jade::Decode::Decoder[Jade::Decode::Desc::Bool[]]
+      }
+
+      # Structural
+
+      function(
+        'nullable',
+        { decoder: 'Decoder(a)' },
+        'Decoder(Maybe(a))',
+      ) { |decoder|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Nullable[decoder.desc]]
+      }
+
+      function(
+        'field',
+        { key: 'String', decoder: 'Decoder(a)' },
+        'Decoder(a)',
+      ) { |key, decoder|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Field[key, decoder.desc]]
+      }
+
+      function(
+        'optional_field',
+        { key: 'String', decoder: 'Decoder(a)' },
+        'Decoder(Maybe(a))',
+      ) { |key, decoder|
+        Jade::Decode::Decoder[Jade::Decode::Desc::OptField[key, decoder.desc]]
+      }
+
+      function(
+        'index',
+        { i: 'Int', decoder: 'Decoder(a)' },
+        'Decoder(a)',
+      ) { |i, decoder|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Idx[i, decoder.desc]]
+      }
+
+      function(
+        'list',
+        { decoder: 'Decoder(a)' },
+        'Decoder(List(a))',
+      ) { |decoder|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Lst[decoder.desc]]
+      }
+
+      # Decodes either a Hash (natural Ruby/JSON object form) or a list
+      # of `[k, v]` pairs (what Encode.dict emits — also the only shape
+      # that round-trips non-String key types).
+      function(
+        'dict',
+        { k_dec: 'Decoder(k)', v_dec: 'Decoder(v)' },
+        'Decoder(Dict(k, v))',
+      ) { |k_dec, v_dec|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Dct[k_dec.desc, v_dec.desc]]
+      }
+
+      # Mapping
+
+      function(
+        'map',
+        { decoder: 'Decoder(a)', fn: 'a -> b' },
+        'Decoder(b)',
+      ) { |decoder, fn|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Map[fn, decoder.desc]]
+      }
+
+      # Pipeline
+
+      function(
+        'succeed',
+        { value: 'a' },
+        'Decoder(a)',
+      ) { |value|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Succeed[value]]
+      }
+
+      function(
+        'and_map',
+        { wrapped: 'Decoder(a -> b)', decoder: 'Decoder(a)' },
+        'Decoder(b)',
+      ) { |wrapped, decoder|
+        Jade::Decode::Decoder[Jade::Decode::Desc::AndMap[wrapped.desc, decoder.desc]]
+      }
+
+      function(
+        'required',
+        { wrapped: 'Decoder(a -> b)', key: 'String', field_decoder: 'Decoder(a)' },
+        'Decoder(b)',
+      ) { |wrapped, key, field_decoder|
+        Jade::Decode::Desc::Field[key, field_decoder.desc]
+          .then { Jade::Decode::Decoder[Jade::Decode::Desc::AndMap[wrapped.desc, it]] }
+      }
+
+      function(
+        'optional',
+        {
+          wrapped: 'Decoder(a -> b)',
+          key: 'String',
+          field_decoder: 'Decoder(a)',
+          default: 'a',
+        },
+        'Decoder(b)',
+      ) { |wrapped, key, field_decoder, default|
+        Jade::Decode::Desc::Optional[key, field_decoder.desc, default]
+          .then { Jade::Decode::Decoder[Jade::Decode::Desc::AndMap[wrapped.desc, it]] }
+      }
+
+      function(
+        'sequence',
+        { decoders: 'List(Decoder(a))' },
+        'Decoder(List(a))',
+      ) { |decoders|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Sequence[decoders.map(&:desc)]]
+      }
+
+      function(
+        'one_of',
+        { decoders: 'List(Decoder(a))' },
+        'Decoder(a)',
+      ) { |decoders|
+        Jade::Decode::Decoder[Jade::Decode::Desc::OneOf[decoders.map(&:desc)]]
+      }
+
+      function(
+        'and_then',
+        { decoder: 'Decoder(a)', fn: 'a -> Decoder(b)' },
+        'Decoder(b)',
+      ) { |decoder, fn|
+        Jade::Decode::Decoder[Jade::Decode::Desc::AndThen[fn, decoder.desc]]
+      }
+
+      function(
+        'fail',
+        { msg: 'String' },
+        'Decoder(a)',
+      ) { |msg|
+        Jade::Decode::Decoder[Jade::Decode::Desc::Fail[msg]]
+      }
+
+      function(
+        'from_result',
+        { r: 'Result(a, String)' },
+        'Decoder(a)',
+      ) { |r|
+        case r
+        in Jade::Result::Ok[v]   then Jade::Decode::Decoder[Jade::Decode::Desc::Succeed[v]]
+        in Jade::Result::Err[e]  then Jade::Decode::Decoder[Jade::Decode::Desc::Fail[e]]
+        end
+      }
+
+      # Entry points
+
+      function(
+        'decode',
+        { decoder: 'Decoder(a)', value: 'Value' },
+        'Result(a, DecodeError)',
+      ) { |decoder, value|
+        Jade::Decode::Runner.run(decoder, value)
+      }
+
+      function(
+        'decode_string',
+        { decoder: 'Decoder(a)', json: 'String' },
+        'Result(a, DecodeError)',
+      ) { |decoder, json|
+        Jade::Decode::Runner.from_json(decoder, json)
+      }
+
+      # Constrained helpers — pick the decoder via Decodable.
+
+      function(
+        'from_value',
+        { value: 'Value' },
+        'Result(a, DecodeError)',
+        constraints: [['Decode.Decodable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['value'],
+          body: [:call,
+            [:stdlib_fn, 'Decode.decode'],
+            [
+              [:impl_arg, 0, 'decoder'],
+              [:var, 'value'],
+            ],
+          ],
+        ),
+      )
+
+      function(
+        'from_json',
+        { json: 'String' },
+        'Result(a, DecodeError)',
+        constraints: [['Decode.Decodable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['json'],
+          body: [:call,
+            [:stdlib_fn, 'Decode.decode_string'],
+            [
+              [:impl_arg, 0, 'decoder'],
+              [:var, 'json'],
+            ],
+          ],
+        ),
+      )
+
+      # Builder seed for `[name, ...args]`-shape union decoding. Compose
+      # with `variant` via `|>`:
+      #   Decode.type_
+      #     |> Decode.variant("A", ...)
+      #     |> Decode.variant("B", ...)
+      function('type_', {}, 'Decoder(a)') {
+        Jade::Decode::Decoder[Jade::Decode::Desc::Variant[{}]]
+      }
+
+      function(
+        'variant',
+        { builder: 'Decoder(a)', name: 'String', decoder: 'Decoder(a)' },
+        'Decoder(a)',
+      ) { |builder, name, decoder|
+        builder.desc => Jade::Decode::Desc::Variant[cases]
+        cases
+          .merge(name => decoder.desc)
+          .then { Jade::Decode::Desc::Variant[it] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
+      function(
+        'tuple',
+        { a: 'Decoder(a)', b: 'Decoder(b)' },
+        'Decoder(Tuple2(a, b))',
+      ) { |da, db|
+        Jade::Decode::Desc::Succeed[Jade::Tuple::Tuple2.method(:[]).curry(2)]
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[0, da.desc]] }
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[1, db.desc]] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
+      function(
+        'tuple3',
+        { a: 'Decoder(a)', b: 'Decoder(b)', c: 'Decoder(c)' },
+        'Decoder(Tuple3(a, b, c))',
+      ) { |da, db, dc|
+        Jade::Decode::Desc::Succeed[Jade::Tuple::Tuple3.method(:[]).curry(3)]
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[0, da.desc]] }
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[1, db.desc]] }
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[2, dc.desc]] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
+      function(
+        'tuple4',
+        { a: 'Decoder(a)', b: 'Decoder(b)', c: 'Decoder(c)', d: 'Decoder(d)' },
+        'Decoder(Tuple4(a, b, c, d))',
+      ) { |da, db, dc, dd|
+        Jade::Decode::Desc::Succeed[Jade::Tuple::Tuple4.method(:[]).curry(4)]
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[0, da.desc]] }
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[1, db.desc]] }
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[2, dc.desc]] }
+          .then { Jade::Decode::Desc::AndMap[it, Jade::Decode::Desc::Idx[3, dd.desc]] }
+          .then { Jade::Decode::Decoder[it] }
+      }
+
+      # Primitive Decodable impls.
+
+      implementation('Decodable', 'Basics.Int',    'decoder' => 'int')
+      implementation('Decodable', 'Basics.Float',  'decoder' => 'float')
+      implementation('Decodable', 'Basics.Bool',   'decoder' => 'bool')
+      implementation('Decodable', 'String.String', 'decoder' => 'string')
+    end
+  end
+end

data/lib/jade/stdlib/dict.rb

@@ -0,0 +1,134 @@
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Dict
+      extend Intrinsics
+
+      import Basics
+      import Maybe
+      import List
+      import Tuple
+
+      union :Dict, 'k', 'v'
+
+      native_type :Dict, Jade::Dict::Dict
+
+      implementation('Eq', 'Dict', '(==)' => 'dict_eq')
+
+      function(:empty, {}, 'Dict(k, v)')
+
+      function(
+        :singleton,
+        { key: 'k', value: 'v' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(:"empty?", { dict: 'Dict(k, v)' }, 'Bool')
+      function(:size, { dict: 'Dict(k, v)' }, 'Int')
+
+      function(
+        :get,
+        { dict: 'Dict(k, v)', key: 'k' },
+        'Maybe(v)',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(
+        :"member?",
+        { dict: 'Dict(k, v)', key: 'k' },
+        'Bool',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(
+        :insert,
+        { dict: 'Dict(k, v)', key: 'k', value: 'v' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(
+        :remove,
+        { dict: 'Dict(k, v)', key: 'k' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(
+        :update,
+        { dict: 'Dict(k, v)', key: 'k', fn: 'Maybe(v) -> Maybe(v)' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      ) do |dict, key, fn|
+        current = dict.hash.key?(key) ? Jade::Maybe::Just[dict.hash[key]] : Jade::Maybe::Nothing[]
+        case fn.call(current)
+        in Jade::Maybe::Just[v] then Jade::Dict::Dict[dict.hash.merge(key => v)]
+        in Jade::Maybe::Nothing then Jade::Dict::Dict[dict.hash.except(key)]
+        end
+      end
+
+      function(:keys, { dict: 'Dict(k, v)' }, 'List(k)')
+      function(:values, { dict: 'Dict(k, v)' }, 'List(v)')
+      function(:to_list, { dict: 'Dict(k, v)' }, 'List(Tuple2(k, v))')
+
+      function(
+        :from_list,
+        { pairs: 'List(Tuple2(k, v))' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(
+        :map,
+        { dict: 'Dict(k, v)', fn: 'k, v -> v2' },
+        'Dict(k, v2)',
+      ) do |dict, fn|
+        dict.hash
+          .each_with_object({}) { |(k, v), h| h[k] = fn.call(k, v) }
+          .then { Jade::Dict::Dict[it] }
+      end
+
+      function(
+        :filter,
+        { dict: 'Dict(k, v)', fn: 'k, v -> Bool' },
+        'Dict(k, v)',
+      ) do |dict, fn|
+        dict.hash
+          .select { |k, v| fn.call(k, v) }
+          .then { Jade::Dict::Dict[it] }
+      end
+
+      function(
+        :fold,
+        { dict: 'Dict(k, v)', initial: 'b', fn: 'k, v, b -> b' },
+        'b',
+      ) do |dict, initial, fn|
+        dict.hash.reduce(initial) { |acc, (k, v)| fn.call(k, v, acc) }
+      end
+
+      function(
+        :union,
+        { left: 'Dict(k, v)', right: 'Dict(k, v)' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      )
+
+      function(
+        :merge,
+        { left: 'Dict(k, v)', right: 'Dict(k, v)', combine: 'v, v -> v' },
+        'Dict(k, v)',
+        constraints: [['Basics.Eq', 'k']],
+      ) do |left, right, combine|
+        right.hash
+          .merge(left.hash) { |_k, r_val, l_val| combine.call(l_val, r_val) }
+          .then { Jade::Dict::Dict[it] }
+      end
+
+      default_importing('Dict')
+
+      function('dict_eq', { a: 'Dict(k, v)', b: 'Dict(k, v)' }, 'Bool')
+    end
+  end
+end

data/lib/jade/stdlib/encode.rb

@@ -0,0 +1,143 @@
+require 'json'
+require 'jade/stdlib/intrinsics'
+
+module Jade
+  module Stdlib
+    module Encode
+      extend Intrinsics
+
+      import Maybe
+      import List
+      import Tuple
+      import Dict
+
+      interface(
+        'Encodable',
+        'a',
+        { 'encoder' => 'a -> Value' },
+      )
+
+      # Primitives
+
+      function('string', { s: 'String' }, 'Value') { it.dup }
+      function('int', { i: 'Int' }, 'Value') { it }
+      function('float', { f: 'Float' }, 'Value') { it.to_f }
+      function('bool', { b: 'Bool' }, 'Value') { it }
+      function('null', {}, 'Value') { nil }
+
+      # Structural
+
+      function(
+        'nullable',
+        { encoder: 'a -> Value', maybe: 'Maybe(a)' },
+        'Value',
+      ) { |encoder, maybe|
+        case maybe
+        in Jade::Maybe::Just[v] then encoder.call(v)
+        in Jade::Maybe::Nothing then nil
+        end
+      }
+
+      function(
+        'list',
+        { encoder: 'a -> Value', items: 'List(a)' },
+        'Value',
+      ) { |encoder, items|
+        items.map { encoder.call(it) }
+      }
+
+      # Dict encodes as a list of `[k_encoded, v_encoded]` pairs — JSON
+      # objects only support String keys, so list-of-pairs is the only
+      # shape that survives non-String key types round-trip.
+      function(
+        'dict',
+        { k_enc: 'k -> Value', v_enc: 'v -> Value', dict: 'Dict(k, v)' },
+        'Value',
+      ) { |k_enc, v_enc, dict|
+        dict.hash.map { |k, v| [k_enc.call(k), v_enc.call(v)] }
+      }
+
+      function(
+        'object',
+        { pairs: 'List(Tuple2(String, Value))' },
+        'Value',
+      ) { |pairs|
+        pairs
+          .each_with_object({}) { |pair, acc| acc[pair._1] = pair._2 }
+      }
+
+      function(
+        'field',
+        { key: 'String', encoder: 'a -> Value', value: 'a' },
+        'Tuple2(String, Value)',
+      ) { |key, encoder, value|
+        Jade::Tuple::Tuple2[key.dup, encoder.call(value)]
+      }
+
+      function(
+        'encode_to_string',
+        { value: 'Value' },
+        'String',
+      ) { |value|
+        JSON.generate(value)
+      }
+
+      # Produces `[name, *args]` — the `[name, ...args]`-shape that
+      # boundary Task outcomes use, here generalised so users can encode
+      # their own union variants through the same shape. Pair with
+      # Decode.type_ + Decode.variant on the decode side.
+      function(
+        'variant',
+        { name: 'String', args: 'List(Value)' },
+        'Value',
+      ) { |name, args| [name, *args] }
+
+      function(
+        'tuple',
+        { a_enc: 'a -> Value', b_enc: 'b -> Value', t: 'Tuple2(a, b)' },
+        'Value',
+      ) { |a_enc, b_enc, t| [a_enc.call(t._1), b_enc.call(t._2)] }
+
+      function(
+        'tuple3',
+        { a_enc: 'a -> Value', b_enc: 'b -> Value', c_enc: 'c -> Value', t: 'Tuple3(a, b, c)' },
+        'Value',
+      ) { |a_enc, b_enc, c_enc, t| [a_enc.call(t._1), b_enc.call(t._2), c_enc.call(t._3)] }
+
+      function(
+        'tuple4',
+        {
+          a_enc: 'a -> Value', b_enc: 'b -> Value',
+          c_enc: 'c -> Value', d_enc: 'd -> Value',
+          t: 'Tuple4(a, b, c, d)',
+        },
+        'Value',
+      ) { |a_enc, b_enc, c_enc, d_enc, t|
+        [a_enc.call(t._1), b_enc.call(t._2), c_enc.call(t._3), d_enc.call(t._4)]
+      }
+
+      # Constrained — picks the encoder via Encodable.
+
+      function(
+        'encode',
+        { x: 'a' },
+        'Value',
+        constraints: [['Encode.Encodable', 'a']],
+        body: Symbol::DerivedFunction.new(
+          params: ['x'],
+          body: [:call,
+            [:impl_arg, 0, 'encoder'],
+            [[:var, 'x']],
+          ],
+        ),
+      )
+
+      # Primitive Encodable impls.
+
+      implementation('Encodable', 'Basics.Int',    'encoder' => 'int')
+      implementation('Encodable', 'Basics.Float',  'encoder' => 'float')
+      implementation('Encodable', 'Basics.Bool',   'encoder' => 'bool')
+      implementation('Encodable', 'String.String', 'encoder' => 'string')
+    end
+  end
+end