feat: Cast values of structurally equivalent types

Casts allow us to convert a pair (u8, u8) of two integers into one u16
integer, and so on. A cast between two Simfony types A and B is possible
if and only if the Simplicity types (aka structural types) that underly
A and B are exactly equal.

Casts in languages like Rust or C++ usually specify their target type.
Simfony casts specify their **source type**. The Simfony compiler knows
the expected output type of each expression. In the above example, the
compiler knows that it expects a `u16` output, but it doesn't know if
the cast input value `(1, 1)` is of type `(u8, u8)` or `(u16, u16)` or
`(u32, u32)`, ... . Therefore, Simfony casts have a slightly weird syntax:

let out: u16 = <(u8, u8)>::into((1, 1));

More generally, the syntax is

let out: TargetType = <SourceType>::into(source_value);

For what it's worth, this is valid Rust and the Rust code works in the
same way as the Simfony code. I think we can live with this syntax,
although it isn't perfect. Casts of the form
<TargetType>::from(source_value) would require a major overhaul of the
compiler.

Also remove `$` from the grammar to allow whitespaces in types,
such as `(u8, u8)`, as opposed to the spaceless `(u8,u8)`.

Author: uncomputable

src/ast.rs

@@ -10,7 +10,9 @@ use crate::error::{Error, RichError, WithSpan};
 use crate::parse;
 use crate::parse::{FunctionName, Identifier, MatchPattern, Span, WitnessName};
 use crate::pattern::Pattern;
-use crate::types::{AliasedType, ResolvedType, TypeConstructible, TypeDeconstructible};
+use crate::types::{
+    AliasedType, ResolvedType, StructuralType, TypeConstructible, TypeDeconstructible,
+};
 use crate::value::{UIntValue, Value};
 
 /// Map of witness names to their expected type, as declared in the program.
@@ -233,6 +235,8 @@ pub enum CallName {
     UnwrapRight(ResolvedType),
     /// [`Option::unwrap`].
     Unwrap,
+    /// Cast from the given source type.
+    TypeCast(ResolvedType),
     /// A custom function that was defined previously.
     ///
     /// We effectively copy the function body into every call of the function.
@@ -899,6 +903,20 @@ impl AbstractSyntaxTree for Call {
                     scope,
                 )?])
             }
+            CallName::TypeCast(source) => {
+                if from.args.len() != 1 {
+                    return Err(Error::InvalidNumberOfArguments(1, from.args.len()))
+                        .with_span(from);
+                }
+                if StructuralType::from(&source) != StructuralType::from(ty) {
+                    return Err(Error::InvalidCast(source, ty.clone())).with_span(from);
+                }
+                Arc::from([Expression::analyze(
+                    from.args.first().unwrap(),
+                    &source,
+                    scope,
+                )?])
+            }
             CallName::Custom(function) => {
                 if from.args.len() != function.params().len() {
                     return Err(Error::InvalidNumberOfArguments(
@@ -951,6 +969,9 @@ impl AbstractSyntaxTree for CallName {
                 .map(Self::UnwrapRight)
                 .with_span(from),
             parse::CallName::Unwrap => Ok(Self::Unwrap),
+            parse::CallName::TypeCast(target) => {
+                scope.resolve(target).map(Self::TypeCast).with_span(from)
+            }
             parse::CallName::Custom(name) => scope
                 .get_function(name)
                 .cloned()

src/compile.rs

@@ -301,6 +301,13 @@ impl Call {
                 let get_inner = ProgNode::assertr_take(fail_cmr, &ProgNode::iden());
                 ProgNode::comp(&right_and_unit, &get_inner).with_span(self)
             }
+            CallName::TypeCast(..) => {
+                // A cast converts between two structurally equal types.
+                // Structural equality of Simfony types A and B means
+                // exact equality of the underlying Simplicity types of A and of B.
+                // Therefore, a Simfony cast is a NOP in Simplicity.
+                Ok(args)
+            }
             CallName::Custom(function) => {
                 let params_pattern = Pattern::tuple(
                     function

src/error.rs

@@ -154,6 +154,7 @@ pub enum Error {
     CannotCompile(String),
     JetDoesNotExist(JetName),
     TypeValueMismatch(ResolvedType),
+    InvalidCast(ResolvedType, ResolvedType),
     MainNoInputs,
     MainNoOutput,
     MainRequired,
@@ -212,6 +213,10 @@ impl fmt::Display for Error {
                 f,
                 "Value does not match the assigned type `{ty}`"
             ),
+            Error::InvalidCast(source, target) => write!(
+                f,
+                "Cannot cast values of type `{source}` as values of type `{target}`"
+            ),
             Error::MainNoInputs => write!(
                 f,
                 "Main function takes no input parameters"

src/minimal.pest

@@ -55,10 +55,11 @@ none_expr         = @{ "None" }
 some_expr         =  { "Some(" ~ expression ~ ")" }
 false_expr        = @{ "false" }
 true_expr         = @{ "true" }
-unwrap_left       = ${ "unwrap_left::<" ~ ty ~ ">" }
-unwrap_right      = ${ "unwrap_right::<" ~ ty ~ ">" }
+unwrap_left       =  { "unwrap_left::<" ~ ty ~ ">" }
+unwrap_right      =  { "unwrap_right::<" ~ ty ~ ">" }
 unwrap            = @{ "unwrap" }
-call_name         = ${ jet | unwrap_left | unwrap_right | unwrap | function_name }
+type_cast         =  { "<" ~ ty ~ ">::into" }
+call_name         =  { jet | unwrap_left | unwrap_right | unwrap | type_cast | function_name }
 call_args         =  { "(" ~ (expression ~ ("," ~ expression)*)? ~ ")" }
 call_expr         =  { call_name ~ call_args }
 unsigned_decimal  = @{ (ASCII_DIGIT | "_")+ }

src/parse.rs

@@ -278,6 +278,8 @@ pub enum CallName {
     UnwrapRight(AliasedType),
     /// Some unwrap function.
     Unwrap,
+    /// Cast from the given source type.
+    TypeCast(AliasedType),
     /// Name of a custom function.
     Custom(FunctionName),
 }
@@ -813,6 +815,10 @@ impl PestParse for CallName {
                 AliasedType::parse(inner).map(Self::UnwrapRight)
             }
             Rule::unwrap => Ok(Self::Unwrap),
+            Rule::type_cast => {
+                let inner = pair.into_inner().next().unwrap();
+                AliasedType::parse(inner).map(Self::TypeCast)
+            }
             Rule::function_name => FunctionName::parse(pair).map(Self::Custom),
             _ => panic!("Corrupt grammar"),
         }