(ns rlm.light-base

   {:author "Robert McIntyre"}

   (:refer-clojure :only []) 

   (:require [rlm [ns-rlm]]))

 

 

 

 ;;We start with absolutely nothing and build from there

 (rlm.ns-rlm/ns-clear) ;; all we have is [def if ns in-ns].

 

 

 (clojure.core/use

  :reload

  '[clojure

    [core

     :only

     [

      ;; object stuff

      extend-type

 

 

      *command-line-args* *err* *out* *warn-on-reflection* val name read-line

      ;;REPL

      find-doc doc print-doc print-namespace-doc

      ;;Regexes

      re-pattern re-matcher re-groups re-seq re-matches re-find

      ;; Unsorted

      meta type with-meta vary-meta defmacro str let binding with-bindings bound-fn bound-fn* eval

      time macroexpand-1 macroexpand destructure comment test rand rand-int subs hash

      definline alter-var-root format printf defonce refer-clojure gen-class load letfn

      gen-interface definterface reify munge defrecord deftype extenders defprotocol

      extend extend-protocol slurp clojure-version char assert read

      ;; Printing

      print-method print-dup newline flush print println prn with-in-str with-out-str

      print-str println-str *print-length* *print-level* print-ctor primitives-classnames

      ;;Agents

      agent send send-off release-pending-sends

      add-watch remove-watch agent-error restart-agent set-error-handler! error-handler

      set-error-mode! error-mode shutdown-agents

      ;;Ref

      ref deref

      ;;Atom

      atom swap! compare-and-set! reset! set-validator! get-validator alter-meta!

      reset-meta! commute alter ref-set ref-history-count ref-min-history ref-max-history

      ensure sync dosync    

      ;;MultiMethods

      defmulti defmethod remove-all-methods remove-method prefer-method

      methods get-method prefers

      ;;Numerics

      inc dec rem quot rationalize mod numerator denominator

      ;;Bits

      bit-and bit-or bit-xor bit-and-not bit-clear bit-set

      bit-flip bit-test bit-shift-left bit-shift-right

      ;; Logic

      not =

      ;; Creation

      symbol gensym keyword int declare num long float double short byte boolean

      bigint bigdec transient persistent! assoc!

      ;; Lists

      list list* rest next cons first second last butlast 

      ;; Maps

      hash-map sorted-map sorted-map-by find select-keys keys vals

      merge merge-with zipmap create-struct defstruct struct-map struct get-in

      assoc-in update-in map-indexed key

      ;; Sets

      set sorted-set sorted-set-by disj split-at split-with 

      ;; Vectors

      vector vec subvec vector-of

      ;; Arrays

      to-array into-array alength aclone aget aset aset-int aset-long

      aset-boolean aset-float aset-double aset-short aset-long aset-byte aset-char

      aset-int make-array to-array-2d amap areduce boolean-array byte-array char-array

      short-array double-array object-array int-array long-array booleans chars

      shorts floats ints doubles longs partition-all

      ;; Seqs

      lazy-seq nth rseq reverse concat peek pop sequence every? not-every? some

      not-any? take take-while drop drop-last take-last drop-while cycle repeat

      replicate iterate range line-seq sort sort-by partition doseq dorun doall

      take-nth interleave lazy-cat tree-seq file-seq xml-seq distinct

      replace subseq rsubseq interpose seque not-empty flatten group-by count

      partition-by frequencies shuffle 

      ;; Functions

      fn defn defn- apply complement constantly identity comp juxt partial repeatedly

      trampoline memoize pmap pcalls pvalues fnil

      ;; List Comprehensions

      reduce reductions map mapcat filter remove keep keep-indexed for

      ;; Predicates

      instance? seq? char? string? map? vector? nil?

      false? true? symbol? keyword? delay?  future? future-done?

      even? odd? contains? number? integer? ratio? decimal? reversible?

      float? rational? special-symbol? var? class? bound? thread-bound? counted?

      distinct? empty? coll? list? set? ifn? fn? associative? sequential? sorted?

      extends? satisfies? future-cancelled?

      comparator

      ;; Comparason

      compare  not= identical?  ==

      ;; Control Flow

      when when-not cond delay force if-not and or locking -> ->> while case

      if-let when-let dotimes await await-for with-open doto loop condp future-call

      future future-cancel promise deliver 

      ;;Namespaces

      create-ns find-ns remove-ns all-ns the-ns ns-name ns-map ns-unmap ns-publics

      ns-imports ns-interns refer ns-refers alias ns-aliases ns-unalias ns-resolve

      resolve ns require use loaded-libs compile intern namespace-munge

      ;; Java

      .. import class enumeration-seq

      ;;Objects

      bases make-hierarchy supers isa? parents ancestors descendants derive underive

      ;; Symbols

      *ns* *1 *2 *3 *e *compile-path*

      ;; Proxies

      get-proxy-class construct-proxy init-proxy update-proxy proxy-mappings proxy

      proxy-super bean

      ;; Vars

      var-get

      

      ]]]

 

 

  '[rlm

    [function-utils :only [mix defmix runonce]]

    [rlm-commands :only [undef ns-reset ns-nuke reload keymap-clojure keymap-normal rlm]]

    [ns-rlm :only [ns-clear ns-clone ls]]

    [play-all :only [play-all-music]]

    [shell-inspect :only [command-line?]]

    [shell-write :only [sw]]

    [classpath-utils :only [classpath add-to-classpath]]

    [dreams :only [megadef megaundef silence]]

    [map-utils :only [map-keys map-vals filter-keys filter-vals]]

    [decorators :only [preserve-meta]]

    [visualize :only [visual]]

    [identify :only [identify]]

    [push :only [push-gen push]]

    ]

  '[coderloop

    [utils :only [read-integer read-big-integer read-integers trans-print digits]]

    [export-files :only [export-archive]]]

 

  '[sunil

    [curry :only  [decorate curry defn-decorated]]]

  

  '[clojure.contrib

    [import-static :only [import-static]]

    [combinatorics :only [cartesian-product subsets selections

 			 permutations lex-permutations combinations]]

    [duck-streams :only [file-str read-lines]]

    [str-utils :only [re-split re-gsub str-join]]

    [seq :only [separate indexed rotations find-first positions]]

    [math :only [expt round gcd lcm floor ceil]]

    [repl-utils :only [show expression-info]]

    [def :only [defn-memo defvar defmacro-]]

 

 

    ]

 

  '[clojure.contrib.generic

    [arithmetic :only [+ - / *]]

    [collection :only [assoc conj dissoc get empty into seq]]

    [comparison :only [pos? neg? zero? > < <= >= max min]]

    [math-functions :only

    [sqr approx= conjugate sgn acos asin atan atan2 

     cos exp log pow rint sin tan]]

    [functor :only [fmap]]]

  

  '[matchure :only [fn-match defn-match if-match when-match cond-match]]

  

  

 ;; '[letd :only [with-separator display-local-bindings letd]]

  

  '[clojure

    [repl :only [source]]]

  

  '[clojure.java

    [javadoc :only [javadoc add-local-javadoc]]]

 

 )

 

 ;;java stuff

 

 (import '[java.lang ProcessBuilder Enum SuppressWarnings Throwable

 	  InterruptedException Thread$UncaughtExceptionHandler RuntimeException

 	  Thread$State ArrayIndexOutOfBoundsException IllegalAccessError Process

 	  SecurityException InstantiationException ThreadGroup System

 	  EnumConstantNotPresentException OutOfMemoryError Double Package

 	  ExceptionInInitializerError RuntimePermission UnknownError

 	  IncompatibleClassChangeError

 	  ArithmeticException StackTraceElement NoSuchFieldError InternalError Thread

 	  SecurityManager Cloneable NegativeArraySizeException StringBuilder Appendable

 	  Byte Math Exception IllegalAccessException ClassNotFoundException

 	  UnsatisfiedLinkError

 	  IllegalArgumentException AssertionError Short StrictMath ClassCircularityError

 	  NoSuchFieldException Comparable Readable UnsupportedClassVersionError

 	  IllegalThreadStateException Iterable Object VirtualMachineError

 	  InheritableThreadLocal

 	  ThreadLocal ClassLoader CloneNotSupportedException TypeNotPresentException

 	  Void

 	  Character NoClassDefFoundError IllegalStateException LinkageError Boolean

 	  String

 	  InstantiationError Float Runnable IndexOutOfBoundsException ClassFormatError

 	  NullPointerException NoSuchMethodError ClassCastException Class

 	  StringIndexOutOfBoundsException Override ThreadDeath CharSequence Number

 	  IllegalMonitorStateException Error NumberFormatException VerifyError

 	  StringBuffer

 	  NoSuchMethodException Long ArrayStoreException UnsupportedOperationException

 	  Integer

 	  Deprecated StackOverflowError AbstractMethodError Runtime]

 	'[java.math BigDecimal BigInteger]

 	'java.util.concurrent.Callable

 	'clojure.lang.Compiler

 	)

 

 ;; jme3 stuff

 

 (set! clojure.core/*print-length* 20)  

 

 (clojure.java.javadoc/add-local-javadoc "/home/r/mobius/temp-clj/javadoc")

 

 

 (clojure.java.javadoc/add-local-javadoc "/home/r/roBin/jdk6-docs/docs/api")

 (clojure.java.javadoc/add-local-javadoc 

  "/home/r/roBin/lpsolve-doc/lpsolve.sourceforge.net/5.5/Java/docs/api")

 

 

 (defmethod / [java.lang.Number java.lang.Number]

   [x y] (clojure.core// x y))

 

 (defmethod - [java.lang.Number java.lang.Number]

   [x y] (clojure.core/- x y))

 

 (import-static java.lang.Math PI E)