Files

bigint

lib.rsuint.rs

bitmaps

bitmap.rslib.rstypes.rs

byteorder

lib.rs

cfg_if

lib.rs

clojurust

clojure

lang

objects

AFn.rsAFunction.rsAMapEntry.rsAPersistentMap.rsAPersistentSet.rsAPersistentVector.rsASeq.rsFn.rsIEditableCollection.rsIFn.rsIHashEq.rsIKVReduce.rsIMapEntry.rsIMapIterable.rsIMeta.rsIObj.rsIPersistentCollection.rsIPersistentMap.rsIPersistentSet.rsIPersistentStack.rsIPersistentVector.rsISeq.rsITransientCollection.rsIndexedSeq.rsMapEntry.rsMapEquivalence.rsMethodImplCache.rsPersistentHashMap.rsPersistentHashSet.rsPersistentVector.rsRSeq.rsRT.rsSequable.rsSequential.rsSubVector.rsUtil.rs

rust

macros

macros.rsnumber.rs

objects

Associative.rsCallable.rsClass.rsCollection.rsComparable.rsComparator.rsCounted.rsFnMethodNative.rsFunction.rsGlobals.rsILookup.rsIObject.rsIndexed.rsIterable.rsList.rsMap.rsMember.rsNumber.rsObjResult.rsObject.rsProtocol.rsPrototype.rsRandomAccess.rsReversible.rsRunnable.rsSerializable.rsSet.rsString.rsThread.rsUnique.rs

lib.rs

crunchy

lib.rs

dashmap

mapref

entry.rsmod.rsmultiple.rsone.rs

setref

mod.rsmultiple.rsone.rs

iter.rsiter_set.rslib.rslock.rsread_only.rsset.rst.rsutil.rs

delegate

lib.rs

error_chain

error_chain.rslib.rsquick_error.rsquick_main.rs

getrandom

error.rslib.rslinux_android.rsuse_file.rsutil.rsutil_libc.rs

im

hash

map.rsmod.rsset.rs

nodes

btree.rshamt.rsmod.rsrrb.rs

ord

map.rsmod.rsset.rs

vector

focus.rsmod.rspool.rs

config.rsfakepool.rsiter.rslib.rssort.rssync.rsutil.rs

intertrait

cast

cast_arc.rscast_box.rscast_mut.rscast_rc.rscast_ref.rs

cast.rshasher.rslib.rs

intertrait_macros

args.rsgen_caster.rsitem_impl.rsitem_type.rslib.rs

lazy_static

inline_lazy.rslib.rs

libc

unix

linux_like

linux

arch

generic

mod.rs

mod.rs

gnu

b64

x86_64

align.rsmod.rsnot_x32.rs

mod.rs

align.rsmod.rs

align.rsmod.rs

mod.rs

align.rsmod.rs

fixed_width_ints.rslib.rsmacros.rs

linkme

distributed_slice.rslib.rsprivate.rs

linkme_impl

args.rsattr.rsdeclaration.rsderive.rselement.rslib.rslinker.rs

mut_static

error.rsforce_some_rw_lock_read_guard.rsforce_some_rw_lock_write_guard.rslib.rsmut_static.rs

num_cpus

lib.rslinux.rs

once_cell

imp_std.rslib.rsrace.rs

proc_macro2

detection.rsfallback.rslib.rsmarker.rsparse.rswrapper.rs

quote

ext.rsformat.rsident_fragment.rslib.rsruntime.rsspanned.rsto_tokens.rs

rand_core

block.rserror.rsimpls.rsle.rslib.rs

rand_xoshiro

common.rslib.rssplitmix64.rsxoroshiro128plus.rsxoroshiro128plusplus.rsxoroshiro128starstar.rsxoroshiro64star.rsxoroshiro64starstar.rsxoshiro128plus.rsxoshiro128plusplus.rsxoshiro128starstar.rsxoshiro256plus.rsxoshiro256plusplus.rsxoshiro256starstar.rsxoshiro512plus.rsxoshiro512plusplus.rsxoshiro512starstar.rs

rc

lib.rsstable_rc.rs

serde

de

ignored_any.rsimpls.rsmod.rsseed.rsutf8.rsvalue.rs

private

de.rsdoc.rsmod.rsser.rssize_hint.rs

ser

fmt.rsimpls.rsimpossible.rsmod.rs

integer128.rslib.rsmacros.rs

sized_chunks

inline_array

iter.rsmod.rs

sized_chunk

iter.rsmod.rs

sparse_chunk

iter.rsmod.rs

lib.rstypes.rs

syn

gen

clone.rsgen_helper.rsvisit_mut.rs

attr.rsawait.rsbigint.rsbuffer.rscustom_keyword.rscustom_punctuation.rsdata.rsderive.rsdiscouraged.rserror.rsexport.rsexpr.rsext.rsfile.rsgenerics.rsgroup.rsident.rsitem.rslib.rslifetime.rslit.rslookahead.rsmac.rsmacros.rsop.rsparse.rsparse_macro_input.rsparse_quote.rspat.rspath.rsprint.rspunctuated.rsreserved.rssealed.rsspan.rsspanned.rsstmt.rsthread.rstoken.rsty.rsverbatim.rswhitespace.rs

typenum

array.rsbit.rsint.rslib.rsmarker_traits.rsoperator_aliases.rsprivate.rstype_operators.rsuint.rs

unicode_xid

lib.rstables.rs

uuid

adapter

mod.rs

builder

error.rsmod.rs

parser

error.rsmod.rs

error.rslib.rsprelude.rsv4.rs

>

//
#![crate_name = "clojurust"]

//! # `clojurust` crate: Proof of concept for a Clojure library in Rust.
//!
//! This library implements root functions for a Rust implemented `host` for
//! manage a `Clojure` implemented in `Rust`.
//! It implements also the core Java equivalent of the Java version of
//! Clojure in Rust.
//!
//! ## `crate::clojure::rust` module
//!
//! This module contains the `Rust` host.
#![allow(dead_code)]
#![allow(unused_variables)]
// ![warn(unreachable_pub, missing_docs)]
#![allow(missing_docs)]
// #![allow(unused_imports)]
#![allow(bare_trait_objects)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![recursion_limit = "256"]
// For Iterator
#![feature(rustc_attrs)]
#![feature(iter_advance_by)]
#![feature(iter_intersperse)]
#![feature(iter_map_while)]
#![feature(iter_partition_in_place)]
#![feature(iter_is_partitioned)]
#![feature(try_trait)]
#![feature(try_blocks)]
#![feature(control_flow_enum)]
#![feature(try_find)]
#![feature(iter_order_by)]
#![feature(associated_type_defaults)]

// #![feature(fn_traits)]
// #![feature(trace_macros)]
// trace_macros!(true);

/// Clojure Module
///
/// description de clojure
pub mod clojure {
    /// Clojure language module
    ///
    /// clojure::lang modules
    pub mod lang {
        pub mod objects {
            pub mod AFn;
            pub mod AFunction;
            pub mod AMapEntry;
            pub mod APersistentMap;
            pub mod APersistentSet;
            pub mod APersistentVector;
            pub mod ASeq;
            pub mod Fn;
            pub mod IEditableCollection;
            pub mod IFn;
            pub mod IHashEq;
            pub mod IKVReduce;
            pub mod IMapEntry;
            pub mod IMapIterable;
            pub mod IMeta;
            pub mod IObj;
            pub mod IPersistentCollection;
            pub mod IPersistentMap;
            pub mod IPersistentSet;
            pub mod IPersistentStack;
            pub mod IPersistentVector;
            pub mod ISeq;
            pub mod ITransientCollection;
            pub mod IndexedSeq;
            pub mod MapEntry;
            pub mod MapEquivalence;
            pub mod MethodImplCache;
            pub mod PersistentHashMap;
            pub mod PersistentHashSet;
            pub mod PersistentVector;
            pub mod RSeq;
            pub mod RT;
            pub mod Sequable;
            pub mod Sequential;
            pub mod SubVector;
            pub mod Util;
        }

        pub use objects::AFn::*;
        pub use objects::AFunction::*;
        pub use objects::AMapEntry::*;
        pub use objects::APersistentMap::*;
        pub use objects::APersistentSet::*;
        pub use objects::APersistentVector::*;
        pub use objects::ASeq::*;
        pub use objects::Fn::*;
        pub use objects::IEditableCollection::*;
        pub use objects::IFn::*;
        pub use objects::IHashEq::*;
        pub use objects::IKVReduce::*;
        pub use objects::IMapEntry::*;
        pub use objects::IMapIterable::*;
        pub use objects::IMeta::*;
        pub use objects::IObj::*;
        pub use objects::IPersistentCollection::*;
        pub use objects::IPersistentMap::*;
        pub use objects::IPersistentSet::*;
        pub use objects::IPersistentStack::*;
        pub use objects::IPersistentVector::*;
        pub use objects::ISeq::*;
        pub use objects::ITransientCollection::*;
        pub use objects::IndexedSeq::*;
        pub use objects::MapEntry::*;
        pub use objects::MapEquivalence::*;
        pub use objects::MethodImplCache::*;
        pub use objects::PersistentHashMap::*;
        pub use objects::PersistentHashSet::*;
        pub use objects::PersistentVector::*;
        pub use objects::RSeq::*;
        pub use objects::Sequable::*;
        pub use objects::Sequential::*;
        pub use objects::SubVector::*;
        pub use objects::Util::*;
        pub use objects::RT::*;
    }

    /// clojure::rust host modules
    pub mod rust {
        pub mod objects {
            pub mod Associative;
            pub mod Callable;
            pub mod Class;
            pub mod Collection;
            pub mod Comparable;
            pub mod Comparator;
            pub mod Counted;
            pub mod FnMethodNative;
            pub mod Function;
            pub mod Globals;
            pub mod ILookup;
            pub mod IObject;
            pub mod Indexed;
            pub mod Iterable;
            pub mod List;
            pub mod Map;
            pub mod Member;
            pub mod Number;
            pub mod ObjResult;
            pub mod Object;
            pub mod Protocol;
            pub mod Prototype;
            pub mod RandomAccess;
            pub mod Reversible;
            pub mod Runnable;
            pub mod Serializable;
            pub mod Set;
            pub mod String;
            pub mod Thread;
            pub mod Unique;
        }
        pub mod macros {
            pub mod macros;
            pub mod number;
        }

        pub use objects::Associative::*;
        pub use objects::Callable::*;
        pub use objects::Class::*;
        pub use objects::Collection::*;
        pub use objects::Comparable::*;
        pub use objects::Comparator::*;
        pub use objects::Counted::*;
        pub use objects::FnMethodNative::*;
        pub use objects::Function::*;
        pub use objects::Globals::*;
        pub use objects::ILookup::*;
        pub use objects::IObject::*;
        pub use objects::Indexed::*;
        pub use objects::Iterable::*;
        pub use objects::List::*;
        pub use objects::Map::*;
        pub use objects::Member::*;
        pub use objects::Number::*;
        pub use objects::ObjResult::*;
        pub use objects::Object::*;
        pub use objects::Protocol::*;
        pub use objects::Prototype::*;
        pub use objects::RandomAccess::*;
        pub use objects::Reversible::*;
        pub use objects::Runnable::*;
        pub use objects::Serializable::*;
        pub use objects::Set::*;
        pub use objects::String::*;
        pub use objects::Thread::*;
        pub use objects::Unique::*;
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}