From 18859cda778b1942a2ee2fd0ae7195e308092d61 Mon Sep 17 00:00:00 2001 From: Jeff Date: Mon, 24 Jun 2024 07:13:54 -0400 Subject: [PATCH] Begin fixing built-in functions --- .../src/abstract_tree/built_in_function.rs | 279 +++++++----------- dust-lang/src/abstract_tree/expression.rs | 16 +- dust-lang/src/abstract_tree/mod.rs | 2 +- dust-lang/src/abstract_tree/value_node.rs | 20 +- dust-lang/src/error.rs | 2 +- dust-lang/src/parser/mod.rs | 89 +++--- dust-lang/src/parser/tests.rs | 22 +- dust-lang/src/value.rs | 8 +- examples/json_length.ds | 5 - std/core.ds | 2 +- std/fs.ds | 2 +- 11 files changed, 187 insertions(+), 260 deletions(-) diff --git a/dust-lang/src/abstract_tree/built_in_function.rs b/dust-lang/src/abstract_tree/built_in_function.rs index 0098a7c..473d667 100644 --- a/dust-lang/src/abstract_tree/built_in_function.rs +++ b/dust-lang/src/abstract_tree/built_in_function.rs @@ -14,242 +14,179 @@ use crate::{ use super::{AbstractNode, Evaluation, Expression, Type, TypeConstructor}; #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub enum BuiltInFunctionCall { - Length(Length), - ReadFile(ReadFile), - ReadLine(ReadLine), - Sleep(Sleep), - WriteLine(WriteLine), - JsonParse(JsonParse), +pub enum BuiltInFunction { + Length, + ReadLine, + ReadFile, + Sleep, + WriteLine, + JsonParse, } -impl AbstractNode for BuiltInFunctionCall { - fn define_types(&self, _context: &Context) -> Result<(), ValidationError> { - Ok(()) - } - - fn validate(&self, _context: &Context, _manage_memory: bool) -> Result<(), ValidationError> { - Ok(()) - } - - fn evaluate( - self, - _context: &Context, - _manage_memory: bool, - ) -> Result, RuntimeError> { +impl BuiltInFunction { + pub fn r#type(&self) -> Type { match self { - BuiltInFunctionCall::Length(inner) => inner.call(_context, _manage_memory), - BuiltInFunctionCall::ReadFile(inner) => inner.call(_context, _manage_memory), - BuiltInFunctionCall::ReadLine(inner) => inner.call(_context, _manage_memory), - BuiltInFunctionCall::Sleep(inner) => inner.call(_context, _manage_memory), - BuiltInFunctionCall::WriteLine(inner) => inner.call(_context, _manage_memory), - BuiltInFunctionCall::JsonParse(inner) => inner.call(_context, _manage_memory), + BuiltInFunction::Length => Length::r#type(), + BuiltInFunction::ReadLine => ReadLine::r#type(), + BuiltInFunction::ReadFile => ReadFile::r#type(), + BuiltInFunction::Sleep => Sleep::r#type(), + BuiltInFunction::WriteLine => WriteLine::r#type(), + BuiltInFunction::JsonParse => JsonParse::r#type(), } } - fn expected_type(&self, _context: &Context) -> Result, ValidationError> { + pub fn call(&self, context: &Context, manage_memory: bool) -> Result { match self { - BuiltInFunctionCall::Length(inner) => inner.return_type(_context), - BuiltInFunctionCall::ReadFile(inner) => inner.return_type(_context), - BuiltInFunctionCall::ReadLine(inner) => inner.return_type(_context), - BuiltInFunctionCall::Sleep(inner) => inner.return_type(_context), - BuiltInFunctionCall::WriteLine(inner) => inner.return_type(_context), - BuiltInFunctionCall::JsonParse(inner) => inner.return_type(_context), + BuiltInFunction::Length => Length::call(context, manage_memory), + BuiltInFunction::ReadLine => ReadLine::call(context, manage_memory), + BuiltInFunction::ReadFile => ReadFile::call(context, manage_memory), + BuiltInFunction::Sleep => Sleep::call(context, manage_memory), + BuiltInFunction::WriteLine => WriteLine::call(context, manage_memory), + BuiltInFunction::JsonParse => JsonParse::call(context, manage_memory), } } } trait FunctionLogic { - fn return_type(&self, context: &Context) -> Result, ValidationError>; - fn call( - self, - context: &Context, - manage_memory: bool, - ) -> Result, RuntimeError>; + fn r#type() -> Type; + fn call(context: &Context, manage_memory: bool) -> Result; } #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub struct Length(Box); - -impl Length { - pub fn new(expression: Expression) -> Self { - Length(Box::new(expression)) - } -} +struct Length; impl FunctionLogic for Length { - fn return_type(&self, _: &Context) -> Result, ValidationError> { - Ok(Some(Type::Integer)) + fn r#type() -> Type { + Type::Function { + type_parameters: None, + value_parameters: Some(vec![( + Identifier::new("list"), + Type::ListOf(Box::new(Type::Any)), + )]), + return_type: Some(Box::new(Type::Integer)), + } } - fn call( - self, - context: &Context, - manage_memory: bool, - ) -> Result, RuntimeError> { - let position = self.0.position(); - let evaluation = self.0.evaluate(context, manage_memory)?; - let value = if let Some(Evaluation::Return(value)) = evaluation { + fn call(context: &Context, manage_memory: bool) -> Result { + let value = if let Some(value) = context.get_value(&Identifier::new("input"))? { value } else { return Err(RuntimeError::ValidationFailure( - ValidationError::ExpectedExpression(position), + ValidationError::BuiltInFunctionFailure("input does not exist"), )); }; let list = if let ValueInner::List(list) = value.inner().as_ref() { list } else { return Err(RuntimeError::ValidationFailure( - ValidationError::ExpectedList { - actual: value.r#type(context)?, - position, - }, + ValidationError::BuiltInFunctionFailure("list is not a list"), )); }; - Ok(Some(Evaluation::Return(Value::integer(list.len() as i64)))) + Ok(Value::integer(list.len() as i64)) } } #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub struct ReadFile(Box); - -impl ReadFile { - pub fn new(expression: Expression) -> Self { - ReadFile(Box::new(expression)) - } -} +struct ReadFile; impl FunctionLogic for ReadFile { - fn return_type(&self, _: &Context) -> Result, ValidationError> { - Ok(Some(Type::String)) - } - - fn call(self, context: &Context, _: bool) -> Result, RuntimeError> { - if let Ok(Some(value)) = context.get_value(&Identifier::new("path")) { - if let ValueInner::String(path) = value.inner().as_ref() { - let file_content = read_to_string(path)?; - - return Ok(Some(Evaluation::Return(Value::string(file_content)))); - } + fn r#type() -> Type { + Type::Function { + type_parameters: None, + value_parameters: None, + return_type: None, } - - Err(RuntimeError::ValidationFailure( - ValidationError::BuiltInFunctionFailure(self.0.position()), - )) - } -} - -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub struct ReadLine; - -impl FunctionLogic for ReadLine { - fn return_type(&self, _: &Context) -> Result, ValidationError> { - Ok(Some(Type::String)) } - fn call(self, _: &Context, _: bool) -> Result, RuntimeError> { - let mut user_input = String::new(); - - stdin().read_line(&mut user_input)?; - - Ok(Some(Evaluation::Return(Value::string( - user_input.trim_end_matches('\n'), - )))) - } -} - -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub struct Sleep(Box); - -impl Sleep { - pub fn new(expression: Expression) -> Self { - Sleep(Box::new(expression)) - } -} - -impl FunctionLogic for Sleep { - fn return_type(&self, _: &Context) -> Result, ValidationError> { - Ok(None) - } - - fn call(self, _: &Context, _: bool) -> Result, RuntimeError> { + fn call(context: &Context, manage_memory: bool) -> Result { todo!() } } #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub struct WriteLine(Box); +struct ReadLine; -impl WriteLine { - pub fn new(expression: Expression) -> Self { - WriteLine(Box::new(expression)) - } -} - -impl FunctionLogic for WriteLine { - fn return_type(&self, _: &Context) -> Result, ValidationError> { - Ok(None) +impl FunctionLogic for ReadLine { + fn r#type() -> Type { + Type::Function { + type_parameters: None, + value_parameters: None, + return_type: None, + } } - fn call( - self, - context: &Context, - manage_memory: bool, - ) -> Result, RuntimeError> { - let position = self.0.position(); - let evaluation = self.0.evaluate(context, manage_memory)?; - let value = if let Some(Evaluation::Return(value)) = evaluation { - value - } else { - return Err(RuntimeError::ValidationFailure( - ValidationError::ExpectedExpression(position), - )); - }; - - println!("{value}"); - - Ok(None) + fn call(context: &Context, manage_memory: bool) -> Result { + todo!() } } #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] -pub struct JsonParse(TypeConstructor, Box); +struct Sleep; -impl JsonParse { - pub fn new(constructor: TypeConstructor, expression: Expression) -> Self { - JsonParse(constructor, Box::new(expression)) +impl FunctionLogic for Sleep { + fn r#type() -> Type { + Type::Function { + type_parameters: None, + value_parameters: None, + return_type: None, + } + } + + fn call(context: &Context, manage_memory: bool) -> Result { + todo!() } } -impl FunctionLogic for JsonParse { - fn return_type(&self, context: &Context) -> Result, ValidationError> { - self.0.construct(context).map(|r#type| Some(r#type)) +#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] +struct WriteLine; + +impl FunctionLogic for WriteLine { + fn r#type() -> Type { + Type::Function { + type_parameters: None, + value_parameters: None, + return_type: None, + } } - fn call( - self, - context: &Context, - manage_memory: bool, - ) -> Result, RuntimeError> { - let target_type = self.0.construct(context)?; - let position = self.1.position(); - let evaluation = self.1.evaluate(context, manage_memory)?; - let value = if let Some(Evaluation::Return(value)) = evaluation { + fn call(context: &Context, manage_memory: bool) -> Result { + todo!() + } +} + +#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] +struct JsonParse; + +impl FunctionLogic for JsonParse { + fn r#type() -> Type { + Type::Function { + type_parameters: None, + value_parameters: None, + return_type: None, + } + } + + fn call(context: &Context, manage_memory: bool) -> Result { + let target_type = if let Some(r#type) = context.get_type(&Identifier::new("T"))? { + r#type + } else { + return Err(RuntimeError::ValidationFailure( + ValidationError::BuiltInFunctionFailure("T does not exist"), + )); + }; + let value = if let Some(value) = context.get_value(&Identifier::new("input"))? { value } else { return Err(RuntimeError::ValidationFailure( - ValidationError::ExpectedExpression(position), + ValidationError::BuiltInFunctionFailure("input does not exist"), )); }; let input = if let ValueInner::String(string) = value.inner().as_ref() { string } else { return Err(RuntimeError::ValidationFailure( - ValidationError::ExpectedString { - actual: value.r#type(context)?, - position, - }, + ValidationError::BuiltInFunctionFailure("input is not a string"), )); }; @@ -279,8 +216,6 @@ impl FunctionLogic for JsonParse { Ok(value) } - let value = parse_value(&input, target_type)?; - - Ok(Some(Evaluation::Return(value))) + parse_value(&input, target_type) } } diff --git a/dust-lang/src/abstract_tree/expression.rs b/dust-lang/src/abstract_tree/expression.rs index 13cb0c6..91f4444 100644 --- a/dust-lang/src/abstract_tree/expression.rs +++ b/dust-lang/src/abstract_tree/expression.rs @@ -7,14 +7,13 @@ use crate::{ }; use super::{ - AbstractNode, As, BuiltInFunctionCall, Evaluation, FunctionCall, ListIndex, Logic, MapIndex, - Math, SourcePosition, Type, ValueNode, WithPosition, + AbstractNode, As, Evaluation, FunctionCall, ListIndex, Logic, MapIndex, Math, SourcePosition, + Type, ValueNode, WithPosition, }; #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)] pub enum Expression { As(WithPosition>), - BuiltIn(WithPosition), FunctionCall(WithPosition), Identifier(WithPosition), MapIndex(WithPosition>), @@ -35,7 +34,6 @@ impl Expression { Expression::Logic(inner) => inner.position, Expression::Math(inner) => inner.position, Expression::Value(inner) => inner.position, - Expression::BuiltIn(inner) => inner.position, } } } @@ -46,7 +44,6 @@ impl AbstractNode for Expression { match self { Expression::As(inner) => inner.node.define_types(_context), - Expression::BuiltIn(inner) => inner.node.define_types(_context), Expression::FunctionCall(inner) => inner.node.define_types(_context), Expression::Identifier(_) => Ok(()), Expression::MapIndex(inner) => inner.node.define_types(_context), @@ -62,9 +59,6 @@ impl AbstractNode for Expression { match self { Expression::As(r#as) => r#as.node.validate(context, manage_memory), - Expression::BuiltIn(built_in_function_call) => { - built_in_function_call.node.validate(context, manage_memory) - } Expression::FunctionCall(function_call) => { function_call.node.validate(context, manage_memory) } @@ -123,9 +117,6 @@ impl AbstractNode for Expression { Expression::Logic(logic) => logic.node.evaluate(context, manage_memory), Expression::Math(math) => math.node.evaluate(context, manage_memory), Expression::Value(value_node) => value_node.node.evaluate(context, manage_memory), - Expression::BuiltIn(built_in_function_call) => { - built_in_function_call.node.evaluate(context, manage_memory) - } } } @@ -150,9 +141,6 @@ impl AbstractNode for Expression { Expression::Logic(logic) => logic.node.expected_type(_context), Expression::Math(math) => math.node.expected_type(_context), Expression::Value(value_node) => value_node.node.expected_type(_context), - Expression::BuiltIn(built_in_function_call) => { - built_in_function_call.node.expected_type(_context) - } } } } diff --git a/dust-lang/src/abstract_tree/mod.rs b/dust-lang/src/abstract_tree/mod.rs index be27604..bbbf878 100644 --- a/dust-lang/src/abstract_tree/mod.rs +++ b/dust-lang/src/abstract_tree/mod.rs @@ -33,7 +33,7 @@ pub use self::{ assignment::{Assignment, AssignmentOperator}, async_block::AsyncBlock, block::Block, - built_in_function::BuiltInFunctionCall, + built_in_function::BuiltInFunction, enum_declaration::{EnumDeclaration, EnumVariant}, expression::Expression, function_call::FunctionCall, diff --git a/dust-lang/src/abstract_tree/value_node.rs b/dust-lang/src/abstract_tree/value_node.rs index 9ae716d..2dcd73d 100644 --- a/dust-lang/src/abstract_tree/value_node.rs +++ b/dust-lang/src/abstract_tree/value_node.rs @@ -10,12 +10,14 @@ use crate::{ }; use super::{ - AbstractNode, Block, Evaluation, Expression, Type, TypeConstructor, WithPos, WithPosition, + AbstractNode, Block, BuiltInFunction, Evaluation, Expression, Type, TypeConstructor, WithPos, + WithPosition, }; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub enum ValueNode { Boolean(bool), + BuiltInFunction(BuiltInFunction), EnumInstance { type_name: WithPosition, variant: WithPosition, @@ -239,7 +241,7 @@ impl AbstractNode for ValueNode { fn evaluate( self, context: &Context, - _manage_memory: bool, + manage_memory: bool, ) -> Result, RuntimeError> { let value = match self { ValueNode::Boolean(boolean) => Value::boolean(boolean), @@ -253,7 +255,7 @@ impl AbstractNode for ValueNode { for expression in expressions { let position = expression.position(); - let evaluation = expression.evaluate(context, _manage_memory)?; + let evaluation = expression.evaluate(context, manage_memory)?; if let Some(Evaluation::Return(value)) = evaluation { values.push(value); @@ -277,7 +279,7 @@ impl AbstractNode for ValueNode { for expression in expression_list { let position = expression.position(); - let evaluation = expression.evaluate(context, _manage_memory)?; + let evaluation = expression.evaluate(context, manage_memory)?; let value = if let Some(Evaluation::Return(value)) = evaluation { value } else { @@ -296,7 +298,7 @@ impl AbstractNode for ValueNode { for (identifier, _type, expression) in property_list { let position = expression.position(); - let evaluation = expression.evaluate(context, _manage_memory)?; + let evaluation = expression.evaluate(context, manage_memory)?; let value = if let Some(Evaluation::Return(value)) = evaluation { value } else { @@ -355,7 +357,7 @@ impl AbstractNode for ValueNode { for (identifier, expression) in expressions { let position = expression.position(); - let evaluation = expression.evaluate(context, _manage_memory)?; + let evaluation = expression.evaluate(context, manage_memory)?; let value = if let Some(Evaluation::Return(value)) = evaluation { value } else { @@ -369,6 +371,9 @@ impl AbstractNode for ValueNode { Value::structure(name, fields) } + ValueNode::BuiltInFunction(built_in_function) => { + built_in_function.call(context, manage_memory)? + } }; Ok(Some(Evaluation::Return(value))) @@ -488,6 +493,7 @@ impl AbstractNode for ValueNode { .collect(), } } + ValueNode::BuiltInFunction(built_in_function) => built_in_function.r#type(), }; Ok(Some(r#type)) @@ -612,6 +618,8 @@ impl Ord for ValueNode { } } (Structure { .. }, _) => Ordering::Greater, + (BuiltInFunction(left), BuiltInFunction(right)) => left.cmp(right), + (BuiltInFunction(_), _) => Ordering::Greater, } } } diff --git a/dust-lang/src/error.rs b/dust-lang/src/error.rs index e06d4a3..de04628 100644 --- a/dust-lang/src/error.rs +++ b/dust-lang/src/error.rs @@ -103,7 +103,7 @@ impl PartialEq for RuntimeError { #[derive(Debug, PartialEq)] pub enum ValidationError { - BuiltInFunctionFailure(SourcePosition), + BuiltInFunctionFailure(&'static str), CannotAssignToNone(SourcePosition), CannotIndex { r#type: Type, diff --git a/dust-lang/src/parser/mod.rs b/dust-lang/src/parser/mod.rs index 226ecc9..ae3eee1 100644 --- a/dust-lang/src/parser/mod.rs +++ b/dust-lang/src/parser/mod.rs @@ -13,9 +13,7 @@ use crate::{ }; use self::{ - built_in_function::{ - BuiltInFunctionCall, JsonParse, Length, ReadFile, ReadLine, Sleep, WriteLine, - }, + built_in_function::BuiltInFunction, enum_declaration::EnumVariant, type_constructor::{RawTypeConstructor, TypeInvokationConstructor}, }; @@ -375,60 +373,50 @@ pub fn parser<'src>( ) }); - let _built_in_function = |keyword| { + let underscored = |keyword| { just(Token::Keyword(keyword)).delimited_by( just(Token::Symbol(Symbol::DoubleUnderscore)), just(Token::Symbol(Symbol::DoubleUnderscore)), ) }; - let built_in_function_call = choice(( - _built_in_function(Keyword::Length) - .ignore_then(expression.clone()) - .map_with(|argument, state| { - Expression::BuiltIn( - BuiltInFunctionCall::Length(Length::new(argument)) - .with_position(state.span()), - ) - }), - _built_in_function(Keyword::ReadFile) - .ignore_then(expression.clone()) - .map_with(|argument, state| { - Expression::BuiltIn( - BuiltInFunctionCall::ReadFile(ReadFile::new(argument)) - .with_position(state.span()), - ) - }), - _built_in_function(Keyword::ReadLine).map_with(|_, state| { - Expression::BuiltIn( - BuiltInFunctionCall::ReadLine(ReadLine).with_position(state.span()), + let built_in_function = choice(( + underscored(Keyword::Length).map_with(|_, state| { + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::Length) + .with_position(state.span()), + ) + }), + underscored(Keyword::ReadLine).map_with(|_, state| { + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::ReadLine) + .with_position(state.span()), + ) + }), + underscored(Keyword::ReadFile).map_with(|_, state| { + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::ReadFile) + .with_position(state.span()), + ) + }), + underscored(Keyword::Sleep).map_with(|_, state| { + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::Sleep) + .with_position(state.span()), + ) + }), + underscored(Keyword::WriteLine).map_with(|_, state| { + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::WriteLine) + .with_position(state.span()), + ) + }), + underscored(Keyword::JsonParse).map_with(|_, state| { + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::JsonParse) + .with_position(state.span()), ) }), - _built_in_function(Keyword::Sleep) - .ignore_then(expression.clone()) - .map_with(|argument, state| { - Expression::BuiltIn( - BuiltInFunctionCall::Sleep(Sleep::new(argument)) - .with_position(state.span()), - ) - }), - _built_in_function(Keyword::WriteLine) - .ignore_then(expression.clone()) - .map_with(|argument, state| { - Expression::BuiltIn( - BuiltInFunctionCall::WriteLine(WriteLine::new(argument)) - .with_position(state.span()), - ) - }), - _built_in_function(Keyword::JsonParse) - .ignore_then(type_constructor.clone()) - .then(expression.clone()) - .map_with(|(constructor, argument), state| { - Expression::BuiltIn( - BuiltInFunctionCall::JsonParse(JsonParse::new(constructor, argument)) - .with_position(state.span()), - ) - }), )) .validate(move |expression, state, emitter| { if !allow_built_ins { @@ -456,6 +444,7 @@ pub fn parser<'src>( ); let atom = choice(( + built_in_function.clone(), enum_instance.clone(), range.clone(), function.clone(), @@ -646,8 +635,8 @@ pub fn parser<'src>( )); choice(( - built_in_function_call, logic_math_indexes_as_and_function_calls, + built_in_function, enum_instance, range, function, diff --git a/dust-lang/src/parser/tests.rs b/dust-lang/src/parser/tests.rs index bf21431..bad00fe 100644 --- a/dust-lang/src/parser/tests.rs +++ b/dust-lang/src/parser/tests.rs @@ -270,15 +270,15 @@ fn built_in_function() { assert_eq!( statements[0], - Statement::Expression(Expression::BuiltIn( - BuiltInFunctionCall::ReadLine(ReadLine).with_position((0, 13)) + Statement::Expression(Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::ReadLine).with_position((0, 13)) )) ); } #[test] fn built_in_function_with_arg() { - let tokens = lex("__WRITE_LINE__ 'hiya'").unwrap(); + let tokens = lex("__WRITE_LINE__('hiya')").unwrap(); let statements = parser(true) .parse(tokens.spanned((tokens.len()..tokens.len()).into())) .into_result() @@ -292,11 +292,17 @@ fn built_in_function_with_arg() { assert_eq!( statements[0], - Statement::Expression(Expression::BuiltIn( - BuiltInFunctionCall::WriteLine(WriteLine::new(Expression::Value( - ValueNode::String("hiya".to_string()).with_position((15, 21)) - ))) - .with_position((0, 21)) + Statement::Expression(Expression::FunctionCall( + FunctionCall::new( + Expression::Value( + ValueNode::BuiltInFunction(BuiltInFunction::WriteLine).with_position((0, 14)) + ), + None, + Some(vec![Expression::Value( + ValueNode::String("hiya".to_string()).with_position((15, 21)) + )]) + ) + .with_position((0, 22)) )) ); } diff --git a/dust-lang/src/value.rs b/dust-lang/src/value.rs index acc7148..e37d393 100644 --- a/dust-lang/src/value.rs +++ b/dust-lang/src/value.rs @@ -14,7 +14,7 @@ use serde::{ }; use crate::{ - abstract_tree::{AbstractNode, Block, Evaluation, Type, WithPosition}, + abstract_tree::{AbstractNode, Block, BuiltInFunction, Evaluation, Type, WithPosition}, context::Context, error::{PoisonError, RuntimeError, ValidationError}, identifier::Identifier, @@ -214,6 +214,7 @@ impl Display for Value { write!(f, "}}") } + ValueInner::BuiltInFunction(_) => todo!(), } } } @@ -305,6 +306,7 @@ impl Serialize for Value { struct_ser.end() } + ValueInner::BuiltInFunction(_) => todo!(), } } } @@ -554,6 +556,7 @@ impl<'de> Deserialize<'de> for Value { #[derive(Clone, Debug, PartialEq)] pub enum ValueInner { Boolean(bool), + BuiltInFunction(BuiltInFunction), EnumInstance { type_name: Identifier, variant: Identifier, @@ -628,6 +631,7 @@ impl ValueInner { }); } } + ValueInner::BuiltInFunction(_) => todo!(), }; Ok(r#type) @@ -717,6 +721,8 @@ impl Ord for ValueInner { } } (Structure { .. }, _) => Ordering::Greater, + (BuiltInFunction(left), BuiltInFunction(right)) => left.cmp(right), + (BuiltInFunction(_), _) => Ordering::Greater, } } } diff --git a/examples/json_length.ds b/examples/json_length.ds index e82e2c2..81a32fc 100644 --- a/examples/json_length.ds +++ b/examples/json_length.ds @@ -1,8 +1,3 @@ -/* - This is is simple program to get the length of a json array. - - Use `cargo run --package dust-shell examples/json_length.ds` -*/ input = fs.read_file('examples/assets/data.json') data = json.parse(input) diff --git a/std/core.ds b/std/core.ds index c7b7009..bb1012b 100644 --- a/std/core.ds +++ b/std/core.ds @@ -1,3 +1,3 @@ length = fn (list: [any]) -> int { - __LENGTH__ list + __LENGTH__(list) } diff --git a/std/fs.ds b/std/fs.ds index 18e0395..536cab4 100644 --- a/std/fs.ds +++ b/std/fs.ds @@ -1,5 +1,5 @@ fs = { read_file = fn (path: str) -> str { - __READ_FILE__ path + __READ_FILE__(path) } }