@adapt-toolkit/mufl 0.8.0

package/meta/meta.mm

@@ -0,0 +1,2666 @@
+PRAGMA LANGSERVER meta = 0
+library meta {
+    // TODO: tests for present cast
+    // TODO: tests for function and mutable type compatibility (tricky with arg/return)
+    
+    // "rtype" const
+    // "ptype" const
+    // "ptype_detailed" func( rtype )
+    // "description" const str
+    // "verify_reduction" func( rtype )
+    // "verify_reference_extention" func( rtype )
+    // "safe_cast" 
+    // "iteration" -> true/false
+    // "reduction" -> true/false
+    // "reference_extention" -> true/false
+    // "check_compatibility" 
+    
+    // "base_type"
+    // "const_value"
+    
+    // LOC_REF file line col line col <NODE>
+    
+    names_root=(,).
+    lookup_root=(,).
+
+    __global_meta_runtime = (,). 
+    __eval_tree_type_info = (,). 
+    __eval_tree_info = (,). 
+
+    module internal { 
+        set_eval_tree_type_info = fn (id, type) { 
+            __eval_tree_type_info id -> type. 
+        }
+
+        pass_info = fn (id, val) { 
+            __eval_tree_info id -> val. 
+        }
+
+        get_info = fn (id) = (__eval_tree_info id). 
+
+        print_deep = fn (val) { 
+            if _typeof val != "IMMUTABLE_DICTIONARY" { 
+                _print val. 
+            } else {  
+                counter = 0. 
+                _print "(". 
+                sc val -- (elem->value) {
+                    if counter > 0 { 
+                        _print ",". 
+                    }
+                    counter->counter + 1.
+                    print_deep elem "->" value. 
+                }
+                if counter == 0 { 
+                    _print ",". 
+                }
+
+                _print ")". 
+            }
+
+            RETURN print_deep. 
+        }
+
+        de_const = fn (t) { 
+            if t "base_type_of_const" { 
+                RETURN t "base_type_of_const". 
+            } else { 
+                RETURN t. 
+            }
+        }
+    }
+
+    module forwards {
+        module conversions {
+            safe_cast = NIL.   
+        }
+
+        disjunction = NIL. 
+        conjunction = NIL. 
+    }
+    
+    module domain {
+        any         = 0.
+        nil         = 1.
+        true        = 2.
+        false       = 3. 
+        primitives  = 4.
+        integer     = 5.
+        string      = 6.
+        code        = 7.
+        dictionary  = 8.
+        int_seq     = 9.
+        packet      = 10.
+        saferef     = 11.
+        binary      = 12. 
+        crypto      = 13.
+        time        = 14. 
+        hash_code   = 15.
+        utf8        = 16. 
+
+        name = (
+            any -> "any",
+            nil -> "nil",
+            true -> "true",
+            primitives -> "primitives",
+            integer -> "integer",
+            string -> "string",
+            code -> "code",
+            dictionary -> "dictionary",
+            int_seq -> "int_seq",
+            packet -> "packet",
+            saferef -> "saferef", 
+            binary -> "binary",
+            crypto -> "crypto",
+            time -> "time",
+            hash_code -> "hash_code",
+            utf8 -> "utf8"
+            
+        ).
+        
+        
+        domain_conversions_tmp = (
+            _str nil -> "NIL", 
+            _str true -> "TRUE", 
+            _str integer -> "INTEGER", 
+            _str string -> "STRING",
+            _str int_seq -> "INTEGER_SEQUENCE", 
+            _str saferef -> "SAFEREF",
+            _str packet -> "PACKET", 
+            _str binary -> "BINARY",
+            _str crypto -> "CRYPTO_ELEMENT",
+            _str time -> "TIME",
+            _str hash_code -> "HASH_CODE",
+            _str utf8 -> "UTF8"
+        ). 
+
+        __global_meta_runtime "domain_conversions" -> domain_conversions_tmp. 
+    }
+
+    module test_mode {
+        on = NIL.
+        err = NIL.  
+        set_test_mode = fn (_) { on -> TRUE. }
+        clear_error = fn (_) { err -> NIL. }
+    }
+
+    hidden {
+        error_state = NIL. 
+    }
+
+    error_state_reset = fn (_) { error_state->NIL. }
+    error_state_finalize = fn (_) {
+        if( error_state != NIL ) {
+            _e_print "Evaluation aborted due to meta-stage error\n".
+            RETURN NIL. 
+        } else {
+            RETURN TRUE. 
+        }
+    }
+
+    signal_error = fn (message, err) {
+        if test_mode::on {
+            test_mode::err -> (err + ": " + message).
+            _print "TEST MODE: " test_mode::err "\n".
+        } else {
+            error_state->TRUE.
+            _e_print (err + ": " + message + "\n").
+        }
+    }
+
+    hidden {
+        any_type = (
+            "is_any_type" -> TRUE,
+            "describe" -> fn (_) = "any", 
+            "verify_reduction" -> fn (_) = [ any_type, NIL ], 
+            "reference_extention" -> fn (_) = any_type, 
+            "iteration" -> fn (_) = ("ptype"->any_type, "rtype"->any_type),
+            "check_compatibility" -> fn (_) = TRUE,
+            "safe_cast" -> fn (_type_from, _error) { 
+                RETURN fn (value) = value.  
+            }
+        ).
+    }
+
+    no_safe_cast = fn (description) {
+        RETURN fn (_type_from, err) { 
+                    signal_error ( "Type " + description + ") not support SAFE cast") err. 
+                }. 
+    }
+    
+    mutation_forbidden = fn (description) {
+        RETURN fn (err, reducer, product) {
+            err_msg = "Invalid mutation for " + description +
+                    " (Observed reducer as " + (reducer "describe" NIL) +
+                    ", product as " + (product "describe" NIL) + ")".
+
+            ::meta::signal_error err_msg err.
+            RETURN any_type.
+        }
+    } 
+    
+    iteration_forbidden = fn (description) {
+        RETURN fn (err) {
+            err_msg = "Invalid iteration for " + description.
+            ::meta::signal_error err_msg err.
+            RETURN ("ptype"->any_type, "rtype"->any_type).
+        }
+    } 
+    
+    reduction_forbidden = fn (description) {
+        RETURN fn (reducer) {
+            err = "Invalid reduction for " + description +
+                    " (Observed reducer as " + (reducer "describe" NIL) + ")".
+
+            RETURN [ any_type, err ].
+        }
+    }
+
+    reference_extention_forbidden = fn (description) {
+        RETURN fn (_reducer) {
+            err = "Invalid reference extention for " + description.
+
+            RETURN [ any_type, err ].
+        }
+    }
+    
+    module basics {
+
+        nothing = fn (description)
+        {
+            ret = (
+                "describe" -> fn (_) = description,
+                "check_compatibility" -> fn (_actual) = NIL, 
+                "verify_reduction" -> reduction_forbidden description,
+                "iteration" -> iteration_forbidden description,
+                "safe_cast" -> no_safe_cast description,
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+            
+            RETURN ret.
+        }
+
+        none = nothing "meta::basics::none". 
+
+        nil = (
+            "is_domain" -> TRUE,
+            "is_const" -> TRUE,
+            "const_value" -> NIL,
+            "describe" -> fn (_) = $nil,
+            "domain" -> domain::nil,
+            "verify_reduction" -> reduction_forbidden $nil,
+            "iteration" -> iteration_forbidden $nil,
+            "check_compatibility" -> fn (actual) = (actual "domain" == domain::nil),
+            "reference_extention" -> reference_extention_forbidden $nil,
+        ).
+
+        true = ( 
+            "is_domain" -> TRUE,
+            "is_const" -> TRUE,
+            "const_value" -> TRUE,
+            "describe" -> fn (_) = $true,
+            "domain" -> domain::true,
+            "verify_reduction" -> reduction_forbidden $true,
+            "iteration" -> iteration_forbidden $true,
+            "check_compatibility" -> fn (actual) = (actual "domain" == domain::true),
+            "reference_extention" -> reference_extention_forbidden $true,
+        ).
+
+        false = ( 
+            "is_domain" -> TRUE,
+            "is_const" -> TRUE,
+            "const_value" -> FALSE,
+            "describe" -> fn (_) = $false,
+            "domain" -> domain::false,
+            "verify_reduction" -> reduction_forbidden $false,
+            "iteration" -> iteration_forbidden $false,
+            "check_compatibility" -> fn (actual) = (actual "domain" == domain::false),
+            "reference_extention" -> reference_extention_forbidden $false,
+        ).
+
+        packet = ( 
+            "is_domain" -> TRUE,
+            "domain" -> domain::packet,
+            "describe" -> fn (_) = $db,
+            "verify_reduction" -> reduction_forbidden $db,
+            "iteration" -> iteration_forbidden $db,
+            "check_compatibility" -> fn (actual) = (actual "domain" == domain::packet),
+            "reference_extention" -> reference_extention_forbidden $db,
+        ).
+
+        saferef = ( 
+            "is_domain" -> TRUE,
+            "domain" -> domain::saferef,
+            "describe" -> fn (_) = $sr,
+            "verify_reduction" -> reduction_forbidden $sr, 
+            "iteration" -> iteration_forbidden $sr, 
+            "check_compatibility" -> fn (actual) = (actual "domain" == domain::saferef), 
+            "reference_extention" -> reference_extention_forbidden $sr,
+        ).
+
+
+        integer = (
+            "is_domain" -> TRUE, 
+            "domain" -> domain::integer, 
+            "describe" -> fn (_) = $int,
+            "verify_reduction" -> reduction_forbidden $int,
+            "iteration" -> iteration_forbidden $int, 
+            "check_compatibility" -> fn (actual) { return domain::integer == actual "domain". },
+            "reference_extention" -> reference_extention_forbidden $int,
+        ). 
+        
+        string = (
+            "is_domain"->TRUE, 
+            "is_iterable" -> TRUE,
+            "domain"->domain::string, 
+            "describe" -> fn (_) = $str,
+            "rtype" -> basics::integer, 
+            "verify_reduction" -> fn (arg) {
+                if arg "domain" != domain::integer {
+                    RETURN [ any_type, "String reduction requires integer argument " ]. 
+                } else { 
+                    RETURN [ string, NIL ]. 
+                }
+            },
+            "iteration" -> fn (_err) = ("rtype"->basics::integer, "ptype"->basics::string),
+            "check_compatibility" -> fn (actual) {
+                RETURN domain::string == actual "domain".  
+            }, 
+            "reference_extention" -> reference_extention_forbidden $str,
+        ).
+
+        binary = (
+            "is_domain"->TRUE, 
+            "is_iterable" -> TRUE,
+            "domain"->domain::binary, 
+            "describe" -> fn (_) = $bin,
+            "rtype" -> basics::integer, 
+            "ptype" -> basics::integer, 
+            "verify_reduction" -> fn (arg) {
+                if arg "domain" != domain::integer {
+                    RETURN [ any_type, "Binary reduction requires integer argument " ]. 
+                } else { 
+                    RETURN [ integer, NIL ]. 
+                }
+            },
+            "iteration" -> fn (_err) = ("rtype"->basics::integer, "ptype"->basics::integer),
+            "check_compatibility" -> fn (actual) {
+                RETURN domain::binary == actual "domain".
+            },
+            "reference_extention" -> reference_extention_forbidden $bin,
+        ).
+
+        utf8 = (
+            "is_domain"->TRUE,
+            "is_iterable"->TRUE,
+            "domain"->domain::utf8,
+            "describe" -> fn (_) = $utf8,
+            "rtype" -> basics::integer,
+            "ptype" -> basics::utf8,
+            "verify_reduction" -> fn (arg) {
+                if arg "domain" != domain::integer {
+                    RETURN [ any_type, "UTF-8 reduction requires integer argument " ].
+                } else {
+                    RETURN [ integer, NIL ].
+                }
+            },
+            "iteration" -> fn (_err) = ("rtype"->basics::integer, "ptype" -> basics::utf8),
+            "check_compatibility" -> fn (actual) {
+                RETURN domain::utf8 == actual "domain".
+            },
+            "reference_extention" -> reference_extention_forbidden $utf8
+        ).
+
+        boolean = (
+            "describe" -> fn (_) = $bool,
+            "verify_reduction" -> reduction_forbidden $bool,
+            "iteration" -> iteration_forbidden $bool,
+            "check_compatibility" -> fn (_actual) { return TRUE. },
+            "safe_cast" -> fn (_type_from, _err) {
+                RETURN fn (value) {
+                    abort provisional "Value not boolean" WHEN value != TRUE && value != FALSE. 
+                    RETURN value.   
+                } 
+            }, 
+            "reference_extention" -> reference_extention_forbidden $bool,
+        ).
+
+        time = (
+            "is_domain" -> TRUE, 
+            "domain" -> domain::time, 
+            "describe" -> fn (_) = $time,
+            "verify_reduction" -> reduction_forbidden $time, 
+            "iteration" -> iteration_forbidden $time, 
+            "check_compatibility" -> fn (actual) {
+                RETURN domain::time == actual "domain".
+            }, 
+            "reference_extention" -> reference_extention_forbidden $time
+        ).
+
+        hash_code = (
+            "is_domain" -> TRUE,
+            "domain" -> domain::hash_code,
+            "describe" -> fn (_) = $hash_code,
+            "verify_reduction" -> reduction_forbidden $hash_code, 
+            "iteration" -> iteration_forbidden $hash_code,
+            "check_compatibility" -> fn (actual) {
+                RETURN domain::hash_code == actual $domain.
+            },
+            "reference_extention" -> reference_extention_forbidden $hash_code
+        ).
+
+        any = any_type. 
+
+        constant = fn (type, value) {
+                RETURN type'($is_const->TRUE, $const_value->value, $base_type_of_const->type). 
+        }
+    }
+
+
+    module compatibility {
+        check = fn (needed, actual) {
+            if actual == basics::none { 
+                RETURN TRUE. 
+            } 
+
+            if actual $is_opaque && check needed (actual $base_type) { 
+                RETURN TRUE. 
+            } elif actual $is_conjunction { 
+                sc actual $types -- (t->) { 
+                    if check needed t { 
+                        RETURN TRUE. 
+                    } 
+                } 
+                RETURN NIL.
+            } elif actual $is_disjunction { 
+                sc actual $types -- (t -> ) { 
+                    if !(check needed t) { 
+                        RETURN NIL. 
+                    }
+                } 
+                RETURN TRUE. 
+            } else { 
+                RETURN (needed "check_compatibility" actual).
+            }
+        }
+
+        check_or_error = fn (err, needed, actual) {
+            if !(check needed actual) {
+                message = "Incompatible type detected. Required " + (needed "describe" NIL) + ", but observing " + (actual "describe" NIL).
+                signal_error message err.
+            }
+        }
+
+        combine_types = fn (err, type_a, type_b) {
+            if check type_a type_b {
+                RETURN type_a.
+            } else {
+                if check type_b type_a {
+                    RETURN type_b.
+                } else {
+                    message = "Incompatible types in conditional expression, " + (type_a "describe" NIL) + " can not be combined with " + (type_b "describe" NIL).
+                    signal_error message err.
+                    RETURN basics::any.
+                }
+            }
+        }
+    }
+
+    module opaque { 
+        type = fn (name, base_type, check_func) 
+        {
+            description = "(::meta::opaque::type \"" + name + "\" " + (base_type "describe" NIL) + ")". 
+            res = (
+                $is_opaque -> TRUE, 
+                $domain -> base_type $domain,
+                $name -> name, 
+                $base_type -> base_type, 
+                $describe -> fn (_) = description, 
+                $verify_reduction -> reduction_forbidden description, 
+                $iteration -> iteration_forbidden description, 
+                $check_compatibility -> fn (actual) {
+                    if !( actual $is_opaque) { 
+                        RETURN NIL. 
+                    } 
+
+                    RETURN actual $name == name && actual $base_type == base_type. 
+                }, 
+                $safe_cast -> fn (_type_from, _err) = check_func, 
+                $reference_extention -> reference_extention_forbidden description,                
+            ). 
+
+            RETURN res. 
+        }
+    }
+
+    module crypto_element { 
+        hidden {
+            crypto_scheme_sc = fn (x) {
+                if (x != 1) { 
+                    _abort_transaction ("Invalid schema id, allowed 1 but got " + (_str x)). 
+                    RETURN NIL. 
+                } else {
+                    RETURN x. 
+                }
+            }
+
+            encrypt__secretkey_check = fn (x) { 
+                if !(_crypto_element_validate x 1 $SECKEY_ENCRYPT) {
+                    _abort_transaction "Invalid encrypt-private key, verification failed". 
+                } else { 
+                    RETURN x. 
+                } 
+
+                RETURN NIL. 
+            }
+
+            sign__secretkey_check = fn (x) { 
+                if !(_crypto_element_validate x 1 $SECKEY_SIGN) {
+                    _abort_transaction "Invalid sign-private key, verification failed". 
+                } else { 
+                    RETURN x. 
+                } 
+
+                RETURN NIL. 
+            }
+
+            encrypt__publickey_check = fn (x) { 
+                if !(_crypto_element_validate x 1 $PUBKEY_ENCRYPT) {
+                    _abort_transaction "Invalid encrypt-public key, verification failed". 
+                } else { 
+                    RETURN x. 
+                } 
+
+                RETURN NIL. 
+            }
+
+
+            sign__publickey_check = fn (x) { 
+                if !(_crypto_element_validate x 1 $PUBKEY_SIGN) {
+                    _abort_transaction "Invalid sign-public key, verification failed". 
+                } else { 
+                    RETURN x. 
+                } 
+
+                RETURN NIL. 
+            }
+
+            signature_check = fn (x) { 
+                if !(_crypto_element_validate x 1 $SIGNATURE) { 
+                    _abort_transaction "Invalid signature, verification failed". 
+                } else {
+                    RETURN x. 
+                }
+
+                RETURN NIL. 
+            }
+
+            encrypted_data_check = fn (x) { 
+                if !(_crypto_element_validate x 1 $ENCRYPTED_DATA) { 
+                    _abort_transaction "Invalid encrypted message, verification failed". 
+                } else {
+                    RETURN x. 
+                } 
+
+                RETURN NIL. 
+            }
+        }
+
+        type = fn (kind) { 
+            if( kind != $ANY && !(_crypto_validate_kind kind) ) { 
+                signal_error ("Invalid crypto element kind "+kind) "". 
+            }
+
+            validator = fn (id, kind, value)
+            {
+                if _typeof value != "CRYPTO_ELEMENT" { 
+                    _abort_transaction_provisional ("Invalid value for crypto element: required CRYPTO_ELEMENT domain but found " + (_typeof value)). 
+                } 
+
+                if kind == $ANY { 
+                    kind->_crypto_get_element_kind value. 
+                }
+
+                if !(_crypto_element_validate value id kind) { 
+                    _abort_transaction_provisional ("Invalid crypto element -- validation failed for kind " + kind + " id " + (_str id)). 
+                }
+
+                RETURN value. 
+            }
+
+            RETURN (
+                        "is_domain"->TRUE, 
+                        "domain"->domain::crypto, 
+                        "kind"->kind,
+                        "describe" -> fn (_) = ("(crypto " + kind + ")"),
+                        "verify_reduction" -> reduction_forbidden $crypto,
+                        "check_compatibility" -> fn (actual) {
+                            if domain::crypto != actual "domain" { 
+                                RETURN NIL. 
+                            }
+
+                            if kind == "ANY" { 
+                                RETURN TRUE. 
+                            } else { 
+                                RETURN kind == actual "kind". 
+                            }
+                        }, 
+                        "safe_cast" -> fn (_type_from, _err) {
+                            RETURN validator 0 kind. 
+                        }, 
+                        "reference_extention" -> reference_extention_forbidden $crypto,
+                    ).
+        }
+
+        global_id_check = fn (x) {
+            if _typeof x != "STRING" { 
+                _abort_transaction_provisional "Global id check failed". 
+            }
+            _validate_global_id_string x.
+            RETURN x.
+        }
+    }
+
+    module nullable {
+        allows_null_values = fn (t)
+        {
+            RETURN ( t "domain" == domain::nil ) || ( t "is_nullable" ) || ( t "is_any_type" ).
+        }
+
+        type = fn (t) 
+        {
+            if allows_null_values t { 
+                RETURN t. 
+            }
+            
+            description = (t "describe" NIL) + "+". 
+            res = (
+                "is_nullable" -> TRUE, 
+                "non_null_type" -> t, 
+                "describe" -> fn (_)
+                    {
+                        RETURN description.  
+                    },
+                "verify_reduction" -> fn (arg) = (t "verify_reduction" arg), 
+                "iteration" -> iteration_forbidden description, 
+                "check_compatibility" -> fn (actual) {
+                    if actual "is_domain" && actual "domain" == domain::nil { 
+                        RETURN TRUE. 
+                    } elif actual "is_nullable" { 
+                        RETURN t "check_compatibility" (actual "non_null_type").
+                    } else {
+                        RETURN t "check_compatibility" actual. 
+                    }.  
+                }, 
+                "safe_cast" -> fn (type_from, err) {
+                    base_type_cast = forwards::conversions::safe_cast type_from t err. 
+                    RETURN fn (value) 
+                    {
+                        if value == NIL { RETURN NIL. } else { RETURN base_type_cast value. }
+                    }
+                }, 
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+            
+            RETURN res. 
+        }
+                
+        get_product_type_no_err = fn (f) 
+        {
+            if f "is_function" { 
+                RETURN f "ptype". 
+            } elif f "iterable" || f "is_immutable" {
+                RETURN f "ptype". 
+            } elif f "is_record" || f "is_tuple" { 
+                RETURN basics::any. // TODO
+            } elif f "is_any_type" { 
+                RETURN basics::any.
+            } elif f "is_conjunction" || f "is_disjunction" { 
+                RETURN f "product". 
+            } else {
+                RETURN basics::none. 
+            }        
+        }
+        
+        is_product_nullable_by_id = fn (id)
+        {
+            type_definition = __eval_tree_type_info id. 
+            if type_definition $is_tuple || type_definition $is_record { 
+                RETURN TRUE. 
+            }
+
+            product_type = get_product_type_no_err type_definition. 
+            if product_type $is_immutable || product_type $is_tuple || product_type $is_record { 
+                RETURN TRUE. 
+            } else { 
+                RETURN allows_null_values product_type. 
+            }
+        }
+
+        remove = fn (t)
+        {
+            if t $is_nullable {
+                RETURN t $non_null_type.
+            } else { 
+                RETURN t. 
+            }
+        }
+        
+        remove_maybe = fn (t, def) 
+        {
+            if allows_null_values def { 
+                RETURN t. 
+            }
+            
+            RETURN remove t. 
+        }
+    }
+    
+    module conversions {
+        safe_cast = fn (type_from, type_to, err) 
+        {
+            if type_to "safe_cast" != NIL { 
+                RETURN type_to "safe_cast" type_from err.
+            } elif type_to "is_domain" { 
+                dom = type_to "domain". 
+                required_domain = domain::name dom.
+                RETURN fn (value) 
+                {
+                    abort provisional err + ": Runtime mismatch for SAFE cast: Invalid value domain. Required: " + required_domain + " but observing " + (_typeof value) 
+                        WHEN _typeof value != __global_meta_runtime "domain_conversions" (_str dom).
+                        
+                    RETURN value.
+                }
+            } else {
+                signal_error ("Safe cast not available for type " + (type_to "describe" NIL)) err. 
+            }
+        }
+        
+        forwards::conversions::safe_cast -> safe_cast. 
+        
+        present_cast = fn (type_from, err)
+        {
+            if !(nullable::allows_null_values type_from) { 
+                RETURN fn (value) = value. 
+            } else {
+                RETURN fn (value) {
+                    abort provisional err + ": Runtime mismatch for PRESENT cast: value is NIL" WHEN value == NIL.  
+                    RETURN value. 
+                }
+            }
+        }
+    }
+    
+    module iterable {
+        type = fn (rtype, ptype) 
+        {
+            description = "(" + (rtype "describe" NIL) + "*>" + (ptype "describe" NIL) + ")". 
+            
+            RETURN (
+                "is_iterable" -> TRUE,
+                "describe" -> fn (_) = description,
+                "rtype" -> rtype,
+                "ptype" -> ptype,
+                "check_compatibility" -> fn (actual) {
+                     RETURN
+                     (
+                        (actual "is_iterable") &&
+                        (rtype "check_compatibility" (actual "rtype")) &&
+                        (ptype "check_compatibility" (actual "ptype"))
+                     ).
+                },
+                "iteration" -> fn (_err) = ("rtype"->rtype, "ptype"->ptype),
+                "verify_reduction" -> reduction_forbidden description,
+                "reference_extention" -> reference_extention_forbidden description,
+           ).
+        }
+
+        integer_sequence = type basics::integer basics::integer.
+    }
+
+   
+    module enumerated_sets { 
+        sets_by_hash = (,). 
+        
+        type = fn (base_type, value_list) {
+            if base_type != basics::string && base_type != basics::integer {
+                signal_error ("Base type must be vanilla integer or string but found " + (base_type "describe" NIL)) "". 
+                RETURN basics::string.  
+            } 
+            
+            sc value_list -- (value -> ) {
+                if (base_type == basics::string && _typeof value != "STRING" ) || 
+                   (base_type == basics::integer && _typeof value != "INTEGER" ) 
+                { 
+                    signal_error "invalid value list element, not compatible with base type" "". 
+                    RETURN basics::any.
+                }  
+            } 
+
+            type_hash = _value_id value_list abort "Unable to generate value hash" WHEN IS NIL. 
+            __global_meta_runtime type_hash -> value_list. 
+            
+            type = sets_by_hash type_hash. 
+            if type != NIL { RETURN type. }
+            
+            SafeCast = fn (_type_from, _err) 
+            {
+                RETURN fn (value) 
+                {
+                    if _typeof value != "STRING" { 
+                        _abort_transaction_provisional "Value) not match this value set: it is not a string". 
+                    } elif __global_meta_runtime type_hash value { 
+                        RETURN value. 
+                    } else {
+                        _abort_transaction_provisional ("String value \"" + value + "\" does not match this value set").   
+                    } 
+                }
+            }
+            
+            Describe = fn (_)
+            {
+                Ret = (,).
+                Ret() -> "<".
+                sc value_list -- (value -> ) {
+                    if base_type == basics::string { 
+                        Ret() -> Ret() + (_code_str value).
+                    } else {
+                        Ret() -> Ret() + (_str value). 
+                    }
+
+                    Ret() -> Ret() + ",".
+                }
+                Ret() -> Ret() + ">".
+                RETURN Ret().
+            }
+
+            description = Describe(). 
+            
+            CheckCompatibility = fn (actual) {
+                
+                if actual "is_const" && value_list (actual "const_value") { 
+                    RETURN TRUE. 
+                } elif actual "is_enumerated_set" {
+                    if actual "type_hash" == type_hash {
+                        RETURN TRUE. 
+                    }
+                    
+                    if actual "base_type" != base_type {
+                        RETURN NIL. 
+                    }
+                    sc actual "value_list" -- (v -> ) { 
+                        if !(value_list v) {
+                            RETURN NIL.                             
+                        }
+                    }
+                    
+                    RETURN TRUE.
+                } else {
+                    RETURN NIL. 
+                }
+            }
+
+            ret = (
+                "is_enumerated_set" -> TRUE,
+                "base_type" -> base_type,
+                "value_list" -> value_list,
+                "type_hash" -> type_hash, 
+                "describe" -> fn (_) = description,
+                "check_compatibility" -> CheckCompatibility,
+                "iteration" -> iteration_forbidden description,
+                "verify_reduction" -> reduction_forbidden description,
+                "safe_cast" -> SafeCast,
+                "reference_extention" -> reference_extention_forbidden description,
+           ).
+
+           sets_by_hash type_hash -> ret. 
+           RETURN ret.
+        }
+    }
+    
+    
+    module combinations { 
+        Conjunction_SafeCast_ex = fn (type_from, err, index, array_of_types, description) {
+            check_cur = conversions::safe_cast basics::any (array_of_types index) err.
+            if index < (_count array_of_types) - 1 {
+                check_tail = Conjunction_SafeCast_ex type_from err (index+1) array_of_types description.
+                RETURN fn (value) {
+                    WHEN provisional abort e {
+                        ret = check_cur value.
+                        ret -> check_tail value.
+                        RETURN ret.
+                    } 
+                    abort provisional "Safe cast for conjunction" + description + " failed: " + e WHEN e != NIL.
+                }
+
+            } else {
+                RETURN fn (value) = (check_cur value).
+            }
+        }
+        conjunction = fn (set_of_types) 
+        {
+            type_set_description = "(". 
+            allows_null_values = TRUE. 
+            non_null_type_set = (,). 
+            product_type_set = (,). 
+            has_types = NIL. 
+
+            sc set_of_types -- (elem -> ) { 
+                if elem $is_conjunction { 
+                    set_of_types->set_of_types'(elem->delete). 
+                    set_of_types->set_of_types'(elem $types). 
+                } 
+            } 
+
+            sc set_of_types -- (elem -> ) { 
+                set_of_types->set_of_types'(elem->delete, internal::de_const elem).
+            } 
+
+            first IS true+ = TRUE. 
+            sc set_of_types -- (elem -> ) { 
+                if elem == any_type { 
+                    continue. 
+                }
+
+                if elem == basics::none { 
+                    RETURN basics::none.
+                } 
+
+                has_types -> TRUE. 
+                if nullable::allows_null_values elem { 
+                    non_null_type_set (nullable::remove elem) -> TRUE. 
+                } else { 
+                    non_null_type_set elem -> TRUE. 
+                    allows_null_values -> NIL. 
+                }
+
+                product_type_set -> product_type_set'(nullable::get_product_type_no_err elem,). 
+                if first { 
+                    type_set_description -> "(" + ( elem "describe" NIL ). 
+                    first->NIL. 
+                } else {
+                    type_set_description -> type_set_description + " && " + ( elem "describe" NIL ). 
+                }
+            } 
+
+            if !has_types { 
+                RETURN basics::any. 
+            } 
+
+            if (_count set_of_types) == 1 { 
+                sc set_of_types -- (ret -> ) { 
+                    RETURN ret. 
+                }
+            }
+
+            type_set_description -> type_set_description + ")". 
+
+            description = type_set_description.  
+
+            SafeCast = fn (type_from, err) {
+                array_of_types = [].
+                sc set_of_types -- (type -> ) {
+                    array_of_types (_count array_of_types) -> type.
+                }
+                RETURN Conjunction_SafeCast_ex type_from err 0 array_of_types description.
+            }
+
+            ret = (
+                "is_conjunction" -> TRUE, 
+                "is_nullable" -> allows_null_values, 
+                "non_null_type" -> (allows_null_values ?? conjunction non_null_type_set ; NIL ), 
+                "product" -> conjunction product_type_set,
+                "describe" -> fn (_) = description,
+                "types" -> set_of_types, 
+                "check_compatibility" -> fn (actual) {
+                    sc set_of_types -- (t -> ) { 
+                        if !(t "check_compatibility" actual) { 
+                            RETURN NIL. 
+                        }
+                    } 
+
+                    RETURN TRUE. 
+                },
+                "iteration" -> iteration_forbidden description,
+                "verify_reduction" -> fn (arg) { 
+                    result_type_set = (,). 
+                    message = "Invalid reduction for type " + description. 
+                    has_error = NIL. 
+                    sc set_of_types -- (t -> ) { 
+                        t "verify_reduction" arg => [result_type, result_error]. 
+                        if result_error {
+                            message -> message + "\n\t Invalid reduction for type " + (t "describe" NIL) + ": " + result_error. 
+                            has_error -> TRUE. 
+                        } 
+                        
+                        result_type_set-> result_type_set'(result_type,). 
+                    }
+
+                    RETURN [ conjunction result_type_set, (has_error ?? message ; NIL) ]. 
+                },
+                "safe_cast" -> SafeCast,
+                "reference_extention" -> reference_extention_forbidden description
+            ). 
+
+            RETURN ret. 
+        }
+
+        conjunction_pair = fn (left, right) 
+        {
+            set = (,). 
+            if left "is_conjunction" { 
+                set -> left "types". 
+            } else { 
+                set -> (left,). 
+            }
+
+            if right "is_conjunction" { 
+                set -> set'(right "types"). 
+            } else { 
+                set -> set'(right,). 
+            } 
+
+            RETURN conjunction set. 
+        }
+
+        forwards::conjunction->conjunction. 
+
+        CheckCompatibility_ex = fn (set_of_types, actual) {
+                                if actual $is_disjunction { 
+                                    sc actual $types -- (one_possible_type -> ) { 
+                                        if !(CheckCompatibility_ex set_of_types one_possible_type) { 
+                                            RETURN NIL. 
+                                        }
+                                    }
+                                    RETURN TRUE. 
+                                } 
+                                sc set_of_types -- (t -> ) { 
+                                    if (t "check_compatibility" actual) { 
+                                        RETURN TRUE. 
+                                    }
+                                } 
+
+                                RETURN NIL. 
+                        }
+
+        Disjunction_SafeCast_ex = fn (_type_from, err, index, array_of_types, type_dsc) {
+            check_cur = conversions::safe_cast basics::any (array_of_types index) err.
+            if index < (_count array_of_types) - 1 {
+                check_tail = combinations::Disjunction_SafeCast_ex _type_from err (index+1) array_of_types type_dsc.
+                RETURN fn (value) {
+                    WHEN provisional abort _e {
+                        RETURN (check_cur value).                            
+                    }
+                    // current type is invalid, check remaining types
+                    WHEN provisional abort e {
+                        RETURN (check_tail value).
+                    }
+                    abort provisional "Runtime mismatch for disjunction SAFE cast: Expected " + type_dsc WHEN e != NIL.
+                }
+            } else {
+                RETURN fn (value) = (check_cur value).
+            }
+        }
+        disjunction = fn (set_of_types)
+        {
+            type_set_description = "(". 
+            allows_null_values = NIL. 
+            non_null_type_set = (,). 
+            product_type_set = (,). 
+            has_types = NIL. 
+
+            sc set_of_types -- (elem -> ) { 
+                if elem $is_disjunction { 
+                    set_of_types->set_of_types'(elem->delete). 
+                    set_of_types->set_of_types'(elem $types). 
+                } 
+            } 
+
+            // strings and string-enumerated types get all folded into one. 
+            string_consumer = enumerated_sets::type basics::string (,). 
+            sc set_of_types -- (elem -> ) { 
+                if elem == basics::string { 
+                    string_consumer -> basics::string. 
+                    set_of_types->set_of_types'(elem->delete).
+                } elif elem "is_const" && elem "base_type_of_const" == basics::string { 
+                    set_of_types->set_of_types'(elem->delete).
+                    if string_consumer != basics::string { 
+                        string_consumer -> enumerated_sets::type basics::string (string_consumer "value_list")'(elem "const_value",). 
+                    } 
+                } elif elem "is_enumerated_set" && elem "base_type" == basics::string { 
+                    set_of_types->set_of_types'(elem->delete). 
+                    if string_consumer != basics::string { 
+                        string_consumer -> enumerated_sets::type basics::string (string_consumer "value_list")'(elem "value_list"). 
+                    } 
+                } else {
+                    set_of_types->set_of_types'(elem->delete, internal::de_const elem).
+                }
+            } 
+
+            if string_consumer == basics::string || string_consumer "value_list" != (,) { 
+                set_of_types->set_of_types'(string_consumer,). 
+            }
+
+            // TODO: outer scope protect feature for IFs and SCANs
+            // ensuring it's not possible to create a new name that shadows 
+            // an outer name in this context. 
+            descriptions = (,). 
+            sc set_of_types -- (elem -> ) { 
+                if elem == any_type { 
+                    RETURN any_type.  
+                }
+
+                if elem == basics::none { 
+                    continue. 
+                }
+
+                has_types -> TRUE. 
+                if nullable::allows_null_values elem { 
+                    allows_null_values -> TRUE. 
+                    if elem != basics::nil { 
+                        non_null_type_set (nullable::remove elem) -> TRUE. 
+                    } 
+                } else {
+                    non_null_type_set elem -> TRUE. 
+                }
+
+                this_product = nullable::get_product_type_no_err elem. 
+
+                product_type_set -> product_type_set'(this_product,). 
+                descriptions (elem "describe" NIL) -> TRUE. 
+            } 
+
+            first IS true+ = TRUE. 
+            sc descriptions -- (one_description -> ) { 
+                if first { 
+                    type_set_description -> "(" + one_description. 
+                    first->NIL. 
+                } else {
+                    type_set_description -> type_set_description + " || " + one_description. 
+                }
+            } 
+
+            if !has_types { 
+                RETURN basics::none. 
+            } 
+
+            if (_count set_of_types) == 1 { 
+                sc set_of_types -- (ret -> ) { 
+                    RETURN ret. 
+                }
+            }
+
+            type_set_description -> type_set_description + ")". 
+
+            description = type_set_description. 
+
+            SafeCast = fn (_type_from, _err) {
+                array_of_types IS any[] = [].
+                sc set_of_types -- (t -> ) { array_of_types (_count array_of_types) -> t. }
+                RETURN Disjunction_SafeCast_ex _type_from _err 0 array_of_types description.
+            }
+
+            ret = (
+                "is_disjunction" -> TRUE, 
+                "is_nullable" -> allows_null_values, 
+                "non_null_type" -> (allows_null_values ?? disjunction non_null_type_set ; NIL ), 
+                "describe" -> fn (_) = description,
+                "types" -> set_of_types, 
+                "check_compatibility" -> CheckCompatibility_ex set_of_types,
+                "product" -> disjunction product_type_set, 
+                "iteration" -> iteration_forbidden description,
+                "verify_reduction" -> fn (arg) { 
+                    result_type_set = (,). 
+                    message = "Invalid reduction for type " + description. 
+                    has_error = NIL. 
+                    sc set_of_types -- (t -> ) { 
+                        t "verify_reduction" arg => [result_type, result_error]. 
+                        if result_error {
+                            message -> message + "\n\t Invalid reduction for type " + (t "describe" NIL) + ": " + result_error. 
+                            has_error -> TRUE. 
+                        } 
+                        
+                        result_type_set-> result_type_set'(result_type,). 
+                    } 
+
+                    RETURN [ disjunction result_type_set, (has_error ?? message ; NIL) ]. 
+                },
+                "safe_cast" -> SafeCast,
+                "reference_extention" -> reference_extention_forbidden description
+            ). 
+
+            RETURN ret. 
+        }
+
+        forwards::disjunction->disjunction. 
+
+        disjunction_pair = fn (left, right) 
+        {
+            set = (,). 
+            if left "is_disjunction" { 
+                set -> left "types". 
+            } else { 
+                set -> (left,). 
+            }
+
+            if right "is_disjunction" { 
+                set -> set'(right "types"). 
+            } else { 
+                set -> set'(right,). 
+            } 
+
+            ret = disjunction set. 
+            RETURN ret. 
+        }
+    }
+
+    module immutable {
+        type = fn (rtype, ptype) {
+            description = "(" + (rtype "describe" NIL) + "->>" + (ptype "describe" NIL) + ")". 
+            
+            Combinator = fn (err, _this, type_r)
+            {
+                if type_r "is_immutable" { 
+                    RETURN immutable::type (forwards::disjunction (rtype, type_r $rtype)) (forwards::disjunction (ptype, type_r $ptype)). 
+                } elif type_r "is_tuple" { 
+                    RETURN immutable::type (forwards::disjunction (rtype, basics::integer)) (forwards::disjunction (type_r $type_set)'(ptype,)). 
+                } elif type_r "is_record" { 
+                    RETURN immutable::type (forwards::disjunction (rtype, basics::string)) (forwards::disjunction (type_r $type_set)'(ptype,)). 
+                } else {
+                    message = "Type " + (type_r "describe" NIL) + " can not be used on the right side of the combinator". 
+                    signal_error message err.
+                    RETURN basics::any. 
+                } 
+            }
+
+            RETURN (
+                "is_immutable" -> TRUE, 
+                "is_iterable" -> TRUE,
+                "describe" -> fn (_) = description,
+                "rtype" -> rtype,
+                "ptype" -> ptype,
+                "combinator" -> Combinator, 
+                "check_compatibility" -> fn (actual) {
+                    if actual "is_immutable" {
+                        RETURN (rtype "check_compatibility" (actual "rtype")) && 
+                               (ptype "check_compatibility" (actual "ptype")).
+                    } elif actual "is_record" { 
+                        if _count (actual $field_list) == 0 { 
+                            RETURN TRUE. 
+                        } elif !(rtype "check_compatibility" meta::basics::string) {
+                            RETURN NIL.  
+                        }
+                        
+                        sc actual "field_list" -- (_ -> tp) {
+                            if !(ptype "check_compatibility" tp) { 
+                                RETURN NIL. 
+                            } 
+                        }
+                        
+                        RETURN TRUE. 
+                    } elif actual "is_tuple" { 
+                        if _count (actual $type_list) == 0 { 
+                            RETURN TRUE. 
+                        } elif !(rtype "check_compatibility" basics::integer) { RETURN NIL. }
+
+                        sc actual $type_list -- (_ -> tp) {
+                            if !(ptype "check_compatibility" tp ) { 
+                                RETURN NIL. 
+                            }
+                        } 
+                        RETURN TRUE. 
+                    } else {
+                        RETURN NIL. 
+                    }
+                },
+                "iteration" -> fn (_err) = ("rtype"->rtype, "ptype"->ptype), 
+                "verify_reduction" -> fn (param) 
+                {
+                    if !(rtype "check_compatibility" param) {
+                        message = "In a reduction: invalid reducer type. Required " + (rtype "describe" NIL) + " but observing " + (param "describe" NIL).
+                        RETURN [any_type, message]. 
+                    } else {
+                        RETURN [(meta::nullable::type ptype), NIL].
+                    }
+                },
+                "safe_cast" -> fn (_type_from, err) 
+                {
+                    reducer_cast = conversions::safe_cast basics::any rtype err. 
+                    product_cast = conversions::safe_cast basics::any ptype err. 
+                    RETURN fn (value)
+                    {
+                        abort provisional "Safe cast failed, required dictionary value" WHEN _typeof value != "IMMUTABLE_DICTIONARY".
+                         
+                        sc value -- (i -> v) {
+                            reducer_cast i. 
+                            product_cast v. 
+                        }
+                        
+                        RETURN value. 
+                    }
+                }, 
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+        }
+        
+    
+        array = fn (result_type) = (type basics::integer result_type).
+        set = fn (elem_type) = (type elem_type (nullable::type basics::true)).
+    }
+
+
+    module tuple {
+        hidden { 
+            SafeCast_ex = fn (_type_from, err, index, rlist)  
+            {
+                check_at_index = conversions::safe_cast basics::any (rlist index) err.
+                if index < (_count rlist) - 1 { 
+                    check_tail = tuple::SafeCast_ex basics::any err (index + 1) rlist.   
+                    RETURN fn (value) 
+                    {
+                        ret = check_tail value.  
+                        ret index -> check_at_index (value index).
+                        RETURN ret.  
+                    }
+                } else {
+                    RETURN fn (value) 
+                    {
+                        if _typeof value != "DICTIONARY" && _typeof value != "IMMUTABLE_DICTIONARY" { 
+                            _abort_transaction_provisional "SAFE cast to tuple failed: value is not a dictionary". 
+                        } else {
+                            ret = (,).  
+                            ret index -> check_at_index (value index).
+                            RETURN ret.  
+                        } 
+                    }
+                }
+            }
+        }
+        
+        type = fn (tlist) {            
+            rlist = (,).
+            type_set = (,). 
+            valid_subscript_set = (,). 
+            sc tlist -- (index -> t) {
+                valid_subscript_set index->TRUE. 
+                rlist->rlist'(index -> internal::de_const t,). 
+                type_set->type_set'(internal::de_const t,). 
+            } 
+
+            Describe = fn (_)
+            {
+                Ret = "[".
+                counter = 0. 
+                sc rlist -- (index -> rtype) {
+                    if (counter > 0) {
+                        Ret -> Ret + ",".
+                    }
+                    counter -> counter + 1. 
+                    Ret -> Ret + (_str index) + "->" + (rtype "describe" NIL).
+                }
+                Ret -> Ret + "]".
+                RETURN Ret.
+            }
+            
+            description = Describe(). 
+            tuple_size = _count rlist. 
+            
+            CheckCompatibility = fn (actual) {
+                if !( actual "is_tuple" ) { RETURN NIL. }
+                sc rlist -- (index -> expected_rtype) {
+                    actual_type = actual $type_list index. 
+                    if actual_type == NIL { actual_type->basics::nil. }
+                    if !(expected_rtype "check_compatibility" actual_type) {
+                        RETURN NIL.
+                    }
+                }
+
+                RETURN TRUE.
+            }
+
+            Combinator = fn (err, this, type_r)
+            {
+                if _count tlist == 0 { 
+                    RETURN type_r. 
+                } elif type_r "is_immutable" { 
+                    RETURN immutable::type (forwards::disjunction (type_r $rtype, basics::integer)) (forwards::disjunction (type_r $ptype,)'type_set). 
+                } elif type_r "is_tuple" { 
+                    RETURN tuple::type rlist'(type_r $type_list). 
+                } elif type_r "is_record" { 
+                    if _count (type_r "field_list") == 0 { 
+                        RETURN this. 
+                    } else { 
+                        RETURN immutable::type (forwards::disjunction (basics::integer, basics::string)) (forwards::disjunction (type_r $type_set)'type_set). 
+                    }
+                } else {
+                    message = "Type " + (type_r "describe" NIL) + " can not be used on the right side of the combinator". 
+                    signal_error message err.
+                    RETURN basics::any. 
+                } 
+            }
+
+            VerifyReduction = fn (reducer)
+            {
+                message = NIL. 
+                if !(compatibility::check meta::basics::integer reducer) {
+                    message -> "In a reduction: invalid reducer type for tuple, integer required but observing " + (reducer "describe" NIL).
+                } elif !(reducer "is_const") {
+                    message -> "In a reduction: tuple subscript must be constant".
+                } elif !(valid_subscript_set (reducer "const_value")) || (reducer "const_value" < 0) {
+                    message -> "In a reduction: tuple subscript out of bounds".
+                }
+
+                if message { 
+                    RETURN [any_type, message]. 
+                } else {
+                    RETURN [rlist (reducer "const_value"), NIL]. 
+                }
+            }
+
+            SafeCast = fn (type_from, err)
+            {
+                RETURN tuple::SafeCast_ex type_from err 0 rlist. 
+            }
+            
+            DeleteElement = fn (err, index_type) {
+                if index_type "base_type_of_const" != basics::integer { 
+                    message = "Invalid deletion of a tuple element: index must be constant. To force this operation cast to an array."
+                    signal_error message err. 
+                } 
+
+                index = index_type "const_value". 
+                new_field_list = rlist'(index->delete). 
+                RETURN tuple::type new_field_list. 
+            }
+
+            ret_val = (
+                "is_tuple" -> TRUE,
+                "is_iterable" -> TRUE,
+                "rtype" -> basics::integer, 
+                "ptype" -> forwards::disjunction type_set, 
+                "type_list" -> rlist,
+                "type_set" -> type_set, 
+                "tuple_size" -> tuple_size, 
+                "describe"-> fn (_) = description, 
+                "check_compatibility" -> CheckCompatibility,
+                "combinator" -> Combinator,
+                "delete" -> DeleteElement, 
+                "iteration" -> fn (_err) = ( "rtype"->basics::integer, "ptype"->forwards::disjunction type_set ),
+                "verify_reduction" -> VerifyReduction,
+                "safe_cast" -> SafeCast,
+                "reference_extention" -> reference_extention_forbidden description,
+           ).
+
+           RETURN ret_val. 
+        }
+        
+        empty = type [].
+        member_type = fn (t, i, err) 
+        {  
+            if !(t "is_tuple") { 
+                signal_error "Type is not a tuple" err.
+                RETURN ::meta::basics::any.
+            } elif !(t "type_list" i) { 
+                signal_error << "Tuple) not have element " + (_str i) << err.
+                RETURN ::meta::basics::any.
+            } else {
+                RETURN t "type_list" i. 
+            }
+        }
+    }
+
+    module reference {
+        type = fn (base_type) {
+            Describe = fn (_)
+            {
+                RETURN "&" + (base_type "describe" NIL).
+            }
+
+            description = Describe(). 
+            
+            CheckCompatibility = fn (actual) {
+                if !(actual "is_reference" ) {
+                    RETURN NIL. 
+                } else { 
+                    RETURN compatibility::check base_type (actual "base_type").
+                } 
+            } 
+
+            ret = (
+                "is_reference" -> TRUE,
+                "base_type" -> base_type,
+                "describe" -> fn (_) = description,
+                "check_compatibility" -> CheckCompatibility,
+                "iteration" -> iteration_forbidden description,
+                "verify_reduction" -> reduction_forbidden description,
+                "safe_cast" -> no_safe_cast description,
+                "reference_extention" -> fn (reducer)
+                {
+                    BIND [result_type, result_error] TO base_type "verify_reduction" reducer.
+                    RETURN [ reference::type result_type, result_error ]. 
+                }, 
+           ).
+ 
+           RETURN ret.
+        } 
+        
+        dereference = fn (type, err) {
+            if !(type "is_reference") {
+                message = "Reference was expected but found " + (type "describe" NIL). 
+                signal_error message err. 
+                RETURN basics::any.  
+            } else {
+                RETURN type "base_type". 
+            }  
+        }
+
+        remove_null = fn (t) { 
+            if t $is_reference { 
+                RETURN reference::type (meta::nullable::remove (t $base_type)). 
+            } else {
+                RETURN meta::nullable::remove t. 
+            }
+        }
+    }
+ 
+    module record {
+        hidden { 
+            SafeCast_ex = fn (_type_from, err, index, fnames_array, flist) 
+            {
+                field_name = fnames_array index. 
+                count_fields = _count fnames_array.
+                field_type = flist field_name. 
+                field_count = _count fnames_array.
+                check_field = conversions::safe_cast basics::any field_type err.
+
+                if index < field_count - 1 { 
+                    check_tail = SafeCast_ex basics::any err (index + 1) fnames_array flist.   
+                    RETURN fn (value) 
+                    {
+                        ret = check_tail value.  
+                        ret field_name -> check_field (value field_name).
+                        RETURN ret.  
+                    }
+                } else {
+                    RETURN fn (value) 
+                    {
+                        // TODO: Find and eliminate "DICTIONARY"
+                        if _typeof value != "DICTIONARY" && _typeof value != "IMMUTABLE_DICTIONARY" { 
+                            _abort_transaction_provisional "SAFE cast to record failed: value is not a dictionary". 
+                        } else {
+                            ret = (,).  
+                            ret field_name -> check_field (value field_name).
+                            RETURN ret.  
+                        } 
+                    }
+                }
+            } 
+        }
+        
+        type = fn (flist) { // name->type             
+            // construct an enumerated set of field names
+            field_names = (,).
+            product_type_set = (,). 
+            index = 0. 
+            fnames_array = []. 
+            sc flist -- (name -> ptype) {
+                fnames_array index -> name. 
+                index -> index + 1. 
+                field_names name->TRUE. 
+                product_type_set->product_type_set'(ptype,). 
+                flist name->/*internal::de_const*/ ptype. 
+            } 
+            
+            subscript_type = enumerated_sets::type basics::string field_names. 
+                        
+            Describe = fn (_)
+            {
+                Ret = "(/*empty_record*/,".
+                is_not_first = NIL. 
+                sc flist -- (name -> rtype) {
+                    if is_not_first {
+                        Ret -> Ret + ",".
+                    } else {
+                        Ret->"(". 
+                        is_not_first->TRUE.
+                    }
+
+                    Ret -> Ret + "\"" + name + "\"->" + (rtype "describe" NIL).
+                }
+                Ret -> Ret + ")".
+                RETURN Ret.
+            }
+
+            description = Describe(). 
+            
+            CheckCompatibility = fn (actual) {
+                if !(actual "is_record") { RETURN NIL. }
+
+                sc flist -- (name -> rtype) { 
+                    actual_field = actual "field_list" name. 
+                    if( actual_field == NIL ) {
+                        actual_field->basics::nil. 
+                    }
+                    
+                    if actual "field_list" name == NIL && !(nullable::allows_null_values rtype) { 
+                        RETURN NIL. 
+                    } elif !(rtype "check_compatibility" actual_field) {
+                        RETURN NIL.
+                    }
+                } 
+                RETURN TRUE.
+            }
+
+            Combinator = fn (err, this, type_r)
+            {
+                if _count flist == 0 { 
+                    RETURN type_r. 
+                } elif type_r "is_immutable" { 
+                    RETURN immutable::type (forwards::disjunction (type_r $rtype, basics::string)) (forwards::disjunction (type_r $ptype,)'product_type_set). 
+                } elif type_r "is_tuple" { 
+                    if _count (type_r $type_list) == 0 { 
+                        RETURN this. 
+                    } else { 
+                        RETURN immutable::type (forwards::disjunction (basics::integer, basics::string)) (forwards::disjunction (type_r $type_set)'product_type_set). 
+                    }
+                } elif type_r "is_record" { 
+                    RETURN record::type flist'(type_r $field_list). 
+                } else {
+                    message = "Type " + (type_r "describe" NIL) + " can not be used on the right side of the combinator". 
+                    signal_error message err.
+                    RETURN basics::any. 
+                } 
+            }
+
+            VerifyReduction = fn (reducer)
+            {
+                if !(compatibility::check subscript_type reducer) {
+                    message = "In a reduction: invalid reducer type for record, field name required but observing " + (reducer "describe" NIL).
+                    RETURN [ basics::any, message ].
+                }
+
+                RETURN [flist (reducer "const_value"), NIL]. 
+            }
+
+            DeleteElement = fn (err, index_type) {
+                if index_type "base_type_of_const" != basics::string { 
+                    message = "Invalid deletion of a record element: index must be constant. To force this operation cast to a dictionary."
+                    signal_error message err. 
+                } 
+
+                index = index_type "const_value". 
+                new_field_list = flist'(index->delete). 
+                RETURN record::type new_field_list. 
+            }
+
+            SafeCast = fn (type_from, err)
+            {
+                RETURN SafeCast_ex type_from err 0 fnames_array flist. 
+            }
+            
+            res = (
+                "is_record" -> TRUE,
+                "is_iterable" -> TRUE,
+                "field_list" -> flist,
+                "rtype" -> subscript_type,
+                "ptype" -> basics::any, // forwards::disjunction product_type_set,
+                "type_set" -> product_type_set, 
+                "describe" -> fn (_) = description,
+                "check_compatibility" -> CheckCompatibility,
+                "combinator" -> Combinator,
+                "delete" -> DeleteElement,
+                "iteration" -> fn (_err) = ( "rtype"->basics::string, "ptype"->forwards::disjunction product_type_set ),
+                "verify_reduction" -> VerifyReduction,
+                "safe_cast" -> SafeCast,
+                "reference_extention" -> reference_extention_forbidden description,
+           ).
+           
+           RETURN res. 
+        }
+        
+        empty = type (,). 
+        field_type = fn (t, f, err) 
+        {  
+            if !(t "is_record") { 
+                signal_error "Type is not a record" err.
+                RETURN ::meta::basics::any.
+            } elif !(t "field_list" f) { 
+                signal_error << "Record) not have element " + f << err.
+                RETURN ::meta::basics::any.
+            } else {
+                RETURN t "field_list" f. 
+            }
+        }
+    }
+    
+    module ops
+    {
+        config_result = meta::nullable::type 
+        (record::type 
+            (
+                $imports->record::type (
+                    $libraries->immutable::type basics::string basics::string, 
+                    $applications->immutable::type basics::string basics::string
+                ),
+                $exports->record::type (
+                    $libraries->immutable::type basics::string basics::string, 
+                    $applications->immutable::type basics::string basics::string
+                ),
+            )
+        ).
+
+        implied_declared_type = fn (t) { 
+            if t == basics::true || t == basics::false { 
+                return basics::boolean. 
+            } else { 
+                return t. 
+            }
+        }
+
+        describe = fn (t) {
+            RETURN t "describe" NIL. 
+        }
+
+        arith = fn (err, op, type_l, type_r) {
+            if op != "+" {
+                if type_l "domain" != domain::integer || type_r "domain" != domain::integer {
+                    message = "Arithmetic operation '" + op + "' requires integer operands, but observing " +
+                            (type_l "describe" NIL) + " and " + (type_r "describe" NIL) + " instead.".
+
+                    meta::signal_error message err.
+                    RETURN basics::any.
+                }
+
+
+                if type_l "is_const" && type_r "is_const" {
+                    RETURN (basics::constant basics::integer ((type_l "const_value") + (type_r "const_value"))). // TODO: This is a bug
+                } else {
+                    RETURN basics::integer.
+                }
+            } elif type_l "domain" == type_r "domain" // op == "+"
+                   && ( type_l "domain" == domain::integer || type_l "domain" == domain::string || type_l "domain" == domain::binary || type_l "domain" == domain::utf8 )
+            {
+                if type_l "is_const" && type_r "is_const" {
+                    RETURN (basics::constant type_l ((type_l "const_value") + (type_r "const_value"))).
+                } elif( type_l "domain" == domain::integer ) {
+                    RETURN basics::integer.
+                } elif( type_l "domain" == domain::binary ) { 
+                    RETURN basics::binary. 
+                } elif( type_l "domain" == domain::utf8 ) {
+                    RETURN basics::utf8.
+                } else {
+                    RETURN basics::string.
+                }
+            } else {
+                message = "Plus requires arguments to either both be integer, string, binary or UTF-8, but observing " +
+                      (type_l "describe" NIL) + " and " + (type_r "describe" NIL) + " instead.".
+                signal_error message err.
+                RETURN basics::any.
+            }
+        }
+
+        eq = fn (_err, _type_l, _type_r) {
+             RETURN basics::boolean.
+        }
+
+        negate = fn (_err, _arg) {
+            RETURN basics::boolean.
+        }
+
+        unary_minus = fn (err, arg) {
+            if (arg "domain" != domain::integer ) {
+                signal_error ("Unary minus requires integer argument, got " + (arg "describe" NIL) + " instead") err.
+            }
+
+            RETURN basics::integer.
+        }
+
+        predicate = fn (_err, _op, _type_l, _type_r) {
+            RETURN basics::boolean.
+        }
+
+        comparison = fn (_err, _op, _type_l, _type_r) {
+            RETURN basics::boolean. // TODO
+        }
+        
+        combinator = fn (err, type_l, type_r) {
+            if !(type_l "combinator") { 
+                message = "Type) not support combinator: " + (type_r "describe" NIL). 
+                meta::signal_error message err. 
+                RETURN meta::basics::any. 
+            } 
+
+            RETURN type_l "combinator" err type_l type_r. 
+        }
+        
+        immutable_deletion = fn (producer, type_l, err) {
+            if producer "is_immutable" { 
+                BIND [ _, result_error ] TO producer "verify_reduction" type_l. 
+                if result_error { 
+                    signal_error result_error err. 
+                }
+                RETURN producer.  
+            } elif producer "is_record" || producer "is_tuple" {
+                RETURN producer "delete" err type_l. 
+            } else {
+                signal_error ("Unable to delete elements for type " + (producer "describe" NIL)) err.  
+                RETURN basics::any.
+            }
+        }
+        
+        verify_reduction = fn (ptype, rtype, err) 
+        {
+            BIND [result_type, result_error] TO ptype "verify_reduction" rtype. 
+            if result_error != NIL { 
+                signal_error result_error err. 
+            }
+
+            RETURN result_type. 
+        }
+        
+        // PTYPE DEFAULT(default) RTYPE
+        verify_reduction_with_default = fn (ptype, rtype, def, err)
+        {
+            BIND [result_type, result_error] TO ptype "verify_reduction" rtype. 
+            if result_error != NIL { 
+                signal_error result_error err. 
+            }
+
+            meta::compatibility::check_or_error err ptype def. 
+            RETURN result_type. 
+        }
+
+        verify_reference_extention = fn (ptype, rtype, err)
+        {
+            BIND [ result_type, result_error ] TO ptype "reference_extention" rtype. 
+            if result_error != NIL { 
+                signal_error result_error err. 
+            }
+
+            RETURN result_type. 
+        }
+
+        // PTYPE-ref DEFAULT(default) RTYPE
+        verify_reference_extention_with_default = fn (ptype, rtype, def, err) 
+        {
+            BIND [ result_type, result_error ] TO ptype "reference_extention" rtype. 
+            if result_error != NIL { 
+                signal_error result_error err. 
+            }
+
+            meta::compatibility::check_or_error err (meta::reference::dereference ptype err) def. 
+            RETURN result_type. 
+
+        }
+
+        retrieve_reducer_type = fn (f)
+        {
+            if f "iterable" || f "is_record" || f "is_tuple" || f "is_immutable" || f "is_function" {
+                RETURN f "rtype". 
+            } elif f "domain" == domain::string || f "domain" == domain::binary || f "domain" == domain::utf8 { 
+                RETURN f "rtype". 
+            } elif f "is_any_type" { 
+                RETURN meta::basics::any. 
+            } else {
+                RETURN NIL. 
+            }
+        }
+        
+        retrieve_product_type = fn (f)
+        {
+            if f "iterable" || f "is_immutable" || f "is_function" || f "is_record" || f "is_tuple" {
+                RETURN f "ptype".
+            } elif f "domain" == domain::binary { 
+                RETURN f "ptype".                 
+            } elif f "domain" == domain::string { 
+                RETURN basics::string. 
+            } elif f "domain" == domain::utf8 {
+                RETURN basics::utf8.
+            } elif f "is_any_type" { 
+                RETURN meta::basics::any. 
+            } else {
+                RETURN NIL. 
+            }  
+        }
+        
+        slice = fn (value_type, slice_type, _is_soft, err) 
+        {
+            BIND ( "rtype"->slice_type_reducer, "ptype"->slice_type_product ) TO slice_type "iteration" err. 
+
+            value_type_reducer = retrieve_reducer_type value_type. 
+            value_type_product = retrieve_product_type value_type. 
+
+            if value_type "is_record" { 
+                value_type_reducer->basics::string. 
+            } 
+
+            if value_type_reducer == NIL || value_type_product == NIL { 
+                message = "Value being sliced is not reduceable". 
+                signal_error message err. 
+                RETURN basics::any. 
+            } 
+            
+            if !( compatibility::check value_type_reducer slice_type_product ) {
+                message = "Slice parameter not compatible: has product type " + (slice_type_product "describe" NIL) + " but expecting " + (value_type_reducer "describe" NIL). 
+                signal_error message err. 
+                RETURN meta::basics::any. 
+            }
+
+            if value_type "domain" == domain::string { 
+                if !(compatibility::check basics::integer slice_type_reducer) { 
+                    message = "Slice parameter not compatible with string type: has reducer type " + (slice_type_reducer "describe" NIL ) + " but expecting integer".
+                    signal_error message err. 
+                    RETURN meta::basics::any. 
+                } 
+                RETURN basics::string. 
+            } elif value_type "domain" == domain::binary { 
+                if !(compatibility::check basics::integer slice_type_reducer) { 
+                    message = "Slice parameter not compatible with binary type: has reducer type " + (slice_type_reducer "describe" NIL ) + " but expecting integer". 
+                    signal_error message err. 
+                    RETURN meta::basics::any. 
+                } 
+
+                RETURN basics::binary. 
+            } elif value_type "is_tuple" || value_type "is_record" || value_type "is_immutable" || value_type "is_function" { 
+                RETURN immutable::type slice_type_reducer value_type_product. 
+            }
+        }
+    }
+
+    module database_checks {
+        // init_arg is intentionally unused here just to run metachecks for this argument
+        create_database = fn (err, arg, _init_arg) {
+            if (arg "domain" != domain::string) {
+                signal_error ("Create database requires string argument for seed, got " + (arg "describe" NIL) + " instead") err.
+            }
+
+            RETURN ::meta::basics::packet.
+        }
+
+        execute_transaction = fn (err, db, message, is_encrypted) {
+            if (db "domain" != domain::packet ) {
+                signal_error ("Execute transaction requires database, got " + (db "describe" NIL) + " instead") err.
+            }
+
+            if is_encrypted && (message "domain" != domain::binary) { 
+                signal_error ("Encrypted message passed to a transaction must be a binary object, but got " + (db "describe" NIL) + " instead" ) err. 
+            } 
+
+            RETURN tuple::type [nullable::type basics::packet, basics::any, basics::string]. 
+        }
+    }
+
+    module stack {
+        stack_collection = (,). 
+        init = fn (_) 
+        {
+            id = _new_id(). 
+            stack_collection id -> (($count->0)). 
+            RETURN &(stack_collection id).
+        }
+
+        push = fn (st, val) {
+            #st (#st "count") -> val.
+            #st "count" -> (#st "count") + 1.
+        }
+
+        pop = fn (st) {
+            if #st "count" == 0 {
+                RETURN NIL.
+            } else {
+                #st "count" -> (#st "count") - 1.
+                ret = #st (#st "count").
+                delete #st (#st "count").
+                RETURN ret.
+            }
+        }
+
+        peek = fn (st) = (#st ((#st "count") - 1)).
+    }
+    
+    
+    module ret {   
+        // return_statck tracks the return type      
+        return_stack = stack::init(). 
+        
+        push = fn (rt) 
+        {
+            stack::push return_stack rt.
+        }
+
+        pop = fn (_) { stack::pop return_stack. }
+        current = fn (_) = ( stack::peek return_stack ). 
+        
+        // return_state tracks whether the return statement is present or not. 
+        return_state = stack::init(). 
+        push_state = fn (state) 
+        {
+            stack::push return_state (TRUE->state). 
+        }
+        
+        pop_state = fn (_) 
+        {
+            state = stack::pop return_state TRUE.
+            RETURN state. 
+        }
+        
+        current_state = fn (_)
+        {
+            state_var = stack::peek return_state. 
+            if state_var { RETURN state_var TRUE. } else { RETURN NIL. } 
+        }
+        
+        set_state = fn (state)
+        {
+            state_var = stack::pop return_state.
+            if state_var { 
+                stack::push return_state (TRUE->state). 
+            }. 
+        }
+        
+        // this is used at the end of the 'else' clause of the 'if' statement
+        // it assumes that both 'then' and 'else' pushed their own state onto the state stack
+        merge_state = fn (_)
+        {
+            state1 = pop_state(). 
+            state2 = pop_state(). 
+            state = ( current_state() || (state1 && state2) ).
+            set_state state.
+        }
+        
+        check_and_pop_state = fn (err) 
+        {
+            return_type = current(). 
+            current_return_state = current_state().
+
+            null_allowed = nullable::allows_null_values return_type. 
+            if !null_allowed && !current_return_state {
+                signal_error "Function return does not allow NIL but there are some code paths that do not produce a valid return" err.  
+            }
+            pop_state().
+        }
+    }
+
+    module locals {
+        hidden {
+            current_scope = NIL.
+        }
+
+        push = fn (name) {
+            new_scope = (
+                "name" -> name,
+                "parent" -> current_scope,
+                "vars" -> (,)
+            ).
+            current_scope -> new_scope.
+        }
+
+        pop = fn (_) {
+            current_scope->current_scope "parent".
+        }
+
+        set = fn (nm, tp) {
+            current_scope "vars" nm -> tp.
+        }
+
+        get_current_scope = fn (_) {
+            RETURN current_scope.
+        }
+
+        set_current_scope = fn (s) {
+            current_scope->s.
+        }
+
+        hidden {
+            get_ex = fn (scope, layer, nm) {
+                if (layer > 0) {
+                    if (scope "parent") == NIL {
+                        RETURN NIL.
+                    }
+
+                    RETURN (get_ex (scope "parent") (layer - 1) nm).
+                } else {
+                    RETURN (scope "vars" nm).
+                }
+            }
+
+            find_ex = fn (scope, nm) {
+                 ret = scope "vars" nm.
+                 if( ret != NIL) {
+                    RETURN ret.
+                 } else {
+                    if (scope "parent") == NIL {
+                        RETURN NIL.
+                    }
+                    RETURN (find_ex (scope "parent") nm).
+                 }
+            }
+        }
+
+        get = fn (layer, nm) {
+            ret = (get_ex current_scope layer nm).
+            if (ret == NIL) {
+                signal_error ("Internal error, local value " + nm + " was not found") "".
+                RETURN meta::basics::any.
+            }
+            RETURN ret.
+        }
+
+        find = fn (nm) {
+            RETURN (find_ex current_scope nm).
+        }
+    }
+
+    
+    module functions { 
+        hidden {
+            get_arg_list_and_return = fn (args, ret, n) {
+                if !(ret "is_function") { 
+                    RETURN ($args->args, $return->ret). 
+                } else {
+                    RETURN (get_arg_list_and_return (args'(n->(ret "rtype"))) (ret "ptype") (n + 1)).
+                }
+            }
+
+            get_arg_count = fn (f) {
+                if !(f "is_function") {
+                    RETURN 0.
+                } else {
+                    RETURN (get_arg_count (f "ptype")) + 1.
+                }
+            }
+        }
+
+        // TODO_TODO: Test this carefully
+        f_simple = fn (arg, ret) {
+            Describe = fn (_)
+            {
+                RETURN ("(" + (arg "describe" NIL) + "->" + (ret "describe" NIL) + ")").
+            }
+        
+            description = Describe(). 
+            
+            res = (
+                "is_function" -> TRUE,
+                "rtype" -> arg,
+                "ptype" -> ret,
+                "describe" -> fn (_) = description, 
+                "verify_reduction" -> fn (actual) {
+                    if !(compatibility::check arg actual) {
+                        RETURN [ ret, 
+                                 "Incompatible argument type, expecting " + (arg "describe" NIL) + " but observed " + (actual "describe" NIL)
+                                ].  
+                    }
+
+                    RETURN [ ret, NIL ].
+                },
+                "iteration" -> iteration_forbidden description,
+                "check_compatibility" -> fn (actual) {
+                    if !( actual "is_function" ) {
+                        RETURN NIL.
+                    }
+
+                    if !( compatibility::check (actual "rtype") arg) {
+                        RETURN NIL.
+                    }
+
+                    if !( compatibility::check ret (actual "ptype")) {
+                        RETURN NIL.
+                    }
+
+                    RETURN TRUE.
+                }, 
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+
+            RETURN res.
+        }
+
+        hidden {
+            f_ex = fn (args_list, start, ret) {
+                if (args_list 0) == NIL {
+                    _meta_stage_error "Invalid function type, argument list is invalid\n".
+                }
+
+                if (args_list (start + 1) == NIL) {
+                    RETURN (f_simple (args_list start) ret).
+                } else {
+                    RETURN (f_simple (args_list start) (f_ex args_list (start + 1) ret)).
+                }
+            }
+
+            get_last_arg = fn (f) {
+                if !(f "is_function") { RETURN NIL. }
+                if (f "ptype" "is_function") {
+                    RETURN (get_last_arg (f "ptype")).
+                } else {
+                    RETURN (f "rtype").
+                }
+            }
+        }
+
+
+        f = fn (args, ret)
+        {
+            // Backward compatibility as we are switching to type expressions: 
+            // args could be an array [t1,t2,...] or a tuple meta::tuple::type [t1, t2, ...]
+            
+            // tuple type is generated by type expression logic when it sees [t1, t2, ...] 
+            // whereas an expression that is not a type expression will generate an array
+             
+            // TODO: Remove this code when we fully switch to type expressions
+            // and only expect a tuple type descriptor as parameter, not an array
+            tuple = args.
+            if args "is_tuple" { 
+                tuple->args "type_list".
+            }
+                
+            RETURN ( f_ex tuple 0 ret ).
+        }
+        
+        cp_unary_f = fn (arg, ret, cp) { // const_propagating function, used for some primitives
+            description = "(" + (arg "describe" NIL) + "->/*const_propagating*/" + (ret "describe" NIL) + ")". 
+            
+            res = (
+                "rtype" -> arg,
+                "ptype" -> ret,
+                "describe" -> fn (_) = description, 
+                "iteration" -> iteration_forbidden description,
+                "verify_reduction" -> fn (a) {
+                    message = NIL. 
+                    if !(compatibility::check arg a) {
+                        message -> "Incompatible argument type for function, expected " + (arg "describe" NIL) + " but observing " + (a "describe" NIL) + " instead".
+                    }
+
+                    if !(a "is_const") {
+                        RETURN [ ret, message ].
+                    } else {
+                        RETURN [ (basics::constant ret (cp (a "const_value"))), message ]. 
+                    }
+                }, 
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+
+            RETURN res.
+        }
+
+        all_ellipses = (,).
+        
+        ellipsis = fn (type)
+        {
+            description = (type "describe" NIL) + "->...". 
+            res = (
+                "rtype" -> type,
+                "describe" -> fn (_) = description,
+                "iteration" -> iteration_forbidden res,
+                "verify_reduction" -> fn (arg)
+                {
+                    message = NIL. 
+                    if !(compatibility::check type arg) {
+                        message -> "Incompatible argument type". 
+                    }
+
+                    RETURN [ all_ellipses type, message ]. 
+                }, 
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+
+            all_ellipses type -> res. 
+            RETURN res.
+        }
+    }
+    
+    module debug {
+        list_names = fn (_)
+        {
+            sc ::meta::names_root -- (name -> type) {
+                _print name "-->".
+                _print (type "describe" NIL) "\n".
+            }
+        }
+    }
+
+    module blinded {
+        type = fn (rtype, ptype) {
+            description = "#(" + (rtype "describe" NIL) + "->>" + (ptype "describe" NIL) + ")". 
+
+            RETURN (
+                "is_blinded" -> TRUE, 
+                "describe" -> fn (_) = description,
+                "rtype" -> rtype,
+                "ptype" -> ptype,
+                "check_compatibility" -> fn (actual) {
+                    if actual "is_blinded" {
+                        RETURN (rtype "check_compatibility" (actual "rtype")) && 
+                               (ptype "check_compatibility" (actual "ptype")).
+                    } else {
+                        RETURN NIL. 
+                    }
+                },
+                "iteration" -> iteration_forbidden description,
+                "verify_reduction" -> fn (param) 
+                {
+                    if !(rtype "check_compatibility" param) {
+                        message = "In a reduction: invalid reducer type. Required " + (rtype "describe" NIL) + " but observing " + (param "describe" NIL).
+                        RETURN [any_type, message]. 
+                    } else {
+                        RETURN [(meta::nullable::type ptype), NIL].
+                    }
+                },
+                "safe_cast" -> fn (_type_from, err) 
+                {
+                    reducer_cast = conversions::safe_cast basics::any rtype err. 
+                    product_cast = conversions::safe_cast basics::any ptype err. 
+                    RETURN fn (value)
+                    {
+                        abort provisional "Safe cast failed, required dictionary value" WHEN _typeof value != "BLINDED_DICTIONARY".
+                         
+                        sc value -- (i -> v) {
+                            reducer_cast i. 
+                            product_cast v. 
+                        }
+                        
+                        RETURN value. 
+                    }
+                }, 
+                "reference_extention" -> reference_extention_forbidden description,
+            ).
+        }
+
+        make = fn (unblinded_type) {
+            if( unblinded_type "is_immutable" ) { 
+                return type (unblinded_type $rtype) (make (unblinded_type $ptype)). 
+            } elif( unblinded_type "is_record" ) { 
+                return type basics::string basics::any. 
+            } elif( unblinded_type "is_tuple" ) { 
+                return type basics::integer basics::any. 
+            } else { 
+                return unblinded_type. 
+            }
+        }
+    }
+
+    module functor { 
+        array_append = fn (arr, val) { 
+            return arr'(_count arr->val). 
+        }
+
+        simple = fn (
+            in_func /*type,type[]->($check->type,$ts->type[]) */, 
+            out_func /* type[]->type */ 
+       ) { 
+            RETURN fn (typeset /* type[] */) { 
+                description = "(::meta::functor::functor ***)". 
+                RETURN (
+                    "is_functor" -> TRUE, 
+                    "in_typeset" -> typeset, 
+                    "in_func" -> in_func, 
+                    "out_func" -> out_func, 
+                    "describe" -> fn (_) = description, 
+                    "check_compatibility" -> fn (actual) = ( 
+                                                actual $in_typeset == typeset && 
+                                                actual $in_func == in_func && 
+                                                actual $out_func == out_func ),
+                    "iteration" -> iteration_forbidden description,
+                    "safe_cast" -> no_safe_cast description, 
+                    "reference_extention" -> reference_extention_forbidden description, 
+                    "verify_reduction" -> fn (param) { 
+                        BIND ($check->check_type, $ts->out_typeset) TO in_func param typeset. 
+                        if !(compatibility::check check_type param) { 
+                            RETURN [ basics::any, "functor compatibility check failed, needed: " + (check_type "describe" NIL) + " actual:" + (param "describe" NIL) ]. 
+                        } else {
+                            RETURN [ out_func out_typeset, NIL ]. 
+                        } 
+                    }
+                ).
+            }
+        }
+
+        functor_ex = fn (index, args, ret) { 
+            if args (index + 1) == NIL { 
+                return simple (args index) ret. 
+            } else { 
+                return simple (args index) (functor_ex (index + 1) args ret). 
+            }
+        }
+
+        make = fn (args, ret) = (functor_ex 0 args ret). 
+
+        save = fn (param, typeset) = ($check->param, $ts->array_append typeset param).
+
+        check = fn (t) { 
+            RETURN fn (param, typeset) = ($check->t, $ts->array_append typeset param). 
+        }
+
+        return_index_blinded = fn (index) { 
+            RETURN fn (typeset) = (blinded::make (typeset index)). 
+        }
+
+        make_any_x_ret_blinded_0 = fn (t) = ((make [ save, check t ] (return_index_blinded 0)) []). 
+        make_any_x_y_ret_blinded_0 = fn (t1, t2) = ((make [ save, check t1, check t2 ] (return_index_blinded 0)) []). 
+    }
+
+    none = basics::none.
+    arr = immutable::array.
+    int = basics::integer.
+    str = basics::string.
+    bin = basics::binary. 
+    bool = basics::boolean.
+    nil = basics::nil.
+    true = basics::true.
+    false = basics::false.
+    time = basics::time. 
+    utf8 = basics::utf8.
+    hash_code = basics::hash_code.
+    truenil = meta::nullable::type true. 
+    function = functions::f.
+    set = immutable::set.
+    immutable_map = immutable::type.
+    map = immutable::type.
+    db = basics::packet.
+    any = basics::any.
+    saferef = basics::saferef.
+    jsonlimits = record::type($ws->int,$depth->int,$strlen->int,$keylen->int,$items->int).
+    plug = meta::nullable::type true. 
+    secretkey_sign = meta::crypto_element::type $SECKEY_SIGN. 
+    publickey_sign = meta::crypto_element::type $PUBKEY_SIGN. 
+    secretkey_encrypt = meta::crypto_element::type $SECKEY_ENCRYPT. 
+    publickey_encrypt = meta::crypto_element::type $PUBKEY_ENCRYPT. 
+    crypto_signature = meta::crypto_element::type $SIGNATURE. 
+    crypto_message = meta::crypto_element::type $ENCRYPTED_DATA. 
+    crypto = meta::crypto_element::type $ANY. 
+    global_id = meta::opaque::type $global_id str crypto_element::global_id_check.
+
+    eth_transaction = record::type ($nonce->bin, $gasPrice->bin, $gasLimit->bin, $data->bin, $value->bin, $to->bin).
+    eth_transaction_signed = record::type ($nonce->bin, $gasPrice->bin, $gasLimit->bin, $data->bin, $value->bin, $to->bin, $v->bin, $r->bin, $s->bin, $signer->bin, $chain->(meta::nullable::type str)).
+
+    totp_key = record::type ($seckey->bin, $digits->int, $period->int, $algorithm -> enumerated_sets::type str ($SHA1, $SHA256, $SHA512,)).
+    totp_input_configuration = meta::nullable::type (record::type ($digits -> meta::nullable::type int, $period -> meta::nullable::type int, $key_length -> meta::nullable::type int, $algorithm -> meta::nullable::type (enumerated_sets::type str ($SHA1, $SHA256, $SHA512)))).
+
+    hidden { 
+        crypto_scheme_sc = fn (x) {
+            if (x != 1) { 
+                _abort_transaction ("Invalid schema id, allowed 1 but got " + (_str x)). 
+                RETURN NIL. 
+            } else {
+                RETURN x. 
+            }
+        }
+    }
+    crypto_scheme = meta::opaque::type $crypto_scheme int crypto_scheme_sc. 
+
+    module primitives {
+        names_root "::_print" -> functions::ellipsis any.
+        names_root "::_strlen" -> functions::cp_unary_f str int (fn (str) = (_strlen str)).
+        names_root "::_binlen" -> functions::cp_unary_f bin int (fn (v) = (_binlen v)).
+        names_root "::NIL" -> nil.
+        names_root "::TRUE" -> true.
+        names_root "::FALSE" -> false. 
+        names_root "::__LINE__" -> int.
+        names_root "::_to_json_with_limits" -> function [map str int,any] any.
+        names_root "::_from_json_with_limits" -> function [map str int,str] any.
+        names_root "::_rsa_generate_cipher_params" -> function [bin] (record::type ($N->bin, $Phi->bin)).
+        names_root "::_rsa_create_key_by_params" -> function [bin, bin, bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa_create_key" -> function [bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa_encrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa_decrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa1024_generate_cipher_params" -> function [bin] (record::type ($N->bin, $Phi->bin)).
+        names_root "::_rsa1024_create_key_by_params" -> function [bin, bin, bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa1024_create_key" -> function [bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa1024_encrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa1024_decrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa2048_generate_cipher_params" -> function [bin] (record::type ($N->bin, $Phi->bin)).
+        names_root "::_rsa2048_create_key_by_params" -> function [bin, bin, bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa2048_create_key" -> function [bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa2048_encrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa2048_decrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa4096_generate_cipher_params" -> function [bin] (record::type ($N->bin, $Phi->bin)).
+        names_root "::_rsa4096_create_key_by_params" -> function [bin, bin, bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa4096_create_key" -> function [bin] (record::type ($N-> bin, $E->bin, $D->bin)).
+        names_root "::_rsa4096_encrypt" -> function [bin, bin, bin] bin.
+        names_root "::_rsa4096_decrypt" -> function [bin, bin, bin] bin.
+        names_root "::_shamir_generate_shares" -> function [bin, int, int, bin] (record::type ($K->int, $N->int, $Prime->bin, $Shares->(immutable::array (record::type ($i->int, $share->bin))))).
+        names_root "::_shamir_reconstruct_secret" -> function [int, bin, (immutable::array bin)] bin.
+        names_root "::_ecc_c25519_create_key" -> function [str] (meta::tuple::type [str,str]).
+        names_root "::_crypto_get_scheme_id" -> function [crypto] int. 
+        names_root "::_crypto_get_element_kind" -> function [crypto] str. 
+        names_root "::_crypto_construct_signing_keypair" -> function [int] (record::type ($public_key->publickey_sign, $secret_key->secretkey_sign)).
+        names_root "::_crypto_signing_keypair_from_secret" -> function [int, secretkey_sign] (record::type ($public_key->publickey_sign, $secret_key->secretkey_sign)).
+        names_root "::_crypto_construct_encryption_keypair" -> function [int] (record::type ($public_key->publickey_encrypt, $secret_key->secretkey_encrypt)).
+        names_root "::_crypto_construct_encryption_keypair_from_seed" -> function [int, bin] (record::type ($public_key->publickey_encrypt, $secret_key->secretkey_encrypt)).
+        names_root "::_crypto_default_scheme_id" -> function [plug] int. 
+        names_root "::_crypto_scheme_id_valid_range" -> function [plug] (record::type ($min->int, $max->int)). 
+        names_root "::_crypto_element_validate" -> function [crypto, int, str] truenil. 
+        names_root "::_crypto_validate_kind" -> function [str] truenil. 
+        names_root "::_crypto_sign_hash" -> function [hash_code,secretkey_sign] crypto_signature. 
+        names_root "::_crypto_verify_hash_signature" -> function [hash_code,crypto_signature,publickey_sign] truenil. 
+        names_root "::_crypto_encrypt_message" -> function [secretkey_encrypt,publickey_encrypt,bin] crypto_message. 
+        names_root "::_crypto_decrypt_message" -> function [secretkey_encrypt,publickey_encrypt,crypto_message] bin.
+        names_root "::_crypto_get_key_id" -> function [ crypto ] bin. 
+        names_root "::_crypto_get_key_id_target" -> function [ crypto_message ] bin. 
+        names_root "::_construct_blinded_dictionary" -> functor::make_any_x_ret_blinded_0 (immutable::set (immutable::array basics::any) ). 
+        names_root "::_construct_blinded_dictionary_custom" -> functor::make_any_x_y_ret_blinded_0 (immutable::set (immutable::array basics::any) ) (immutable::type str any).
+        names_root "::_construct_blinded_with_absence" -> functor::make_any_x_y_ret_blinded_0 (immutable::set (immutable::array basics::any) ) (immutable::set (immutable::array basics::any) ).
+        names_root "::_examine_blinded" -> function [any, (immutable::array basics::any)] (immutable::array basics::any).
+        names_root "::_examine_blinded_many" -> function [any, (immutable::array (immutable::array basics::any))] (immutable::array (immutable::array basics::any)).
+        names_root "::_examine_blinded_strict" -> function [any, (immutable::array basics::any)] (immutable::array basics::any).
+        names_root "::_examine_blinded_many_strict" -> function [any, (immutable::array (immutable::array basics::any))] (immutable::array (immutable::array basics::any)).
+        names_root "::_get_hash_code_metadata" -> function [hash_code] (record::type ($hash_type->str, $hash_shape_version->int)).
+        names_root "::_eth_sign" -> function [bin, eth_transaction, meta::nullable::type int] bin.
+        names_root "::_eth_parse_signature" -> function [bin] eth_transaction_signed.
+        names_root "::_eth_validate_and_parse_signature" -> function [bin, bin] eth_transaction_signed.
+        names_root "::_eth_public_from_private" -> function [bin] bin.
+        names_root "::_eth_address_from_public" -> function [bin] bin.
+        names_root "::_eth_compress_public" -> function [bin] bin.
+        names_root "::_eth_decompress_public" -> function [bin] bin.
+        names_root "::_rlp_decode" -> function [bin] any.
+        names_root "::_crypto_keccak256" -> function [bin] bin.
+        names_root "::_crypto_sha256" -> function [bin] bin.
+        names_root "::_crypto_sha256d" -> function [bin] bin.
+        names_root "::_crypto_ripemd160" -> function [bin] bin.
+        names_root "::_crypto_hash160" -> function [bin] bin.
+        names_root "::_crypto_hmac_sha256" -> function [bin, bin] bin.
+        names_root "::_crypto_hmac_sha512" -> function [bin, bin] bin.
+        names_root "::_base58_encode" -> function [bin] str.
+        names_root "::_base58_decode" -> function [str] bin.
+        names_root "::_base58check_encode" -> function [bin] str.
+        names_root "::_base58check_decode" -> function [str] bin.
+        names_root "::_crypto_secp256k1_sign_recoverable" -> function [bin, bin] bin.
+        names_root "::_crypto_secp256k1_ecrecover" -> function [bin, bin] bin.
+        names_root "::_crypto_secp256k1_verify" -> function [bin, bin, bin] truenil.
+        names_root "::_rlp_encode" -> function [any] bin.
+        names_root "::_bech32_encode" -> function [str, bin] str.
+        names_root "::_bech32_decode" -> function [str] (record::type ($hrp->str, $data->bin)).
+        names_root "::_bech32m_encode" -> function [str, bin] str.
+        names_root "::_bech32m_decode" -> function [str] (record::type ($hrp->str, $data->bin)).
+        names_root "::_read" -> function [bin] (forwards::disjunction ((record::type ($kind -> enumerated_sets::type str ($ok,), $value -> any)), (record::type ($kind -> enumerated_sets::type str ($err,), $value -> str)))).
+        names_root "::_generate_totp_key" -> function [totp_input_configuration] totp_key.
+        names_root "::_generate_totp_code" -> function [totp_key, time] str.
+
+        ret_spec = basics::nothing "primitives::retspec".
+        ret_spec->ret_spec'(
+            "verify_reduction" -> fn (arg) {
+                message = NIL. 
+                expected = ret::current().
+                if expected == NIL {
+                    message -> "Return without a function (ret_spec)". 
+                } elif !(compatibility::check expected arg) {
+                    // TODO TODO: prevent creation of duplicate names inside temporary scopes of if and SCAN
+                    message -> ("Invalid return type, expected " + (expected "describe" NIL) + " but observing " + (arg "describe" NIL)). 
+                }
+                
+                ret::set_state(). 
+                RETURN [ arg, message ]. 
+            }
+        ).
+        names_root "::_return" -> ret_spec.
+    }
+
+    type_of_global = fn (name) = (names_root name "describe" NIL).
+    type_of_local = fn (name) {
+        t = locals::find name.
+        if t {
+            RETURN (locals::find name "describe" NIL).
+        } else {
+            RETURN "".
+        }
+    }
+
+    domain_of = fn (name) = (domain::name (names_root name "domain")).
+    is_constant = fn (name) = (names_root name "is_const").
+    constant_value = fn (name) = (names_root name "const_value").
+
+    module checks {
+        verify_is_type_expression = fn (err, expr)
+        {
+            if (_typeof expr) != "IMMUTABLE_DICTIONARY" {
+                signal_error "Invalid type expression" err.
+                RETURN int.
+            }
+
+            if (expr "describe") == NIL {
+                signal_error "Invalid type expression" err.
+                RETURN int.
+            }
+
+            RETURN expr.
+        }
+    }
+
+    global_name_get = fn (name, err)
+    {
+        ret = names_root name.
+        if ret == NIL {
+            signal_error ("Internal error: global name " + name + " was not found") err.
+            RETURN any.
+        }
+        RETURN ret.
+    }
+
+
+    get_reducer_type = fn (f, err)
+    {
+        if f "iterable" || f "is_record" || f "is_immutable" || f "is_function" || f "is_tuple" || f "is_record" {
+            RETURN f "rtype". 
+        } elif f "is_any_type" { 
+            RETURN meta::basics::any. 
+        } else {
+            signal_error ("Cannot deduce reducer type for " + ( f "describe" NIL ) ) err. 
+            RETURN meta::basics::any. 
+        }
+    }
+
+    get_product_type = fn (f, err)
+    {
+        if f "iterable" || f "is_immutable" || f "is_function" || f "is_tuple" || f "is_record" {
+            RETURN f "ptype".
+        } elif f "is_any_type" { 
+            RETURN meta::basics::any. 
+        } else {
+            message = "Cannot deduce product type for " + (f "describe" NIL). 
+            signal_error message err.
+            RETURN basics::any. 
+        }  
+    }
+    
+    
+    get_product_type_detailed = fn (f, reducer, err)
+    {
+        if f "iterable" || f "is_immutable" || f "is_function" {
+            RETURN f "ptype". 
+        } elif f "is_record" { 
+            if reducer "is_const" && _typeof (reducer "const_value") == "STRING" {
+                ret =  f "field_list" (reducer "const_value").  
+                if NIL != ret { 
+                    RETURN ret. 
+                } else {
+                    RETURN basics::any.   
+                } 
+            } else {
+                RETURN basics::any. 
+            }
+        } elif f "is_tuple" { 
+            if reducer "is_const" && _typeof (reducer "const_value") == "INTEGER" {
+                ret = f "type_list" (reducer "const_value"). 
+                if NIL != ret { 
+                    RETURN ret. 
+                } else {
+                    RETURN basics::any.
+                }
+            } else {
+                RETURN basics::any. 
+            }
+        } elif f "is_any_type" { 
+            RETURN basics::any.  
+        } elif f "is_nullable" { 
+            RETURN get_product_type_detailed (f "non_null_type") reducer err.           
+        } else {
+            signal_error ("Type " + (f "describe" NIL) + " is not reduce-able: no product") err.
+            RETURN basics::any.
+        } 
+    }
+  
+    finalize = fn (_) 
+    {
+    }
+}