Dev/v1

.gitignore

@@ -398,3 +398,4 @@ FodyWeavers.xsd
 *.sln.iml
 
 .lh/
+/ZSharpTest/test.zs

CommonZ/CommonZ.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

CommonZ/IResult.cs

@@ -0,0 +1,32 @@
+public interface IResult<out TResult, out TError>
+        where TResult : class?
+        where TError : class
+{
+    public bool IsOk { get; }
+
+    public bool IsError { get; }
+
+    public TResult Unwrap();
+
+    public TError UnwrapError();
+
+    public IResult<TResult, TError> When(Action<TResult> action)
+    {
+        if (this.Ok(out var result))
+            action(result);
+
+        return this;
+    }
+
+    public IResult<R, TError> When<R>(Func<TResult, R> map) where R : class;
+
+    public IResult<TResult, TError> Else(Action<TError> action)
+    {
+        if (this.Error(out var error))
+            action(error);
+
+        return this;
+    }
+
+    public IResult<TResult, E> Else<E>(Func<TError, E> map) where E : class;
+}

CommonZ/Result.cs

@@ -0,0 +1,47 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace CommonZ
+{
+    public sealed class Result<TResult, TError>
+        : IResult<TResult, TError>
+        where TResult : class?
+        where TError : class
+    {
+        private readonly TResult? result;
+        private readonly TError? error;
+
+        [MemberNotNullWhen(true, nameof(result))]
+        public bool IsOk => result is not null;
+
+        [MemberNotNullWhen(true, nameof(error))]
+        public bool IsError => error is not null;
+
+        private Result(TResult? result, TError? error)
+        {
+            this.result = result;
+            this.error = error;
+        }
+
+        public static Result<TResult, TError> Ok(TResult result)
+            => new(result, null);
+
+        public static Result<TResult, TError> Error(TError error)
+            => new(null, error);
+
+        TResult IResult<TResult, TError>.Unwrap()
+            => result ?? throw new InvalidOperationException(error!.ToString());
+
+        TError IResult<TResult, TError>.UnwrapError()
+            => error ?? throw new InvalidOperationException("Result is Ok");
+
+        IResult<R, TError> IResult<TResult, TError>.When<R>(Func<TResult, R> map)
+            => IsOk
+                ? Result<R, TError>.Ok(map(result))
+                : Result<R, TError>.Error(error!);
+
+        IResult<TResult, E> IResult<TResult, TError>.Else<E>(Func<TError, E> map)
+            => IsOk
+                ? Result<TResult, E>.Ok(result)
+                : Result<TResult, E>.Error(map(error!));
+    }
+}

CommonZ/collections/CacheBase.cs

@@ -12,10 +12,13 @@ public abstract class CacheBase<Key, Value>
 
         public Cache<Key, Value>? Parent { get; set; }
 
-        public T Cache<T>(Key key, T value)
+        public T Cache<T>(Key key, T value, bool set = false)
             where T : Value
         {
-            _cache.Add(key, value);
+            if (set)
+                _cache[key] = value;
+            else
+                _cache.Add(key, value);
             return value;
         }
 

CommonZ/collections/Mapping.cs

@@ -3,6 +3,12 @@
     public class Mapping<Key, Value> : Dictionary<Key, Value>
         where Key : notnull
     {
+        public Mapping() : base() { }
+
+        public Mapping(IDictionary<Key, Value> dictionary) : base(dictionary) { }
+
+        public Mapping(IEnumerable<KeyValuePair<Key, Value>> items) : base(items) { }
+
         public virtual void OnAdd(Key key, Value value) { }
 
         public virtual void OnRemove(Key key) { }

CommonZ/extensions/IResultExtensions.cs

@@ -0,0 +1,70 @@
+using CommonZ;
+using System.Diagnostics.CodeAnalysis;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+
+public static class IResultExtensions
+{
+    public static bool Ok<TResult, TError>(
+        this IResult<TResult, TError> result,
+        [NotNullWhen(true)] out TResult? output
+    )
+        where TResult : class?
+        where TError : class
+        => (output = result.IsOk ? result.Unwrap() : null) is not null;
+
+    public static bool Error<TResult, TError>(
+        this IResult<TResult, TError> result,
+        [NotNullWhen(true)] out TError? error
+    )
+        where TResult : class?
+        where TError : class
+        => (error = result.IsError ? result.UnwrapError() : null) is not null;
+
+    public static IResult<TResult, TError> When<TResult, TError>(
+        this IResult<TResult, TError> result,
+        out TResult? output
+    )
+        where TResult : class?
+        where TError : class
+    {
+        output = result.IsOk ? result.Unwrap() : null;
+        return result;
+    }
+
+    public static IResult<TResult, TError> Else<TResult, TError>(
+        this IResult<TResult, TError> result,
+        out TError? error
+    )
+        where TResult : class?
+        where TError : class
+    {
+        error = result.IsError ? result.UnwrapError() : null;
+        return result;
+    }
+
+    public static IResult<R, TError> When<TResult, TError, R>(
+        this IResult<TResult, TError> result,
+        Func<TResult, IResult<R, TError>> map
+    )
+        where TResult : class?
+        where TError : class
+        where R : class
+    {
+        if (result.IsError) return result.When(_ => (null as R)!);
+
+        return map(result.Unwrap()).Else(e => e);
+    }
+
+    //public static IResult<TResult, TError> Else<TResult, TError>(
+    //    this IResult<TResult, TError> result,
+    //    Action<TError> action
+    //)
+    //    where TResult : class?
+    //    where TError : class
+    //{
+    //    if (result.IsError)
+    //        action(result.UnwrapError());
+
+    //    return result;
+    //}
+}

Examples/test.zs

@@ -0,0 +1,28 @@
+import { print } from "std:io";
+import { Void, Test } from "std:types";
+
+print("[CT] Hello, World!");
+
+import { Directory } from "std:fs";
+
+import { CompilerObject } from "core:compiler";
+
+module A {
+	print("[CT] Inside module A");
+
+	fun main(): Void {
+		print(Directory.cwd().toString());
+		print(Test(Directory.cwd().toString()));
+
+		print("[RT] Hello, World!");
+		return;
+	}
+}
+
+if (false) {
+	print("[CT] Condition is true");
+} else {
+	print("[CT] Condition is false");
+}
+
+A.main();

README.md

@@ -1,76 +1,15 @@
 # Z# Language
 
 
-Welcome to the Z# language repository! This repository holds the first released version of Z#.
-
-Z# is a typesafe, interpreterd language. It is still very much a WIP so don't expect it to work smoothly.
-
-The current state of the project is:
-* [x] Tokenizer
-* [x] Parser
-* [x] Resolver
-* [x] Compiler
-* [x] IR Layer
-* [x] ZSRuntime
-* [ ] Platform Compiler
-
-## Structure
-
-The whole compiler is separated to multiple modules, each with a different purpose.
+> This README file is out-of-date. I will update this once I have enough time and an acceptable working version.
+> If you have any questions regarding this project, you can join the discord server ~~[discord server](https://discord.gg/Uc3GN2bfG9)~~ [discord channel on PLTD](https://discord.gg/jkCSRvpyYA).
 
-To understand the architecture of the compiler, one needs to understand the architecture of the language.
 
-The language is interpreted and it allows using statements in top-level scopes (e.g. document, module, etc..).
-Also, it is typesafe. The compiler creates an IR of the code and the interpreter holds a runtime representation of the IR.
-
-The IR defines a static structure, while the runtime objects can vary during execution.
-
-## Running
-
-Simply run the main project (ZSharpTest).
-
-You can edit the [`test.zs`](ZSharpTest/test.zs) file.
+Welcome to the Z# language repository! This repository holds the first released version of Z#.
 
-## ToDo
+Z# is a typesafe, interpreterd language. It is still very much a WIP so don't expect it to work smoothly.
 
-* [ ] Add support for type-inference
-    - [x] Local inference
-    - [ ] Function return type
-* [ ] Implement the overloading protocol (C#)
-* [ ] Implement the `compile` protocol (both `IRObject` and `IR Type`) (C#, Z#)
-* [ ] Implement better Z# RT VM API (C#)
-    - [x] Function calls
-    - [ ] Object construction, instantiation and initialization
-    - [x] IR loading
-* [x] Organize IR loading in Z# RT VM (C#)
-* [ ] Implement document-level definitions
-    - [ ] Functions
-    - [ ] Globals
-* [ ] Implement OOP types
-    - [ ] Class
-    - [ ] Interface
-    - [ ] Typeclass
-    - [ ] Structure
-* [ ] Add support for decorators
-* [ ] Add support for custom attributes
-* [ ] Implement the CG `Execute`/`Evaluate` command.
-* [ ] Implement the `import(string)` CG function (C#)
-    - [ ] Add support for extensible `StringImporter`
-* [ ] Add support for definition templates
-    - [ ] Functions
-    - [ ] Classes (which includes methods, properties, fields, etc..)
-* [x] Fix module references lookup code (consider the fact that IR have 2 sources: `Read` and `EvaluateType`).
-    - > The way this works is by analyzing each function code right after the body is compiled.
-* [ ] ZSharp.Compiler project
-    - [ ] IR Generator
-    - [ ] Generators
-        - [ ] Document
-        - [ ] Function Body
-        - [ ] Module
-        - [ ] OOP Types
-        - [ ] Method Body
+This repository is undergoing massive rewrites and the architecture is still under development.
+Due to that, contributions are currently not accepted.
 
-## ToDo (High Level)
-* [ ] C# Interop with Z# (C# Reflection -> IR)
-* [ ] Add more language features
-* [ ] Fully implement the IR -> CG loader
+However, suggestions about everything (syntax, concepts, architecture, etc..) are always welcome.

Testing/Program.cs

@@ -0,0 +1,45 @@
+using ZSharp.Importer.ILLoader;
+using Objects = ZSharp.Importer.ILLoader.Objects;
+
+var rtm = ZSharp.IR.RuntimeModule.Standard;
+var coc = new ZSharp.Compiler.Compiler(rtm);
+var rt = new ZSharp.Platform.Runtime.Runtime(new()
+{
+    Array = rtm.TypeSystem.Array,
+    Boolean = rtm.TypeSystem.Boolean,
+    Char = null!,
+    Float16 = null!,
+    Float32 = rtm.TypeSystem.Float32,
+    Float64 = null!,
+    Float128 = null!,
+    Object = rtm.TypeSystem.Object,
+    Pointer = rtm.TypeSystem.Pointer,
+    Reference = rtm.TypeSystem.Reference,
+    SInt8 = null!,
+    SInt16 = null!,
+    SInt32 = rtm.TypeSystem.Int32,
+    SInt64 = null!,
+    SIntNative = null!,
+    String = rtm.TypeSystem.String,
+    UInt8 = null!,
+    UInt16 = null!,
+    UInt32 = null!,
+    UInt64 = null!,
+    UIntNative = null!,
+    Void = rtm.TypeSystem.Void
+});
+
+var ilLoader = new ILLoader(coc, rt);
+
+coc.TS.SInt32 = ilLoader.TypeSystem.SInt32;
+
+var code = rt.Expose("Hello, Exposed String!");
+var exposed = rt.Evaluate(code, rtm.TypeSystem.Object);
+System.Console.WriteLine(exposed);
+
+var typedCode = ilLoader.ExposeAsIR(12);
+var typedExposed = rt.Evaluate(typedCode, rtm.TypeSystem.Int32);
+System.Console.WriteLine(typedExposed);
+
+
+System.Console.WriteLine(string.Empty);

Testing/Testing.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ZSharp.Importer.ILLoader\ZSharp.Importer.ILLoader.csproj" />
+  </ItemGroup>
+
+</Project>