rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/metalua/extension/ternary.mlua

@@ -0,0 +1,10 @@
+local function b(x, suffix)
+   local v, ontrue, onfalse = mlp.gensym "test", unpack (suffix)
+   return `Stat{ 
+      +{ block:
+         local -{v}
+         if -{x} then (-{v}) = -{ontrue} else (-{v}) = -{onfalse or `Nil} end },
+      v }
+end
+
+mlp.expr.suffix:add{ "?", mlp.expr, gg.onkeyword{ ",", mlp.expr }, prec=5, builder=b }

data/vendor/lua/lib/lua/metalua/extension/trycatch.mlua

@@ -0,0 +1,189 @@
+-{ extension 'match' }
+
+--------------------------------------------------------------------------------
+--
+-- TODO:
+--
+-- * Hygienize calls to pcall()
+--
+--------------------------------------------------------------------------------
+
+-{ extension 'H' }
+-{ extension 'log' }
+
+-- Get match parsers and builder, for catch cases handling:
+local match_alpha = require 'metalua.extension.match'
+local H = H:new{side='inside', alpha = match_alpha }
+
+-- We'll need to track rogue return statements:
+require 'metalua.walk'
+
+-- Put a block AST into a pcall():
+local mkpcall = |block| +{pcall(function() -{block} end)}
+
+-- The statement builder:
+function trycatch_builder(x)
+   --$log ("trycatch_builder", x, 'nohash', 60)
+   local try_code, catch_cases, finally_code = unpack(x)
+   local insert_return_catcher = false
+
+   -- Can't be hygienize automatically by the current version of H, as
+   -- it must bridge from inside user code (hacjed return statements)
+   -- to outside macro code.
+   local caught_return = !mlp.gensym 'caught_return'
+   local saved_args
+
+   !try_code; !(finally_code or { })
+   -- FIXME: Am I sure there's no need to hygienize inside?
+   --[[if catch_cases then
+      for case in ivalues(catch_cases) do
+         --$log(case,'nohash')
+         local patterns, guard, block = unpack(case)
+         ! block
+      end
+   end]]
+
+
+   ----------------------------------------------------------------
+   -- Returns in the try-block must be transformed:
+   -- from the user's PoV, the code in the try-block isn't
+   -- a function, therefore a return in it must not merely
+   -- end the execution of the try block, but:
+   --  * not cause any error to be caught;
+   --  * let the finally-block be executed;
+   --  * only then, let the enclosing function return with the
+   --    appropraite values.
+   -- The way to handle that is that any returned value is stored
+   -- into the runtime variable caught_return, then a return with
+   -- no value is sent, to stop the execution of the try-code.
+   --
+   -- Similarly, a return in a catch case code must not prevent
+   -- the finally-code from being run.
+   --
+   -- This walker catches return statements and perform the relevant
+   -- transformation into caught_return setting + empty return.
+   --
+   -- There is an insert_return_catcher compile-time flag, which
+   -- allows to avoid inserting return-handling code in the result
+   -- when not needed.
+   ----------------------------------------------------------------
+   local replace_returns_and_dots do
+      local function f(x)
+         match x with
+         | `Return{...} ->
+            insert_return_catcher = true
+            -- Setvar's 'caught_return' code can't be hygienize by H currently.
+            local setvar = `Set{ {caught_return}, { `Table{ unpack(x) } } }
+            x <- { setvar; `Return }; x.tag = nil;
+            --$log('transformed return stat:', x, 60)
+            return 'break'
+         | `Function{...} -> return 'break'
+            -- inside this, returns would be the nested function's, not ours.
+         | `Dots ->
+            if not saved_args then saved_args = mlp.gensym 'args' end
+            x <- `Call{ `Id 'unpack', saved_args }
+         | _ -> -- pass
+         end
+      end
+      local cfg = { stat = {down=f}, expr = {down=f} }
+      replace_returns_and_dots = |x| walk.block(cfg, x)
+   end
+
+   -- parse returns in the try-block:
+   replace_returns_and_dots (try_code)
+
+   -- code handling the error catching process:
+   local catch_result do
+      if catch_cases and #catch_cases>0 then
+         ----------------------------------------------------------
+         -- Protect catch code against failures: they run in a pcall(), and
+         -- the result is kept in catch_* vars so that it can be used to
+         -- relaunch the error after the finally code has been executed.
+         ----------------------------------------------------------
+         for x in ivalues (catch_cases) do
+            local case_code = x[3]
+            -- handle rogue returns:
+            replace_returns_and_dots (case_code)
+            -- in case of error in the catch, we still need to run "finally":
+            x[3] = +{block: catch_success, catch_error = -{mkpcall(case_code)}}
+         end
+         ----------------------------------------------------------
+         -- Uncaught exceptions must not cause a mismatch,
+         -- so we introduce a catch-all do-nothing last case:
+         ----------------------------------------------------------
+         table.insert (catch_cases, { { { `Id '_' } }, false, { } })
+         catch_result = spmatch.match_builder{ {+{user_error}}, catch_cases }
+      else
+         catch_result = { }
+      end
+   end
+
+   ----------------------------------------------------------------
+   -- Build the bits of code that will handle return statements
+   -- in the user code (try-block and catch-blocks).
+   ----------------------------------------------------------------
+   local caught_return_init, caught_return_rethrow do
+      if insert_return_catcher then
+         caught_return_init    = `Local{{caught_return}}
+         caught_return_rethrow =
+            +{stat: if -{caught_return} then return unpack(-{caught_return}) end}
+      else
+         caught_return_init, caught_return_rethrow = { }, { }
+      end
+   end
+
+   local saved_args_init =
+      saved_args and `Local{ {saved_args}, { `Table{`Dots} } } or { }
+
+   -- The finally code, to execute no matter what:
+   local finally_result = finally_code or { }
+
+   -- And the whole statement, gluing all taht together:
+   local result = +{stat:
+      do
+         -{ saved_args_init }
+         -{ caught_return_init }
+         local user_success,  user_error  = -{mkpcall(try_code)}
+         local catch_success, catch_error = false, user_error
+         if not user_success then -{catch_result} end
+         -{finally_result}
+         if not user_success and not catch_success then error(catch_error) end
+         -{ caught_return_rethrow }
+      end }
+
+   H(result)
+
+   return result
+end
+
+function catch_case_builder(x)
+   --$log ("catch_case_builder", x, 'nohash', 60)
+   local patterns, guard, _, code = unpack(x)
+   -- patterns ought to be a pattern_group, but each expression must
+   -- be converted into a single-element pattern_seq.
+   for i = 1, #patterns do patterns[i] = {patterns[i]} end
+   return { patterns, guard, code }
+end
+
+mlp.lexer:add{ 'try', 'catch', 'finally', '->' }
+mlp.block.terminators:add{ 'catch', 'finally' }
+
+mlp.stat:add{
+   'try',
+   mlp.block,
+   gg.onkeyword{ 'catch',
+      gg.list{
+         gg.sequence{
+            mlp.expr_list,
+            gg.onkeyword{ 'if', mlp.expr },
+            gg.optkeyword 'then',
+            mlp.block,
+            builder = catch_case_builder },
+         separators = 'catch' } },
+   gg.onkeyword{ 'finally', mlp.block },
+   'end',
+   builder = trycatch_builder }
+
+return H.alpha
+
+

data/vendor/lua/lib/lua/metalua/extension/types-runtime.mlua

@@ -0,0 +1,159 @@
+--------------------------------------------------------------------------------
+-- Initialize the types table. It has an __index metatable entry,
+-- so that if a symbol is not found in it, it is looked for in the current
+-- environment. It allows to write things like [ n=3; x :: vector(n) ].
+--------------------------------------------------------------------------------
+types = { }
+setmetatable (types, { __index = getfenv(0)})
+
+function types.error (fmt, ...)
+   error(string.format("Runtime type-checking failure: "..fmt, ...))
+end
+
+--------------------------------------------------------------------------------
+-- Add a prefix to an error message, if an error occurs.
+-- Useful for type checkers that call sub-type-checkers.
+--------------------------------------------------------------------------------
+local function nest_error (prefix, ...)
+   local status, msg = pcall(...)
+   if not status then types.error("%s:\n%s", prefix, msg) end
+end
+
+--------------------------------------------------------------------------------
+-- Built-in types
+--------------------------------------------------------------------------------
+for typename in values{ "number", "string", "boolean", "function", "thread" } do
+   types[typename] = 
+      function (val)           
+         if type(val) ~= typename then types.error ("%s expected", typename) end
+      end
+end
+
+function types.integer(val)
+   if type(val)~='number' or val%1~=0 then types.error 'integer expected' end
+end
+
+--------------------------------------------------------------------------------
+-- table(foo) checks
+-- table(foo, bar) checks
+-- table(i) where i is an integer checks
+-- table(i, j) where i and j are integers checks
+-- Integers and key/value types can be combined
+--------------------------------------------------------------------------------
+function types.table (...)
+
+   local key_type, val_type, range_from, range_to
+   -- arguments parsing
+   for x in values{...} do
+      if type(x) == "number" then
+         if range2    then types.error "Invalid type: too many numbers in table type"
+         elseif range1 then range2 = x
+         else   range1 = x end
+      else
+         if     type_key  then types.error "Invalid type: too many types"
+         elseif type_val  then type_key, type_val = type_val, x
+         else   type_val = x end
+      end
+   end
+   if not range2 then range2=range1 end
+   if not type_key then type_key = types.integer end
+   return function (val)
+      if type(val) ~= "table" then types.error "table expected" end
+      local s = #val
+      if range2 and range2 > s then types.error "Not enough table elements" end
+      if range1 and range1 < s then types.error "Too many elements table elements" end
+      for k,v in pairs(val) do 
+         nest_error ("in table key",   type_key, k)
+         nest_error ("in table value", type_val, v)
+      end
+   end
+end
+
+--------------------------------------------------------------------------------
+-- [list (subtype)] checks that the term is a table, and all of its 
+-- integer-indexed elements are of type [subtype].
+--------------------------------------------------------------------------------
+types.list = |...| types.table (types.integer, ...)
+
+--------------------------------------------------------------------------------
+-- Check that [x] is an integral number
+--------------------------------------------------------------------------------
+function types.int (x)
+   if type(x)~="number" or x%1~=0 then types.error "Integer number expected" end
+end
+
+--------------------------------------------------------------------------------
+-- [range(a,b)] checks that number [val] is between [a] and [b]. [a] and [b]
+-- can be omitted.
+--------------------------------------------------------------------------------
+function types.range (a,b)
+   return function (val)
+      if type(val)~="number" or a and val<a or b and val>b then 
+         types.error ("Number between %s and %s expected",
+                      a and tostring(a) or "-infty",
+                      b and tostring(b) or "+infty")
+      end
+   end
+end
+
+--------------------------------------------------------------------------------
+-- [inter (x, y)] checks that the term has both types [x] and [y].
+--------------------------------------------------------------------------------
+function types.inter (...)
+   local args={...}
+   return function(val)
+      for t in values(args) do nest_error ("in inter type", t, args) end
+   end
+end      
+
+--------------------------------------------------------------------------------
+-- [inter (x, y)] checks that the term has type either [x] or [y].
+--------------------------------------------------------------------------------
+function types.union (...)
+   local args={...}
+   return function(val)
+      for t in values(args) do if pcall(t, val) then return end end
+      types.error "None of the types in the union fits"
+   end
+end      
+
+--------------------------------------------------------------------------------
+-- [optional(t)] accepts values of types [t] or [nil].
+--------------------------------------------------------------------------------
+function types.optional(t)
+   return function(val) 
+             if val~=nil then nest_error("In optional type", t, val) end 
+   end
+end  
+
+--------------------------------------------------------------------------------
+-- A call to this is done on litteral tables passed as types, i.e.
+-- type {1,2,3} is transformed into types.__table{1,2,3}.
+--------------------------------------------------------------------------------
+function types.__table(s_type)
+   return function (s_val)
+      if type(s_val) ~= "table" then types.error "Struct table expected" end
+      for k, field_type in pairs (s_type) do
+         nest_error ("in struct field "..k, field_type, s_val[k])
+      end
+   end
+end
+
+--------------------------------------------------------------------------------
+-- Same as __table, except that it's called on literal strings.
+--------------------------------------------------------------------------------
+function types.__string(s_type)
+   return function (s_val)
+      if s_val ~= s_type then
+         types.error("String %q expected", s_type)
+      end
+   end
+end
+
+--------------------------------------------------------------------------------
+-- Top and Bottom:
+--------------------------------------------------------------------------------
+function types.any() end
+function types.none() types.error "Empty type" end
+types.__or  = types.union
+types.__and = types.inter

data/vendor/lua/lib/lua/metalua/extension/types.mlua

@@ -0,0 +1,352 @@
+-- This extension inserts type-checking code at approriate place in the code,
+-- thanks to annotations based on "::" keyword:
+--
+-- * function declarations can be annotated with a returned type. When they
+--   are, type-checking code is inserted in each of their return statements,
+--   to make sure they return the expected type.
+--
+-- * function parameters can also be annotated. If they are, type-checking
+--   code is inserted in the function body, which checks the arguments' types
+--   and cause an explicit error upon incorrect calls. Moreover, if a new value
+--   is assigned to the parameter in the function's body, the new value's type
+--   is checked before the assignment is performed.
+--
+-- * Local variables can also be annotated. If they are, type-checking
+--   code is inserted before any value assignment or re-assignment is
+--   performed on them.
+--
+-- Type checking can be disabled with:
+--
+-- -{stat: types.enabled = false }
+--
+-- Code transformation is performed at the chunk level, i.e. file by
+-- file.  Therefore, it the value of compile-time variable
+-- [types.enabled] changes in the file, the only value that counts is
+-- its value once the file is entirely parsed.
+--
+-- Syntax
+-- ======
+--
+-- Syntax annotations consist of "::" followed by a type
+-- specifier. They can appear after a function parameter name, after
+-- the closing parameter parenthese of a function, or after a local
+-- variable name in the declaration. See example in samples.
+--
+-- Type specifiers are expressions, in which identifiers are taken
+-- from table types. For instance, [number] is transformed into
+-- [types.number]. These [types.xxx] fields must contain functions,
+-- which generate an error when they receive an argument which doesn't
+-- belong to the type they represent. It is perfectly acceptible for a
+-- type-checking function to return another type-checking function,
+-- thus defining parametric/generic types. Parameters can be
+-- identifiers (they're then considered as indexes in table [types])
+-- or literals.
+--
+-- Design hints
+-- ============
+--
+-- This extension uses the code walking library [walk] to globally
+-- transform the chunk AST. See [chunk_transformer()] for details
+-- about the walker.
+--
+-- During parsing, type informations are stored in string-indexed
+-- fields, in the AST nodes of tags `Local and `Function. They are
+-- used by the walker to generate code only if [types.enabled] is
+-- true.
+--
+-- TODO
+-- ====
+--
+-- It's easy to add global vars type-checking, by declaring :: as an
+-- assignment operator.  It's easy to add arbitrary expr
+-- type-checking, by declaring :: as an infix operator. How to make
+-- both cohabit?
+
+--------------------------------------------------------------------------------
+--
+-- Function chunk_transformer()
+--
+--------------------------------------------------------------------------------
+--
+-- Takes a block annotated with extra fields, describing typing
+-- constraints, and returns a normal AST where these constraints have
+-- been turned into type-checking instructions.
+--
+-- It relies on the following annotations:
+--
+--  * [`Local{ }] statements may have a [types] field, which contains a
+--    id name ==> type name map.
+--
+--  * [Function{ }] expressions may have an [param_types] field, also a
+--    id name ==> type name map. They may also have a [ret_type] field
+--    containing the type of the returned value.
+--
+-- Design hints:
+-- =============
+--
+-- It relies on the code walking library, and two states:
+--
+--  * [return_types] is a stack of the expected return values types for
+--    the functions currently in scope, the most deeply nested one
+--    having the biggest index.
+--
+--  * [scopes] is a stack of id name ==> type name scopes, one per
+--    currently active variables scope.
+--
+-- What's performed by the walker:
+--
+--  * Assignments to a typed variable involve a type checking of the
+--    new value;
+--
+--  * Local declarations are checked for additional type declarations.
+--
+--  * Blocks create and destroy variable scopes in [scopes]
+--
+--  * Functions create an additional scope (around its body block's scope)
+--    which retains its argument type associations, and stacks another
+--    return type (or [false] if no type constraint is given)
+--
+--  * Return statements get the additional type checking statement if
+--    applicable.
+--
+--------------------------------------------------------------------------------
+
+-- TODO: unify scopes handling with free variables detector
+-- FIXME: scopes are currently incorrect anyway, only functions currently define a scope.
+
+require "metalua.walk"
+
+-{ extension 'match' }
+
+module("types", package.seeall)
+
+enabled = true
+
+local function chunk_transformer (block)
+   if not enabled then return end
+   local return_types, scopes = { }, { }
+   local cfg = { block = { }; stat = { }; expr = { } }
+
+   function cfg.stat.down (x)
+      match x with
+      | `Local{ lhs, rhs, types = x_types } ->
+         -- Add new types declared by lhs in current scope.
+         local myscope = scopes [#scopes]
+         for var, type in pairs (x_types) do
+            myscope [var] = process_type (type)
+         end
+         -- Type-check each rhs value with the type of the
+         -- corresponding lhs declaration, if any.  Check backward, in
+         -- case a local var name is used more than once.
+         for i = 1, max (#lhs, #rhs) do
+            local type, new_val = myscope[lhs[i][1]], rhs[i]
+            if type and new_val then
+               rhs[i] = checktype_builder (type, new_val, 'expr')
+            end
+         end
+      | `Set{ lhs, rhs } ->
+         for i=1, #lhs do
+            match lhs[i] with
+            | `Id{ v } ->
+               -- Retrieve the type associated with the variable, if any:
+               local  j, type = #scopes, nil
+               repeat j, type = j-1, scopes[j][v] until type or j==0
+               -- If a type constraint is found, apply it:
+               if type then rhs[i] = checktype_builder(type, rhs[i] or `Nil, 'expr') end
+            | _ -> -- assignment to a non-variable, pass
+            end
+         end
+      | `Return{ r_val } ->
+         local r_type = return_types[#return_types]
+         if r_type then
+            x <- `Return{ checktype_builder (r_type, r_val, 'expr') }
+         end
+      | _ -> -- pass
+      end
+   end
+
+   function cfg.expr.down (x)
+      if x.tag ~= 'Function' then return end
+      local new_scope = { }
+      table.insert (scopes, new_scope)
+      for var, type in pairs (x.param_types or { }) do
+         new_scope[var] = process_type (type)
+      end
+      local r_type = x.ret_type and process_type (x.ret_type) or false
+      table.insert (return_types, r_type)
+   end
+
+   -------------------------------------------------------------------
+   -- Unregister the returned type and the variable scope in which
+   -- arguments are registered;
+   -- then, adds the parameters type checking instructions at the
+   -- beginning of the function, if applicable.
+   -------------------------------------------------------------------
+   function cfg.expr.up (x)
+      if x.tag ~= 'Function' then return end
+      -- Unregister stuff going out of scope:
+      table.remove (return_types)
+      table.remove (scopes)
+      -- Add initial type checking:
+      for v, t in pairs(x.param_types or { }) do
+         table.insert(x[2], 1, checktype_builder(t, `Id{v}, 'stat'))
+      end
+   end
+
+   cfg.block.down = || table.insert (scopes, { })
+   cfg.block.up   = || table.remove (scopes)
+
+   walk.block(cfg, block)
+end
+
+--------------------------------------------------------------------------
+-- Perform required transformations to change a raw type expression into
+-- a callable function:
+--
+--  * identifiers are changed into indexes in [types], unless they're
+--    allready indexed, or into parentheses;
+--
+--  * literal tables are embedded into a call to types.__table
+--
+-- This transformation is not performed when type checking is disabled:
+-- types are stored under their raw form in the AST; the transformation is
+-- only performed when they're put in the stacks (scopes and return_types)
+-- of the main walker.
+--------------------------------------------------------------------------
+function process_type (type_term)
+   -- Transform the type:
+   cfg = { expr = { } }
+
+   function cfg.expr.down(x)
+      match x with
+      | `Index{...} | `Paren{...} -> return 'break'
+      | _ -> -- pass
+      end
+   end
+   function cfg.expr.up (x)
+      match x with
+      | `Id{i} -> x <- `Index{ `Id "types", `String{ i } }
+      | `Table{...} | `String{...} | `Op{...} ->
+         local xcopy, name = table.shallow_copy(x)
+         match x.tag with
+         | 'Table'  -> name = '__table'
+         | 'String' -> name = '__string'
+         | 'Op'     -> name = '__'..x[1]
+         end
+         x <- `Call{ `Index{ `Id "types", `String{ name } }, xcopy }
+      | `Function{ params, { results } } if results.tag=='Return' ->
+         results.tag = nil
+         x <- `Call{ +{types.__function}, params, results }
+      | `Function{...} -> error "malformed function type"
+      | _ -> -- pass
+      end
+   end
+   walk.expr(cfg, type_term)
+   return type_term
+end
+
+--------------------------------------------------------------------------
+-- Insert a type-checking function call on [term] before returning
+-- [term]'s value. Only legal in an expression context.
+--------------------------------------------------------------------------
+local non_const_tags = table.transpose
+   { 'Dots', 'Op', 'Index', 'Call', 'Invoke', 'Table' }
+function checktype_builder(type, term, kind)
+   -- Shove type-checking code into the term to check:
+   match kind with
+   | 'expr' if non_const_tags [term.tag] ->
+      local  v = mlp.gensym()
+      return `Stat{ { `Local{ {v}, {term} }; `Call{ type, v } }, v }
+   | 'expr' ->
+      return `Stat{ { `Call{ type, term } }, term }
+   | 'stat' ->
+      return `Call{ type, term }
+   end
+end
+
+--------------------------------------------------------------------------
+-- Parse the typechecking tests in a function definition, and adds the
+-- corresponding tests at the beginning of the function's body.
+--------------------------------------------------------------------------
+local function func_val_builder (x)
+   local typed_params, ret_type, body = unpack(x)
+   local e = `Function{ { }, body; param_types = { }; ret_type = ret_type }
+
+   -- Build [untyped_params] list, and [e.param_types] dictionary.
+   for i, y in ipairs (typed_params) do
+      if y.tag=="Dots" then
+         assert(i==#typed_params, "`...' must be the last parameter")
+         break
+      end
+      local param, type = unpack(y)
+      e[1][i] = param
+      if type then e.param_types[param[1]] = type end
+   end
+   return e
+end
+
+--------------------------------------------------------------------------
+-- Parse ":: type" annotation if next token is "::", or return false.
+-- Called by function parameters parser
+--------------------------------------------------------------------------
+local opt_type = gg.onkeyword{ "::", mlp.expr }
+
+--------------------------------------------------------------------------
+-- Updated function definition parser, which accepts typed vars as
+-- parameters.
+--------------------------------------------------------------------------
+
+-- Parameters parsing:
+local id_or_dots = gg.multisequence{ { "...", builder = "Dots" }, default = mlp.id }
+
+-- Function parsing:
+mlp.func_val = gg.sequence{
+   "(", gg.list{
+      gg.sequence{ id_or_dots, opt_type }, terminators = ")", separators  = "," },
+   ")",  opt_type, mlp.block, "end",
+   builder = func_val_builder }
+
+mlp.lexer:add { "::", "newtype" }
+mlp.chunk.transformers:add (chunk_transformer)
+
+-- Local declarations parsing:
+local local_decl_parser = mlp.stat:get "local" [2].default
+
+local_decl_parser[1].primary = gg.sequence{ mlp.id, opt_type }
+
+function local_decl_parser.builder(x)
+   local lhs, rhs = unpack(x)
+   local s, stypes = `Local{ { }, rhs or { } }, { }
+   for i = 1, #lhs do
+      local id, type = unpack(lhs[i])
+      s[1][i] = id
+      if type then stypes[id[1]]=type end
+   end
+   if next(stypes) then s.types = stypes end
+   return s
+end
+
+function newtype_builder(x)
+   local lhs, rhs = unpack(x)
+   match lhs with
+   | `Id{ x } -> t = process_type (rhs)
+   | `Call{ `Id{ x }, ... } ->
+      t = `Function{ { }, rhs }
+      for i = 2, #lhs do
+         if lhs[i].tag ~= "Id" then error "Invalid newtype parameter" end
+         t[1][i-1] = lhs[i]
+      end
+   | _ -> error "Invalid newtype definition"
+   end
+   return `Let{ { `Index{ `Id "types", `String{ x } } }, { t } }
+end
+
+mlp.stat:add{ "newtype", mlp.expr, "=", mlp.expr, builder = newtype_builder }
+
+
+--------------------------------------------------------------------------
+-- Register as an operator
+--------------------------------------------------------------------------
+--mlp.expr.infix:add{ "::", prec=100, builder = |a, _, b| insert_test(a,b) }
+
+return +{ require (-{ `String{ package.metalua_extension_prefix .. 'types-runtime' } }) }