Worked on more documentation but somehow parent files got screwed up

Author: BigBadE

Cargo.toml

@@ -14,7 +14,4 @@ members = [
     "tools/ide-plugins/raven-intellij-natives",
     "tools/ide-plugins/raven-language-server"
 ]
-
-exclude = [
-    "crates/chalk"
-]
+resolver = "2"

LICENSE

@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -4,23 +4,20 @@ Raven is an experimental language bringing modern features to every platform.
 
 Raven's goal is to allow one codebase to run on every platform, without having to sacrifice speed or usability.
 
-Currently, Raven mainly targets desktop applications, but web, mobile, and JVM targets are planned.
+Currently, Raven targets desktop applications, but web, mobile, and JVM targets are planned.
 
-# !!! DO NOT DOWNLOAD RAVEN ANYWHERE WITH A SPACE IN THE PATH. EX: "C:/Program Files/Raven". IT WILL NOT WORK. I CANNOT FIX IT !!!
+# Installing
 
-# Building
+For help on installing Raven, look at the [first chapter of the Raven book](docs/raven/1_installation.md)
 
-Requires LLVM set with the environmental variable LLVM_SYS_130_PREFIX = (path to folder with bin)
+# Contributing
 
-Please download LLVM from https://github.com/PLC-lang/llvm-package-windows/releases/tag/v13.0.0
+If your interested in contributing, look at [the current Raven projects](projects.md).
+More information can be found in the [building.md file](docs/building.md)
 
-C++ is also required to be installed somewhere on your system, for Windows get it from https://visualstudio.microsoft.com/vs/community/
+Please read the [contributing guidelines](contributing.md) before contributing.
 
-Nightly is required for building the compiler, you can set the project to nightly with ```rustup override set nightly```
+# Documentation
+For the documentation on the Raven language, look at the [Raven book in the raven folder](raven/raven.md)
 
-# Running
-
-Run this in the lib/test folder (or whatever Raven project in the repository you want to run)
-```cargo run --bin magpie```
-
-That command will build and run Raven's CLI with the following options
+For crate-level, file-level, and function-level documentation over the Raven internals, look at the source itself in the language folder. You can also find a helpful document going over internals in [language/README.md](language/README.md)

docs/building.md

@@ -0,0 +1,24 @@
+# !!! DO NOT DOWNLOAD RAVEN ANYWHERE WITH A SPACE IN THE PATH. EX: "C:/Program Files/Raven". IT WILL NOT WORK. I CANNOT FIX IT !!!
+
+This project requires the latest Rust download. Download it using Rustup from https://www.rust-lang.org/tools/install
+
+# Building
+
+Requires LLVM set with the environmental variable LLVM_SYS_130_PREFIX = (path to folder with bin)
+
+Please download LLVM from https://github.com/PLC-lang/llvm-package-windows/releases/tag/v13.0.0
+
+C++ is also required to be installed somewhere on your system, for Windows get it from https://visualstudio.microsoft.com/vs/community/.
+By default, Rustup should install this for you.
+
+Nightly is required for building the compiler, you can set the project to nightly with ```rustup override set nightly```
+
+# Running
+
+Run this in the lib/test folder (or whatever Raven project in the repository you want to run)
+```cargo run --bin magpie```
+
+That command will build and run Magpie in that folder, which will run the project there.
+
+Magpie can also be passed individual files, for example you can run this from the root folder:
+```cargo run --bin magpie lib/test/src/main.rv```

docs/contributing.md

@@ -0,0 +1,22 @@
+# Contributing Guidelines
+
+# Licensing
+
+This repository is under the MIT License. By contributing to this project, any contributions you make are also under the MIT License. 
+The full license terms are in the LICENSE file. The license simply allows free copying, distribution, modification, publishing, sublicensing, merging, or selling your code.
+Basically, you have no right to prevent others from doing whatever they want with the code.
+However, the license also prevents you from taking any responsibility over how the code is used, and you are not liable for any damage cuased.
+
+# Contributors
+
+All contributors without direct write access must make contributions to their own forks and open a pull request for code review.
+
+All contributions will automatically be checked by the CI. This will let you know if anything is broken, but you should test all code you write.
+
+# Style
+
+The repository follows the Rust style, with: 
+- snake_case method, file, variable, and folder names
+- CamelCase structure names 
+
+When in doubt, follow the established code style found in the source.

docs/index.md

@@ -0,0 +1,11 @@
+# Welcome to the Raven documentation!
+
+This folder contains all the documentation over the Raven project and everything associated with Raven.
+
+If your interested in contributing, look at [the current Raven projects](projects.md).
+
+For the documentation on the Raven language, look at the [Raven book in the raven folder](raven/raven.md)
+
+Please read the [contributing guidelines](contributing.md) before contributing.
+
+For crate-level, file-level, and function-level documentation over the Raven internals, look at the source itself in the language folder. You can also find a helpful document going over internals in [language/README.md](../language/README.md)

docs/projects.md

@@ -0,0 +1,24 @@
+# Core
+The core is the base compiler of Raven (written in Rust), most work is fixing issues with the language itself and adding new features.
+
+This is in the language folder of the base repository
+
+# Magpie
+Magpie is Raven's build tool, dependency manager, and version control. It is currently lacking most functionality.
+
+This is in the tools/magpie folder of the base repository
+
+# IDE Extensions / Raven Language Server
+This provides support to various IDEs such as VSCode and implementing features like syntax highlighting. It's a mix of Rust (Raven Language Server), NodeJS (VSCode), and Java (IntelliJ)
+
+This is in the tools/ide-plugins folder of the base repository
+
+# Website
+This is the main page for Raven.
+
+The source is in the website folder of the base repository The website is on the gh-pages branch of the base repository
+
+# Standard Library
+This is the standard library of Raven for every platform it supports. It's divided into a platform-specific std, and a universal std, which calls the platform std.
+
+This is in the lib folder of the base repository

docs/raven/1_installation.md

@@ -0,0 +1,35 @@
+# Installation
+
+The best way to install Raven without building from source is through Magpie.
+
+Raven comes with a helper program called "Magpie Wrapper" that will automatically keep the language up to date.
+
+To install the latest Magpie or Magpie Wrapper, check out https://github.com/BigBadE/Raven-Language/releases/tag/nightly.
+
+Follow the instructions on the release page to install the wrapper and run it.
+
+# Running
+
+Magpie can either run a project or a single file. 
+
+Running a project requires following the project format, a commented example can be found in the lib/test folder.
+
+Running a single file just requires a .rv file with a main function. This file will provide examples you can run by copying them into a file
+and running it with Magpie.
+
+An example of running a single file:
+```magpie my_file.rv```
+
+This will run the file named my_file.rv.
+
+To confirm your installation is working, try running the following Hello World! example:
+
+```
+import stdio;
+
+fn main() {
+    printf("Hello World!");
+}
+```
+
+For more information over how this example works, check out [Chapter 2: Getting Started](2_getting_started.md)

docs/raven/2_getting_started.md

@@ -0,0 +1,49 @@
+# Getting Started - Types
+
+Types are the backbone of Raven. Every single variable has a type, so types will be covered to help understand variables.
+
+Raven comes with a few built in types, but it's most important to know the "primtives", basic types that all other types are built off of. 
+They are the following:
+
+- Unsigned Integers:
+Unsigned integers are an integer (whole number) with no sign (positive). There are 4 of them: ``u8``, ``u16``, ``u32``, and ``u64``.
+The u stands for unsigned, and the number after is the amount of bits the number has. To understand what the number of bits mean,
+it's worth reviewing binary. Keep in mind, if you try to go below 0, unsigned integers will underflow to the maximum number.
+Likewise, if you go over the maximum number, the number will overflow to 0.
+- Signed Integers:
+Signed integers have less range than unsigned integers, but they can be negative. There are also 4 of them: ``i8``, ``i16``, ``i32``, and ``i64``.
+The numbers mean the same thing, and i stands for signed.
+- Booleans:
+There is only one boolean type, ``bool``, which can be the value ``true`` or ``false``.
+- Floats:
+There are two float types, ``f32`` or ``f64``. Floats, unlike integers, can have decimals. Floats also have a gigantic range,
+but it's important to know the drawbacks of floats: Floats are imprecise. Because they're restricted to 32 or 64 bits, they can't
+represent every single number. Floats should never be directly compared because they may not precisely be the expected value.
+- Strings:
+Strings are unique because they can have a variables size. There is only one type, ``str``, but it can be one letter ("a")
+or a full sentence ("Hello World!", as seen earlier). That's why a ``str`` isn't mutable. Any operation you do on a ``str``
+actually creates a new type.
+
+Now that you've learned the basics, lets move on to actually using those types:
+
+# Variables
+
+Variables are a way to store data for later use. Let's write simple code to square a number:
+
+```
+fn main() {
+    let squaring = 2;
+    let squared = squaring * squaring;
+}
+```
+
+In this example the line ``let squaring = 2;`` sets the variable ``squaring`` equal to the ``u64`` ``2``.
+We can use this variable later, for example when we do ```let squared = squaring * squaring;``` which takes the ```squaring```
+variable and squares it by multiplying it by itself, then assigning it to ``squared``.
+
+So, reviewing what has been covered so far:
+- Every variable has a name and a type
+- Numbers are either unsigned, signed, or floats
+- Variables can be used like numbers with their name
+
+Now, lets move onto something a little different. [Chapter 3: Control Flow](3_control_flow.md)

docs/raven/3_control_flow.md

@@ -0,0 +1,82 @@
+# Control Flow
+
+Control Flow is how we use different statements to control the flow of the program. What does that mean? Well, lets look at an example:
+What if we wanted to run some code only if a number is less than 5? Let's try it:
+```
+import stdio;
+
+fn main() {
+    let value = 7;
+    if value < 5 {
+        printf("Yep!");
+    } else {
+        printf("Nope!");
+    }
+}
+```
+
+Let's run the code with various values:
+```
+value | output
+------+-------
+  7   | Nope!
+  6   | Nope!
+  5   | Nope!
+  4   | Yep!
+```
+
+So, if the value is less than 5, only the code in the ``if`` statement runs. If the value is greater than or equal to 5, than the code
+in the ``else`` statement runs. We can expand this with the ``else if`` statement:
+
+```
+import stdio;
+
+fn main() {
+    let value = 7;
+    if value < 5 {
+        printf("Yep!");
+    } else if value == 5 {
+        printf("Five!");
+    } else {
+        printf("Nope!");
+    }
+}
+```
+
+
+Let's run the code with the same values:
+```
+value | output
+------+-------
+  7   | Nope!
+  6   | Nope!
+  5   | Five!
+  4   | Yep!
+```
+
+Following alone with the code, we can label each statement:
+(This code will NOT compile, it is purely for comprehension)
+
+```
+import stdio;
+
+fn main() {
+    let value = 7;
+    1: if value < 5 {
+        printf("Yep!");
+    2: } else if value == 5 {
+        printf("Five!");
+    3: } else {
+        printf("Nope!");
+    }
+}
+```
+
+The logic is as follows:
+
+1 is checked. IF value is less than 5, THEN Yep! is printed and nothing else happens.
+2 is checked IF 1 failed. IF value equals 5, THEN Five! is printed and nothing else happens.
+IF 1 and 2 failed, THEN Nope! is printed and nothing else happens.
+
+If the logic doesn't make sense, feel free to mess around with the code on your own.
+

docs/raven/raven.md

@@ -15,42 +15,47 @@ use syntax::r#struct::VOID;
 use syntax::types::FinalizedTypes;
 use crate::output::TypesChecker;
 
-pub async fn verify_code(process_manager: &TypesChecker, resolver: &Box<dyn NameResolver>, code: CodeBody, external: bool,
-                         syntax: &Arc<Mutex<Syntax>>, variables: &mut SimpleVariableManager, references: bool) -> Result<FinalizedCodeBody, ParsingError> {
+pub async fn verify_code(process_manager: &TypesChecker, resolver: &Box<dyn NameResolver>, code: CodeBody,
+                         syntax: &Arc<Mutex<Syntax>>, variables: &mut SimpleVariableManager, references: bool, top: bool) -> Result<FinalizedCodeBody, ParsingError> {
     let mut body = Vec::new();
+    let mut found_end = false;
     for line in code.expressions {
+        match &line.effect {
+            Effects::CompareJump(_, _, _) => found_end = true,
+            Effects::Jump(_) => found_end = true,
+            _ => {}
+        }
+
         body.push(FinalizedExpression::new(line.expression_type,
                                            verify_effect(process_manager, resolver.boxed_clone(),
-                                                         line.effect, external, syntax, variables, references).await?));
+                                                         line.effect, syntax, variables, references).await?));
 
         if let ExpressionType::Return = line.expression_type {
-            if external {
-                //Load if the function is external
-                let effect = FinalizedEffects::ReferenceLoad(Box::new(body.pop().unwrap().effect));
-                body.push(FinalizedExpression::new(ExpressionType::Return, effect));
-            }
             return Ok(FinalizedCodeBody::new(body, code.label.clone(), true));
         }
     }
 
+    if !found_end && !top {
+        panic!("Code body with label {} doesn't return or jump!", code.label)
+    }
+
     return Ok(FinalizedCodeBody::new(body, code.label.clone(), false));
 }
 
 //IntelliJ seems to think the operation loop is unreachable for some reason.
 #[allow(unreachable_code)]
 #[async_recursion]
-async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameResolver>, effect: Effects, external: bool,
+async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameResolver>, effect: Effects,
                        syntax: &Arc<Mutex<Syntax>>, variables: &mut SimpleVariableManager, references: bool) -> Result<FinalizedEffects, ParsingError> {
     let output = match effect {
-        Effects::Paren(inner) => verify_effect(process_manager, resolver, *inner, external, syntax, variables, references).await?,
+        Effects::Paren(inner) => verify_effect(process_manager, resolver, *inner, syntax, variables, references).await?,
         Effects::CodeBody(body) =>
-            FinalizedEffects::CodeBody(verify_code(process_manager, &resolver, body, external,
-                                                   syntax, &mut variables.clone(), references).await?),
+            FinalizedEffects::CodeBody(verify_code(process_manager, &resolver, body, syntax, &mut variables.clone(), references, false).await?),
         Effects::Set(first, second) => {
             FinalizedEffects::Set(Box::new(
-                verify_effect(process_manager, resolver.boxed_clone(), *first, external, syntax, variables, references).await?),
+                verify_effect(process_manager, resolver.boxed_clone(), *first, syntax, variables, references).await?),
                                   Box::new(
-                                      verify_effect(process_manager, resolver, *second, external, syntax, variables, references).await?))
+                                      verify_effect(process_manager, resolver, *second, syntax, variables, references).await?))
         }
         Effects::Operation(operation, mut values) => {
             let error = ParsingError::new(String::new(), (0, 0), 0,
@@ -110,25 +115,25 @@ async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameRes
             verify_effect(process_manager, resolver,
                           Effects::ImplementationCall(calling, operation.name.clone(),
                                                       String::new(), values, None),
-                          external, syntax, variables, references).await?
+                          syntax, variables, references).await?
         }
         Effects::ImplementationCall(calling, traits, method, effects, returning) => {
             let mut finalized_effects = Vec::new();
             for effect in effects {
-                finalized_effects.push(verify_effect(process_manager, resolver.boxed_clone(), effect, external, syntax, variables, references).await?)
+                finalized_effects.push(verify_effect(process_manager, resolver.boxed_clone(), effect, syntax, variables, references).await?)
             }
 
             let return_type;
             if let Effects::NOP() = *calling {
                 return_type = FinalizedTypes::Struct(VOID.clone());
             } else {
-                let found = verify_effect(process_manager, resolver.boxed_clone(), *calling, external, syntax, variables, references).await?;
+                let found = verify_effect(process_manager, resolver.boxed_clone(), *calling, syntax, variables, references).await?;
                 return_type = found.get_return(variables).unwrap();
                 finalized_effects.insert(0, found);
             }
 
             if let Ok(inner) = Syntax::get_struct(syntax.clone(), placeholder_error(String::new()),
-                                                  traits, resolver.boxed_clone()).await {
+                                                  traits.clone(), resolver.boxed_clone()).await {
                 let mut output = None;
                 {
                     let mut result = None;
@@ -172,17 +177,17 @@ async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameRes
                 check_method(process_manager, method,
                              finalized_effects, syntax, variables, returning).await?
             } else {
-                panic!("Screwed up trait!");
+                panic!("Screwed up trait! {}", traits);
             }
         }
         Effects::MethodCall(calling, method, effects, returning) => {
             let mut finalized_effects = Vec::new();
             for effect in effects {
-                finalized_effects.push(verify_effect(process_manager, resolver.boxed_clone(), effect, external, syntax, variables, references).await?)
+                finalized_effects.push(verify_effect(process_manager, resolver.boxed_clone(), effect, syntax, variables, references).await?)
             }
 
             let method = if let Some(found) = calling {
-                let found = verify_effect(process_manager, resolver.boxed_clone(), *found, external, syntax, variables, references).await?;
+                let found = verify_effect(process_manager, resolver.boxed_clone(), *found, syntax, variables, references).await?;
                 let return_type = found.get_return(variables).unwrap();
 
                 if is_modifier(return_type.inner_struct().data.modifiers, Modifier::Trait) {
@@ -238,7 +243,7 @@ async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameRes
         }
         Effects::CompareJump(effect, first, second) =>
             FinalizedEffects::CompareJump(Box::new(
-                verify_effect(process_manager, resolver, *effect, external, syntax, variables, references).await?),
+                verify_effect(process_manager, resolver, *effect, syntax, variables, references).await?),
                                           first, second),
         Effects::CreateStruct(target, effects) => {
             let mut target = Syntax::parse_type(syntax.clone(), placeholder_error(format!("Test")),
@@ -262,20 +267,20 @@ async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameRes
                     return Err(placeholder_error(format!("Unknown field {}!", field_name)));
                 }
 
-                final_effects.push((i, verify_effect(process_manager, resolver.boxed_clone(), effect, external, syntax, variables, references).await?));
+                final_effects.push((i, verify_effect(process_manager, resolver.boxed_clone(), effect, syntax, variables, references).await?));
             }
 
             FinalizedEffects::CreateStruct(Some(Box::new(FinalizedEffects::HeapAllocate(target.clone()))),
                                            target, final_effects)
         }
         Effects::Load(effect, target) => {
-            let output = verify_effect(process_manager, resolver, *effect, external, syntax, variables, references).await?;
+            let output = verify_effect(process_manager, resolver, *effect, syntax, variables, references).await?;
 
             let types = output.get_return(variables).unwrap().inner_struct().clone();
             FinalizedEffects::Load(Box::new(output), target.clone(), types)
         }
         Effects::CreateVariable(name, effect) => {
-            let effect = verify_effect(process_manager, resolver, *effect, external, syntax, variables, references).await?;
+            let effect = verify_effect(process_manager, resolver, *effect, syntax, variables, references).await?;
             let found;
             if let Some(temp_found) = effect.get_return(variables) {
                 found = temp_found;
@@ -297,7 +302,7 @@ async fn verify_effect(process_manager: &TypesChecker, resolver: Box<dyn NameRes
             let mut output = Vec::new();
             for effect in effects {
                 output.push(verify_effect(process_manager, resolver.boxed_clone(), effect,
-                                          external, syntax, variables, references).await?);
+                                          syntax, variables, references).await?);
             }
 
             let types = output.get(0).map(|found| found.get_return(variables).unwrap());

language/checker/src/check_code.rs

@@ -4,7 +4,7 @@ use no_deadlocks::Mutex;
 #[cfg(not(debug_assertions))]
 use std::sync::Mutex;
 use syntax::function::{CodeBody, CodelessFinalizedFunction, FinalizedCodeBody, FinalizedFunction, UnfinalizedFunction};
-use syntax::{Attribute, SimpleVariableManager, is_modifier, Modifier, ParsingError};
+use syntax::{SimpleVariableManager, is_modifier, Modifier, ParsingError};
 use syntax::async_util::NameResolver;
 use syntax::code::{ExpressionType, FinalizedEffects, FinalizedExpression, FinalizedField, FinalizedMemberField};
 use syntax::syntax::Syntax;
@@ -67,12 +67,8 @@ pub async fn verify_function_code(process_manager: &TypesChecker, resolver: Box<
 
     let mut variable_manager = SimpleVariableManager::for_function(&codeless);
 
-    let mut code = verify_code(process_manager, &resolver, code, codeless.data.attributes.iter()
-        .any(|inner| if let Attribute::Basic(inner) = inner {
-            inner == "extern"
-        } else {
-            false
-        }), syntax, &mut variable_manager, include_refs).await?;
+    let mut code = verify_code(process_manager, &resolver, code, syntax,
+                               &mut variable_manager, include_refs, true).await?;
 
     if !code.returns {
         if codeless.return_type.is_none() {

language/checker/src/check_function.rs

@@ -15,7 +15,7 @@ pub fn parse_operator(last: Option<Effects>, parser_utils: &mut ParserUtils, sta
 
     parser_utils.index -= 1;
     while let Some(token) = parser_utils.tokens.get(parser_utils.index) {
-        if token.token_type == TokenTypes::Operator || token.token_type == TokenTypes::Equals {
+        if token.token_type == TokenTypes::Operator || token.token_type == TokenTypes::Equals || token.token_type == TokenTypes::Period {
             operation += token.to_string(parser_utils.buffer).as_str();
         } else {
             break

language/parser/src/parser/operator_parser.rs

@@ -72,7 +72,7 @@ pub fn parse_top(parser_utils: &mut ParserUtils) {
             TokenTypes::EOF => return,
             _ => panic!("How'd you get here? {}: {:?} index {} ({:?})", parser_utils.file, token.token_type, parser_utils.index,
                         parser_utils.tokens[parser_utils.index-6..parser_utils.index-1].iter()
-                            .map(|token| token.to_string(parser_utils.buffer)).collect::<Vec<_>>())
+                            .map(|token| format!("{} ({:?})", token.to_string(parser_utils.buffer), token.token_type)).collect::<Vec<_>>())
         }
     }
 }

language/parser/src/parser/top_parser.rs

@@ -99,6 +99,13 @@ impl<T: TopElement> Future for AsyncTypesGetter<T> {
             return Poll::Ready(output);
         }
 
+        // Check if a structure within the parent type with that name exists.
+        let parent = self.name_resolver.parent().clone();
+        if let Some(output) = self.get_types(&mut locked,
+                                             parent, cx.waker().clone(), not_trait) {
+            return Poll::Ready(output);
+        }
+
         // Check each import if the structure is in those files.
         for import in self.name_resolver.imports().clone() {
             if let Some(output) = self.get_types(&mut locked,
@@ -109,6 +116,7 @@ impl<T: TopElement> Future for AsyncTypesGetter<T> {
 
         // If the async manager is finished, return an error.
         if locked.async_manager.finished {
+            println!("Error {}", self.error);
             return Poll::Ready(Err(self.error.clone()));
         }
 

language/syntax/src/async_util.rs

@@ -283,6 +283,7 @@ impl FinalizedFunction {
 }
 
 /// A body of code, each body must have a label for jump effects to jump to.
+/// ! Each nested CodeBody MUST have a jump or return or else the compiler will error !
 #[derive(Clone, Default, Debug)]
 pub struct CodeBody {
     pub label: String,

language/syntax/src/function.rs

@@ -23,15 +23,16 @@ use crate::syntax::Syntax;
 /// For example, "test" is a Struct called str, which is an internal type.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Types {
-    //A basic struct
+    // A basic struct
     Struct(Arc<StructData>),
-    //A type with generic types
+    // A type with generic types. For example, List<T> is GenericType with a base struct (List) and bounds T.
+    // This List<T> will be degeneric'd into a type (for example, List<String>) then solidified.
     GenericType(Box<Types>, Vec<Types>),
-    //A reference to a type
+    // A reference to a type
     Reference(Box<Types>),
-    //A generic with bounds
+    // A generic with bounds
     Generic(String, Vec<Types>),
-    //An array
+    // An array
     Array(Box<Types>),
 }
 
@@ -333,7 +334,7 @@ impl FinalizedTypes {
     /// Flattens GenericTypes into a Structure, degenericing them.
     #[async_recursion]
     pub async fn flatten(&mut self, generics: &mut Vec<FinalizedTypes>, syntax: &Arc<Mutex<Syntax>>) -> Result<FinalizedTypes, ParsingError> {
-        // Flatten the arguments to this generic type.
+        // Flatten the arguments to this GenericType.
         for generic in &mut *generics {
             if let FinalizedTypes::GenericType(base, bounds) = generic {
                 *generic = base.flatten(bounds, syntax).await?;

language/syntax/src/types.rs

@@ -11,13 +11,26 @@ pub struct NumberIter {
 
 impl Iter<u64> for NumberIter {
     pub fn next(self) -> u64 {
-        //self.current = self.current + 1;
-        //return self.current - 1;
-        return 0;
+        self.current = self.current + 1;
+        return self.current - 1;
     }
 
     pub fn has_next(self) -> bool {
-        //return self.current != self.end;
-        return false;
+        return self.current != self.end;
+    }
+}
+
+#[priority(-1)]
+#[operation({}..{})]
+trait Range<T> {
+    fn range(self, other: T) -> Iter<T>;
+}
+
+impl Range<u64> for u64 {
+    fn range(self, other: u64) -> Iter<T> {
+        return new NumberIter {
+            current: self,
+            end: other,
+        };
     }
 }

lib/core/src/iter.rv

@@ -1,11 +1,13 @@
-import main::Test;
+import iter::NumberIter;
 import stdio;
 
 fn main() {
-    let i = 0;
-    while i != 5 {
+    let iter = new NumberIter {
+        current: 0,
+        end: 5,
+    };
+    for i in iter {
         printf("Loop!");
-        i = i + 1;
     }
     printf("Done!");
 }