Module: Jade::Codegen::Boundary::Specialized

Extended by:
Specialized
Included in:
Specialized
Defined in:
lib/jade/codegen/boundary/specialized.rb,
lib/jade/codegen/boundary/specialized/list.rb,
lib/jade/codegen/boundary/specialized/maybe.rb,
lib/jade/codegen/boundary/specialized/record.rb,
lib/jade/codegen/boundary/specialized/scalar.rb

Overview

Emits inline boundary code for known-shape types — scalars, ‘List(specializable)`, `Maybe(specializable)`, and structs whose fields are all specializable. Bypasses `Decode::Runner` and the descriptor cache.

This module is the dispatcher: each shape (‘Scalar`, `List`, `Maybe`, `Record`) lives in its own file under `specialized/`, exposing `decode` / `encode` / `specializable?` methods that the dispatcher tries in order. Shapes that contain other types (`List`, `Maybe`, `Record`) recurse back through the dispatcher.

Defined Under Namespace

Modules: List, Maybe, Record, Scalar

Instance Method Summary collapse

Instance Method Details

#args_of(type) ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 83

def args_of(type)
  case type
  in Type::Application(args:)         then args
  in Symbol::TypeApplication(args:)   then args
  else                                     nil
  end
end

#collect_helpers(body, registry) ⇒ Object 



57
58
59
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 57

def collect_helpers(body, registry)
  Record.collect_helpers(body, registry)
end

#decode_expr(type, input, registry) ⇒ Object

Ruby expression that validates ‘input` and yields the decoded value, or `nil` if `type` isn’t specializable.



24
25
26
27
28
29
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 24

def decode_expr(type, input, registry)
  Scalar.decode(type, input) ||
    List.decode(type, input, registry) ||
    Maybe.decode(type, input, registry) ||
    Record.decode(type, input, registry)
end

#emit_helpers(structs, registry) ⇒ Object 



61
62
63
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 61

def emit_helpers(structs, registry)
  Record.emit_helpers(structs, registry)
end

#encode_expr(type, value_expr, registry) ⇒ Object

Ruby expression that encodes ‘value_expr` to the wire form, or `nil` if the encoder is identity (caller skips the wrap) or the type isn’t specializable (caller falls back to the cache).



34
35
36
37
38
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 34

def encode_expr(type, value_expr, registry)
  Record.encode(type, value_expr, registry) ||
    List.encode(type, value_expr, registry) ||
    Maybe.encode(type, value_expr, registry)
end

#identity_encoder?(type) ⇒ Boolean

True when the encoder for ‘type` produces output equal to the input — the boundary wrapper can skip the encode call entirely. Recursive: `List(t)` is identity iff `t` is.

Returns:

  • (Boolean) 


43
44
45
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 43

def identity_encoder?(type)
  Scalar.identity_encoder?(type) || List.identity_encoder?(type)
end

#qname_of(type) ⇒ Object

Both ‘Type::Application` (from inferred boundary types) and `Symbol::TypeApplication` (from struct field declarations) carry the same constructor/args shape; normalize to a qname string.



70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 70

def qname_of(type)
  case type
  in Type::Application(constructor: Type::Constructor(name:))
    name

  in Symbol::TypeApplication(constructor: Symbol::TypeRef(module_name:, name: n))
    "#{module_name}.#{n}"

  else
    nil
  end
end

#specializable_field?(type, registry, seen) ⇒ Boolean

Predicate used by ‘Record.specializable_struct` when checking field types. The `seen` set carries struct qnames we’re already inside, threaded through container shapes for cycle detection.

Returns:

  • (Boolean) 


50
51
52
53
54
55
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 50

def specializable_field?(type, registry, seen)
  Scalar.specializable?(type, registry, seen) ||
    List.specializable?(type, registry, seen) ||
    Maybe.specializable?(type, registry, seen) ||
    Record.specializable?(type, registry, seen)
end

#type_label(type) ⇒ Object

Human-readable label for error messages on container types.



92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/jade/codegen/boundary/specialized.rb', line 92

def type_label(type)
  if (qname = Scalar.qname_for(type))
    Scalar::LABEL[qname]
  elsif (inner = List.inner_of(type))
    "List(#{type_label(inner)})"
  elsif (inner = Maybe.inner_of(type))
    "Maybe(#{type_label(inner)})"
  else
    (qname_of(type) || 'value').split('.').last
  end
end