Module: MilkTea::Types::Registry

Defined in:
lib/milk_tea/core/types/registry.rb

Class Method Summary collapse

Class Method Details

._intern(key, &construct) ⇒ Object 



15
16
17
18
19
 
# File 'lib/milk_tea/core/types/registry.rb', line 15

def _intern(key, &construct)
  @mutex.synchronize do
    @pool[key] ||= construct.call
  end
end

.dyn(interface_binding, type_arguments = []) ⇒ Object 



82
83
84
 
# File 'lib/milk_tea/core/types/registry.rb', line 82

def dyn(interface_binding, type_arguments = [])
  Dyn.new(interface_binding, type_arguments)
end

.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false) ⇒ Object 



46
47
48
49
50
51
 
# File 'lib/milk_tea/core/types/registry.rb', line 46

def function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
  params_frozen = params.freeze
  _intern([:function, name, params_frozen, return_type, receiver_type, receiver_editable, variadic, external]) {
    Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
  }
end

.generic_instance(name, arguments) ⇒ Object 



29
30
31
32
 
# File 'lib/milk_tea/core/types/registry.rb', line 29

def generic_instance(name, arguments)
  args = arguments.freeze
  _intern([:generic, name, args]) { GenericInstance.new(name, args) }
end

.lifetime_ref(name) ⇒ Object 



78
79
80
 
# File 'lib/milk_tea/core/types/registry.rb', line 78

def lifetime_ref(name)
  LifetimeRef.new(name)
end

.nullable(base) ⇒ Object 



25
26
27
 
# File 'lib/milk_tea/core/types/registry.rb', line 25

def nullable(base)
  _intern([:nullable, base]) { Nullable.new(base) }
end

.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil) ⇒ Object 



58
59
60
61
62
 
# File 'lib/milk_tea/core/types/registry.rb', line 58

def parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)
  _intern([:parameter, name, type, mutable, passing_mode, boundary_type]) {
    Parameter.new(name, type, mutable: mutable, passing_mode: passing_mode, boundary_type: boundary_type)
  }
end

.primitive(name) ⇒ Object 



21
22
23
 
# File 'lib/milk_tea/core/types/registry.rb', line 21

def primitive(name)
  _intern([:primitive, name]) { Primitive.new(name) }
end

.proc(params:, return_type:) ⇒ Object 



53
54
55
56
 
# File 'lib/milk_tea/core/types/registry.rb', line 53

def proc(params:, return_type:)
  params_frozen = params.freeze
  _intern([:proc, params_frozen, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
end

.reset! ⇒ Object 



11
12
13
 
# File 'lib/milk_tea/core/types/registry.rb', line 11

def reset!
  @mutex.synchronize { @pool.clear }
end

.simd(element_type, lane_count:) ⇒ Object 



74
75
76
 
# File 'lib/milk_tea/core/types/registry.rb', line 74

def simd(element_type, lane_count:)
  _intern([:simd, element_type, lane_count]) { Simd.new(element_type, lane_count: lane_count) }
end

.soa(element_type, count:) ⇒ Object 



70
71
72
 
# File 'lib/milk_tea/core/types/registry.rb', line 70

def soa(element_type, count:)
  _intern([:soa, element_type, count]) { SoA.new(element_type, count: count) }
end

.span(element_type) ⇒ Object 



34
35
36
 
# File 'lib/milk_tea/core/types/registry.rb', line 34

def span(element_type)
  _intern([:span, element_type]) { Span.new(element_type) }
end

.string_view ⇒ Object 



42
43
44
 
# File 'lib/milk_tea/core/types/registry.rb', line 42

def string_view
  _intern([:string_view]) { StringView.new }
end

.task(result_type) ⇒ Object 



38
39
40
 
# File 'lib/milk_tea/core/types/registry.rb', line 38

def task(result_type)
  _intern([:task, result_type]) { Task.new(result_type) }
end

.tuple(element_types, field_names: nil) ⇒ Object 



64
65
66
67
68
 
# File 'lib/milk_tea/core/types/registry.rb', line 64

def tuple(element_types, field_names: nil)
  et_frozen = element_types.freeze
  fn_frozen = field_names&.freeze
  _intern([:tuple, et_frozen, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
end