Module: MilkTea::Types::Registry

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

Class Method Summary collapse

Class Method Details

._intern(key, &construct) ⇒ Object 



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

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

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



80
81
82
 
# File 'lib/milk_tea/core/types/registry.rb', line 80

def self.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 



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

def self.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 



27
28
29
30
 
# File 'lib/milk_tea/core/types/registry.rb', line 27

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

.lifetime_ref(name) ⇒ Object 



76
77
78
 
# File 'lib/milk_tea/core/types/registry.rb', line 76

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

.nullable(base) ⇒ Object 



23
24
25
 
# File 'lib/milk_tea/core/types/registry.rb', line 23

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

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



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

def self.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 



19
20
21
 
# File 'lib/milk_tea/core/types/registry.rb', line 19

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

.proc(params:, return_type:) ⇒ Object 



51
52
53
54
 
# File 'lib/milk_tea/core/types/registry.rb', line 51

def self.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 



9
10
11
 
# File 'lib/milk_tea/core/types/registry.rb', line 9

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

.simd(element_type, lane_count:) ⇒ Object 



72
73
74
 
# File 'lib/milk_tea/core/types/registry.rb', line 72

def self.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 



68
69
70
 
# File 'lib/milk_tea/core/types/registry.rb', line 68

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

.span(element_type) ⇒ Object 



32
33
34
 
# File 'lib/milk_tea/core/types/registry.rb', line 32

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

.string_view ⇒ Object 



40
41
42
 
# File 'lib/milk_tea/core/types/registry.rb', line 40

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

.task(result_type) ⇒ Object 



36
37
38
 
# File 'lib/milk_tea/core/types/registry.rb', line 36

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

.tuple(element_types, field_names: nil) ⇒ Object 



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

def self.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