Begin clojure.lang cllection protocols

ivanpierre · ivanpierre · commit 2b4bd9093ab4 · 2021-04-15T06:04:55.000+02:00
diff --git a/README.md b/README.md
@@ -1,10 +1,23 @@
 # ClojuRust
 A proof of concept version of Clojure in Rust.
 
+<!-- TOC -->
+
+- [ClojuRust](#clojurust)
+    - [Current state](#current-state)
+    - [Goals](#goals)
+    - [Documentation](#documentation)
+    - [Licence](#licence)
+        - [Persistent data structures licence](#persistent-data-structures-licence)
+        - [Original Clojure licence](#original-clojure-licence)
+        - [clojure.core original code](#clojurecore-original-code)
+
+<!-- /TOC -->
+
 ## Current state
 WIP in an analysis and test state, and so a working version is out of sight for now.
 
-As I'm a newbie in Rust, I hit all the bads of borrowing, referencing, Arcs, automatic derefs, timeline problems... But it begin to enter in my fingers... ;)
+As I'm a newbie in Rust, I hit all the bads of borrowing, referencing, Arcs, automatic derefs, timeline problems... But it begin to enter in my fingers... :wink:
 
 For now, in the creation of the clojure::rust modules, say the Rust host environment, as Clojure is an hosted language. Rust, as a bare-metal language, has no dynamic abilities per se, and is even opposed to such an approach as all is verified at compile time. So a lot of information should be statically stored for the library to function.
 
@@ -23,35 +36,32 @@ Meanwhile, the first Core Clojure classes can be developed in parallel, for test
 ## Documentation
 The whole documentation will be located in a .io page (WIP)
 
-## Copyrights
-### ClojuRust
-
-    Copyright (c) 2020 Ivan Pierre, kilroySoft, <Ivan Pierre, ivan@kilroysoft.ch>, under MPL 2.0.
-
-* Code is on GitHub: https://github.com/clojurust/clojurust
+## Licence
+This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. 
 
-### Clojure
-As clojure::lang::* is a translation of original code of Java Clojure core, reference is due to Rich Hickey:
+If a copy of the MPL was not distributed within this file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-    Copyright (c) Rich Hickey. All rights reserved. Under EPL 1.0.
 
-* Original project can be found in the main repository: https://github.com/clojure/clojure
+    Copyright (c) 2020 Ivan Pierre, kilroySoft, <Ivan Pierre, ivan@kilroysoft.ch>, under MPL 2.0.
 
-But the project is not in this stage for now.
+* Code is on GitHub: https://github.com/clojurust/clojurust
 
-### Crate for the persistent data structures
+### Persistent data structures licence
 
     Copyright 2017 Bodil Stokke, under MPL 2.0.
 
 * Crate doc is here: https://crates.io/crates/im
 * Code is on GitHub: https://github.com/bodil/im-rs
 
-## Licence
-This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. 
+### Original Clojure licence
+As clojure::lang::* is a translation of original code of Java Clojure core, reference is due to Rich Hickey:
 
-If a copy of the MPL was not distributed within this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    Copyright (c) Rich Hickey. All rights reserved. Under EPL 1.0.
+
+* Original project can be found in the main repository: https://github.com/clojure/clojure
+
+But the project is not in this stage for now.
 
-### Original Clojure licence
 As clojure::lang is on Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php), there could be some problem of double licence problem.
 
 As is, I put this advice of the original project licence:
diff --git a/src/clojure/lang/a_map_entry.rs b/src/clojure/lang/a_map_entry.rs
@@ -0,0 +1,21 @@
+//! Protocol AMapEntry
+
+use crate::clojure;
+use clojure::rust::object::*;
+use clojure::rust::obj_error::*;
+use clojure::lang::a_persistent_vector::*;
+use clojure::lang::i_persistent_stack::*;
+use clojure::lang::i_persistent_collection::*;
+use clojure::lang::i_seq::*;
+use clojure::lang::i_map_entry::*;
+
+pub trait AMapEntry : TObject + APersistentVector + IMapEntry {
+    fn assocN(&self, i: usize, val: &Object) -> ObjResult<&'_ IPersistentVector>; 
+    fn cons(&self, o: &Object) -> ObjResult<&'_ IPersistentVector>;
+    fn count(&self) -> ObjResult<usize>;
+    fn empty(&self) -> ObjResult<&'_ IPersistentCollection>; 
+    fn nth(&self, i: usize) -> ObjResult<Object>;
+    fn pop(&self) -> ObjResult<&'_ IPersistentStack>; 
+    fn seq(&self) -> ObjResult<&'_ ISeq>; 
+    fn setValue(value: Object) -> ObjResult<Object>; 
+}
diff --git a/src/clojure/lang/i_map_entry.rs b/src/clojure/lang/i_map_entry.rs
@@ -0,0 +1,11 @@
+//! Protocol IMapEntry
+
+use crate::clojure;
+use clojure::rust::object::*;
+use clojure::rust::obj_error::*;
+use clojure::rust::map::*;
+
+pub trait IMapEntry: TObject + Entry {
+    fn key(&self) -> ObjResult<Object>;
+    fn val(&self) -> ObjResult<Object>;    
+}
diff --git a/src/clojure/rust/associative.rs b/src/clojure/rust/associative.rs
@@ -0,0 +1,12 @@
+//! Protocol Associative
+
+use crate::clojure;
+use clojure::rust::object::*;
+use clojure::rust::obj_error::*;
+use clojure::lang::i_map_entry::*;
+
+pub trait Associative {
+    fn assoc(&self, key: &Object, value: &Object) -> ObjResult<&Associative>;
+    fn containsKey(&self, key: &Object) -> ObjResult<bool>;
+    fn entryAt(&self, key: &Object) -> ObjResult<&IMapEntry>;
+}
diff --git a/src/clojure/rust/counted.rs b/src/clojure/rust/counted.rs
@@ -1,16 +1,18 @@
 /// Protocol `Counted`
 
+use crate::clojure;
+use clojure::rust::object::*;
+use clojure::rust::obj_error::*;
+
 use crate::init_obj;
 use crate::init_init_obj;
 
-// castable_to!(SGlobals => [sync] TObject, Globals);
-
 init_obj! {
     Counted {
     }
 }
 
-pub trait Counted {
+pub trait Counted: TObject {
     /// give the nr of elements
-    fn count(&self) -> usize;
+    fn count(&self) -> ObjResult<usize>;
 }
diff --git a/src/clojure/rust/indexed.rs b/src/clojure/rust/indexed.rs
@@ -4,11 +4,12 @@
 use crate::clojure;
 use clojure::rust::counted::*;
 use clojure::rust::object::*;
+use clojure::rust::obj_error::*;
 
 // castable_to!(SGlobals => [sync] TObject, Globals);
 
-pub trait Indexed: Counted {
-    fn nth_1(&self, i: usize) -> Object;
-    fn nth_2(&self, i: usize, notFound: Object) -> Object;
+pub trait Indexed: TObject + Counted {
+    fn nth_1(&self, i: usize) -> ObjResult<Object>;
+    fn nth_2(&self, i: usize, notFound: Object) -> ObjResult<Object>;
 }
 
diff --git a/src/clojure/rust/iterable.rs b/src/clojure/rust/iterable.rs
diff --git a/src/clojure/rust/map.rs b/src/clojure/rust/map.rs
@@ -0,0 +1,8 @@
+//! An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value.
+
+trait Map<K, V>{}
+
+/// This is an entry for K = V = Object
+pub trait Entry {
+
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -35,21 +35,25 @@ pub mod clojure {
         pub mod a_persistent_vector;
         pub mod a_persistent_set;
         pub mod a_persistent_map;
+        pub mod a_map_entry;
         pub mod persistent_vector;
         pub mod persistent_set;
         pub mod persistent_map;
+        pub mod i_map_entry;
     }
 
     /// Rust host Module
     pub mod rust {
         pub mod class;
         pub mod counted;
+        pub mod associative;
         pub mod indexed;
         pub mod fn_method_native;
         pub mod function;
         pub mod globals;
         pub mod member;
         pub mod number;
+        pub mod map;
         pub mod obj_error;
         pub mod object;
         pub mod protocol;
