Very basic return types

Author: timfennis

ndc_bin/src/docs.rs

@@ -67,14 +67,16 @@ pub fn docs(query: Option<&str>) -> anyhow::Result<()> {
                     }
                 }
 
-                writeln!(signature, ")")?;
+                write!(signature, ")")?;
             }
         }
         let name = function.name();
         let documentation = function.documentation().trim();
+        let return_type = function.return_type();
         let markdown = format!(
-            "---\n\n## **{}**{signature}\n{documentation}{}",
+            "---\n\n## **{}**{signature} -> {}\n\n{documentation}{}",
             name.green(),
+            format!("{}", return_type).green().bold(),
             if documentation.is_empty() { "" } else { "\n\n" }
         );
 

ndc_lib/src/ast/expression.rs

@@ -1,6 +1,7 @@
 use crate::ast::operator::LogicalOperator;
 use crate::ast::parser::Error as ParseError;
 use crate::interpreter::evaluate::EvaluationError;
+use crate::interpreter::function::StaticType;
 use crate::lexer::Span;
 use num::BigInt;
 use num::complex::Complex64;
@@ -57,6 +58,7 @@ pub enum Expression {
         resolved_name: Option<ResolvedVar>,
         parameters: Box<ExpressionLocation>,
         body: Box<ExpressionLocation>,
+        return_type: Option<StaticType>,
         pure: bool,
     },
     Block {
@@ -332,15 +334,17 @@ impl std::fmt::Debug for ExpressionLocation {
                 .finish(),
             Expression::FunctionDeclaration {
                 name,
-                parameters: arguments,
+                parameters,
+                return_type,
                 body,
                 pure,
                 resolved_name,
             } => f
                 .debug_struct("FunctionDeclaration")
                 .field("name", name)
                 .field("resolved_name", resolved_name)
-                .field("arguments", arguments)
+                .field("parameters", parameters)
+                .field("return_type", return_type)
                 .field("body", body)
                 .field("pure", pure)
                 .finish(),

ndc_lib/src/ast/parser.rs

@@ -1157,6 +1157,7 @@ impl Parser {
                 name: identifier,
                 parameters: Box::new(argument_list),
                 body: Box::new(body),
+                return_type: None, // At some point in the future we could use type declarations here to insert the type (return type inference is cringe anyway)
                 pure: is_pure,
                 resolved_name: None,
             },

ndc_lib/src/interpreter/evaluate/mod.rs

@@ -348,12 +348,14 @@ pub(crate) fn evaluate_expression(
             parameters: arguments,
             body,
             resolved_name,
+            return_type,
             pure,
             ..
         } => {
             let mut user_function = FunctionBody::Closure {
                 parameter_names: arguments.try_into_parameters()?,
                 body: *body.clone(),
+                return_type: return_type.clone().unwrap_or_else(StaticType::unit),
                 environment: environment.clone(),
             };
 

ndc_lib/src/interpreter/function.rs

@@ -72,13 +72,17 @@ impl Function {
     pub fn type_signature(&self) -> TypeSignature {
         self.body.type_signature()
     }
+    pub fn return_type(&self) -> &StaticType {
+        self.body.return_type()
+    }
 }
 
 #[derive(Clone)]
 pub enum FunctionBody {
     Closure {
         parameter_names: Vec<String>,
         body: ExpressionLocation,
+        return_type: StaticType,
         environment: Rc<RefCell<Environment>>,
     },
     NumericUnaryOp {
@@ -89,6 +93,7 @@ pub enum FunctionBody {
     },
     GenericFunction {
         type_signature: TypeSignature,
+        return_type: StaticType,
         function: fn(&mut [Value], &Rc<RefCell<Environment>>) -> EvaluationResult,
     },
     Memoized {
@@ -111,13 +116,16 @@ impl FunctionBody {
     }
     pub fn generic(
         type_signature: TypeSignature,
+        return_type: StaticType,
         function: fn(&mut [Value], &Rc<RefCell<Environment>>) -> EvaluationResult,
     ) -> Self {
         Self::GenericFunction {
             type_signature,
+            return_type,
             function,
         }
     }
+
     fn type_signature(&self) -> TypeSignature {
         match self {
             Self::Closure {
@@ -140,6 +148,15 @@ impl FunctionBody {
         }
     }
 
+    pub fn return_type(&self) -> &StaticType {
+        match self {
+            FunctionBody::Closure { return_type, .. } => return_type,
+            FunctionBody::NumericUnaryOp { .. } => &StaticType::Number,
+            FunctionBody::NumericBinaryOp { .. } => &StaticType::Number,
+            FunctionBody::GenericFunction { return_type, .. } => return_type,
+            FunctionBody::Memoized { function, .. } => function.return_type(),
+        }
+    }
     pub fn call(&self, args: &mut [Value], env: &Rc<RefCell<Environment>>) -> EvaluationResult {
         match self {
             Self::Closure {

ndc_lib/src/stdlib/file.rs

@@ -1,5 +1,7 @@
 use crate::interpreter::environment::Environment;
-use crate::interpreter::function::{FunctionBody, FunctionBuilder, FunctionCarrier, TypeSignature};
+use crate::interpreter::function::{
+    FunctionBody, FunctionBuilder, FunctionCarrier, StaticType, TypeSignature,
+};
 use crate::interpreter::value::Value;
 use ndc_macros::export_module;
 use std::fs::read_to_string;
@@ -46,6 +48,7 @@ pub fn register_variadic(env: &mut Environment) {
                     Ok(Value::unit())
                 },
                 type_signature: TypeSignature::Variadic,
+                return_type: StaticType::unit(),
             })
             .build()
             .expect("function definition defined in code must be valid"),
@@ -73,6 +76,7 @@ pub fn register_variadic(env: &mut Environment) {
                     Ok(Value::unit())
                 },
                 type_signature: TypeSignature::Variadic,
+                return_type: StaticType::unit(),
             })
             .build()
             .expect("function definition defined in code must be valid"),

ndc_lib/src/stdlib/math.rs

@@ -267,6 +267,7 @@ pub mod f64 {
                                 },
                                 _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                             },
+                            return_type: StaticType::Bool,
                         })
                         .build()
                         .expect("must succeed")
@@ -291,6 +292,7 @@ pub mod f64 {
                         [left, right] => Ok(Value::Bool(left == right)),
                         _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                     },
+                    return_type: StaticType::Bool,
                 })
                 .build()
                 .expect("must succeed")
@@ -308,6 +310,7 @@ pub mod f64 {
                         [left, right] => Ok(Value::Bool(left != right)),
                         _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                     },
+                    return_type: StaticType::Bool,
                 })
                 .build()
                 .expect("must succeed")
@@ -330,6 +333,7 @@ pub mod f64 {
                         },
                         _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                     },
+                    return_type: StaticType::Int,
                 })
                 .build()
                 .expect("must succeed")
@@ -352,6 +356,7 @@ pub mod f64 {
                         },
                         _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                     },
+                    return_type: StaticType::Int,
                 })
                 .build()
                 .expect("must succeed")
@@ -371,6 +376,7 @@ pub mod f64 {
                                 [Value::Bool(left), Value::Bool(right)] => Ok(Value::Bool($operation(*left, *right))),
                                 _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                             },
+                            return_type: StaticType::Bool,
                         })
                         .build()
                         .expect("must succeed")
@@ -388,6 +394,7 @@ pub mod f64 {
                                 [Value::Number(Number::Int(left)), Value::Number(Number::Int(right))] => Ok(Value::Number(Number::Int($operation(left.clone(), right.clone())))),
                                 _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                             },
+                            return_type: StaticType::Int,
                         })
                         .build()
                         .expect("must succeed"),
@@ -416,6 +423,7 @@ pub mod f64 {
                             [Value::Bool(b)] => Ok(Value::Bool(b.not())),
                             _ => unreachable!("the type checker should never invoke this function if the argument count does not match"),
                         },
+                        return_type: StaticType::Bool,
                     })
                     .name(ident.to_string())
                     .build()
@@ -437,6 +445,7 @@ pub mod f64 {
                             .map(|x| Value::Number(Number::Int(x))),
                         _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                     },
+                    return_type: StaticType::Int,
                 })
                 .build()
                 .expect("must succeed")
@@ -456,6 +465,7 @@ pub mod f64 {
                             .map(|x| Value::Number(Number::Int(x))),
                         _ => unreachable!("the type checker should never invoke this function if the argument count does not match")
                     },
+                    return_type: StaticType::Int,
                 })
                 .build()
                 .expect("must succeed")

ndc_lib/src/stdlib/sequence.rs

@@ -735,7 +735,7 @@ pub mod extra {
     use anyhow::anyhow;
     use itertools::izip;
 
-    use crate::interpreter::function::FunctionBuilder;
+    use crate::interpreter::function::{FunctionBuilder, StaticType};
     use crate::interpreter::{
         environment::Environment, function::FunctionBody, iterator::mut_value_to_iterator,
         value::Value,
@@ -748,6 +748,7 @@ pub mod extra {
                     .documentation("Combines multiple sequences (or iterables) into a single sequence of tuples, where the ith tuple contains the ith element from each input sequence.\n\nIf the input sequences are of different lengths, the resulting sequence is truncated to the length of the shortest input.".to_string())
                     .body(FunctionBody::generic(
                         crate::interpreter::function::TypeSignature::Variadic,
+                        StaticType::List,
                         |args, _env| match args {
                             [_] => {
                                 Err(anyhow!("zip must be called with 2 or more arguments").into())

ndc_macros/src/function.rs

@@ -53,6 +53,9 @@ pub fn wrap_function(function: &syn::ItemFn) -> Vec<WrappedFunction> {
         }
     }
 
+    // TODO: CONTINUE HERE
+    let return_type = quote! { crate::interpreter::function::StaticType::Any }; // RIP ROP RAP
+
     // If the function has no argument then the cartesian product stuff below doesn't work
     if function.sig.inputs.is_empty() {
         return function_names
@@ -63,6 +66,7 @@ pub fn wrap_function(function: &syn::ItemFn) -> Vec<WrappedFunction> {
                     &original_identifier,
                     function_name,
                     vec![],
+                    return_type.clone(),
                     &docs_buf,
                 )
             })
@@ -71,7 +75,6 @@ pub fn wrap_function(function: &syn::ItemFn) -> Vec<WrappedFunction> {
 
     // When we call create_temp_variable we can get multiple definitions for a variable
     // For instance when a rust function is `fn foo(list: &[Value])` we can define two internal functions for both Tuple and List
-
     let mut variation_id = 0usize;
     function_names
         .iter()
@@ -98,6 +101,7 @@ pub fn wrap_function(function: &syn::ItemFn) -> Vec<WrappedFunction> {
                         &format_ident!("{original_identifier}_{variation_id}"),
                         function_name,
                         args,
+                        return_type.clone(),
                         &docs_buf,
                     );
                     variation_id += 1;
@@ -116,6 +120,7 @@ fn wrap_single(
     identifier: &syn::Ident,
     register_as_function_name: &proc_macro2::Literal,
     input_arguments: Vec<Argument>,
+    return_type: TokenStream,
     docs: &str,
 ) -> WrappedFunction {
     let inner_ident = format_ident!("{}_inner", identifier);
@@ -206,6 +211,7 @@ fn wrap_single(
                 type_signature: crate::interpreter::function::TypeSignature::Exact(vec![
                     #( crate::interpreter::function::Parameter::new(#param_names, #param_types,) ),*
                 ]),
+                return_type: #return_type,
             })
             .name(String::from(#register_as_function_name))
             .documentation(String::from(#docs))

tests/programs/603_stdlib_seq/004_zip.ndct

@@ -0,0 +1,5 @@
+--PROGRAM--
+assert_eq((1,2).zip((3,4)), [(1,3),(2,4)]);
+print("ok");
+--EXPECT--
+ok