Re-namespacing

Moving away from the DNS-driven namespacing toward more condensed names,
mostly because I don't like typing so much.

1 files changed, 0 insertions, 158 deletions

diff --git a/Com/Simatime/Core.scm b/Com/Simatime/Core.scm
deleted file mode 100644
index 83ded5d..0000000
--- a/Com/Simatime/Core.scm
+++ /dev/null
@@ -1,158 +0,0 @@
-(define-module (Com Simatime Core)
-  #:use-module ((ice-9 format))
-  #:export (
-            ;; simple printing
-            fmt printf pr prn
-
-                ;; navigating data
-            first next second rest
-
-            ;; booleans
-            true? false? nil nil?
-
-            ;; dev helpers
-            comment
-            ))
-
-(define (flip f)           (lambda (x y) (f y x)))
-(define (curry f a)        (lambda (b) (apply f (cons a (list b)))))
-(define pos?
-  (curry < 0))
-
-(define neg?
-  (curry > 0))
-
-(define (foldr f end lst)
-  (if (null? lst)
-    end
-    (f (car lst) (foldr f end (cdr lst)))))
-
-(define (foldl f acc lst)
-  (if (null? lst)
-    acc
-    (foldl f (f acc (car lst)) (cdr lst))))
-
-(define fold foldl)
-
-(define (unfold f init pred)
-  (if (pred init)
-    (cons init '())
-    (cons init (unfold f (f init) pred))))
-
-(define (sum lst)          (fold + 0 lst))
-(define (produce lst)      (fold * 1 lst))
-
-(define count length)
-
-
-;;
-;; clojure-like stuff
-;;
-
-(define (pr . a)
-  (for-each display a))
-
-(define (prn . a) (apply pr a) (newline))
-
-(define (first a)
-  "Return the first item in the collection."
-  (car a))
-
-(define (rest a)
-  "Returns a list of the items after the first."
-  (cdr a))
-
-(define (next a)
-  "Returns the next item after the first."
-  (cadr a))
-
-;; same thing, easier to remember/read
-(define second next)
-
-(define (ffirst a)
-  (first (first a)))
-
-(define (nnext a)
-  (next (next a)))
-
-(define (last coll)
-  "Return the last time in coll, in linear time."
-  (if (next coll)
-      (last coll)
-      (first coll)))
-
-(define (butlast ls)
-  "Return everthing execpt the last element in ls."
-  (let ((len (length ls)))
-    (list-head ls (- len 1))))
-
-(define (false? x)
-  (eq? #f x))
-
-(define (true? x)
-  (eq? #t x))
-
-(define nil #nil)
-
-(define (nil? x)
-  (eq? nil x))
-
-;; Ignores body, returns nil.
-(define-syntax comment
-  (syntax-rules ()
-    ((_ ...) nil)))
-
-(comment
- ;; nil is different from null. nil is supposed to be more like
- ;; 'Nothing' in Haskell, it is the absence of any value or type;
- ;; whereas null is specifically the empty list, which still has a type
- ;; of 'list'.
- (null? '()) ;; => #t
- (nil? '())  ;; => #f
- )
-
-(define (some pred coll)
-  (or (pred (first coll))
-      (some pred (next coll))))
-
-(define comp compose)
-
-(define (not-any? pred coll)
-  (comp not some))
-
-(define (printf . args)
-  (display (apply format args)))
-
-(define-syntax fmt
-  (syntax-rules ()
-    ((_ s args ...)
-     (format #f s args ...))))
-
-;; If I implement ML-like interface abstractions in scheme, what would it look like?
-
-;; 
-;; ;; seq
-
-;; (define-class <seq> () (_first))
-
-;; 
-;; ;; Functor
-
-;; (define-class <functor> ())
-
-;; (define-method (fmap (f <procedure>) (coll <functor>)))
-
-;; 
-;; ;; Applicative
-
-;; ;; a -> f a
-;; (define-method (pure (a <any>)))
-
-;; ;; f (a -> b) -> f a -> f b
-;; (define-method (<*> (f <procedure>) (a <applicative>) (b <applicative>)))
-
-;; ;; f a -> f b -> f b
-;; (define-method (*> (a <applicative>) (b <applicative>)))
-
-;; ;; f a -> f b -> f a
-;; (define-method (<* (a <applicative>) (b <applicative>)))