Enum clarity_repl::clarity::types::signatures::TypeSignature

source · [−]

pub enum TypeSignature {
    NoType,
    IntType,
    UIntType,
    BoolType,
    SequenceType(SequenceSubtype),
    PrincipalType,
    TupleType(TupleTypeSignature),
    OptionalType(Box<TypeSignature>),
    ResponseType(Box<(TypeSignature, TypeSignature)>),
    TraitReferenceType(TraitIdentifier),
}

Variants

`NoType`

`IntType`

`UIntType`

`BoolType`

`SequenceType(SequenceSubtype)`

`PrincipalType`

`TupleType(TupleTypeSignature)`

`OptionalType(Box<TypeSignature>)`

`ResponseType(Box<(TypeSignature, TypeSignature)>)`

`TraitReferenceType(TraitIdentifier)`

Implementations

source

impl TypeSignature

source

pub fn new_option(
inner_type: TypeSignature
) -> Result<TypeSignature, CheckErrors>

source

pub fn new_response(
ok_type: TypeSignature,
err_type: TypeSignature
) -> Result<TypeSignature, CheckErrors>

source

pub fn factor_out_no_type(
a: &TypeSignature,
b: &TypeSignature
) -> Result<TypeSignature, CheckErrors>

If one of the types is a NoType, return Ok(the other type), otherwise return least_supertype(a, b)

source

pub fn least_supertype(
a: &TypeSignature,
b: &TypeSignature
) -> Result<TypeSignature, CheckErrors>

This function returns the most-restrictive type that admits both A and B (something like a least common supertype), or Errors if no such type exists. On error, it throws NoSuperType(A,B), unless a constructor error’ed – in which case, it throws the constructor’s error.

For two Tuples: least_supertype(A, B) := (tuple \for_each(key k) least_supertype(type_a_k, type_b_k)) For two Lists: least_supertype(A, B) := (list max_len: max(max_len A, max_len B), entry: least_supertype(entry_a, entry_b)) if max_len A | max_len B is 0: entry := Non-empty list entry For two responses: least_supertype(A, B) := (response least_supertype(ok_a, ok_b), least_supertype(err_a, err_b)) if any entries are NoType, use the other type’s entry For two options: least_supertype(A, B) := (option least_supertype(some_a, some_b)) if some_a | some_b is NoType, use the other type’s entry. For buffers: least_supertype(A, B) := (buff len: max(len A, len B)) For ints, uints, principals, bools: least_supertype(A, B) := if A != B, error, else A

source

pub fn list_of(
item_type: TypeSignature,
max_len: u32
) -> Result<TypeSignature, CheckErrors>

source

pub fn empty_list() -> ListTypeData

source

pub fn type_of(x: &Value) -> TypeSignature

source

pub fn construct_parent_list_type(
args: &[Value ]
) -> Result<ListTypeData, CheckErrors>

source

pub fn parent_list_type(
children: &[TypeSignature ]
) -> Result<ListTypeData, CheckErrors>

source

impl TypeSignature

Parsing functions.

source

pub fn parse_response_type_repr<A: CostTracker>(
type_args: &[SymbolicExpression ],
accounting: &mut A
) -> Result<TypeSignature, CheckErrors>

source

pub fn parse_type_repr<A: CostTracker>(
x: &SymbolicExpression,
accounting: &mut A
) -> Result<TypeSignature, CheckErrors>

source

pub fn parse_trait_type_repr<A: CostTracker>(
type_args: &[SymbolicExpression ],
accounting: &mut A
) -> Result<BTreeMap<ClarityName, FunctionSignature>, CheckErrors>

source

impl TypeSignature

These implement the size calculations in TypeSignatures in constructors of TypeSignatures, only .inner_size() may be called. .inner_size is a failable method to compute the size of the type signature, Failures indicate that a type signature represents too large of a value. TypeSignature constructors will fail instead of constructing such a type. because of this, the public interface to size is infallible.

source