compiler: add fixnums Word{64,32,16,8}, Int{64,32,16,8}

and example/fixnums.kl
and associated operations such as:
- {word|int}{8|16|32|64}{<|>|<=|>=|=}
- {word|int}-compliment,-popcount,->string
- {word|int}{8|16|32|64}->string

and redefine #%integer-literal to not assume an Integer.

Author: doyougnu

README.rst

@@ -145,7 +145,7 @@ want to help make Klister a more practical language, please `reach out`_!
 Here are the most prominent Racket features which are missing from Klister:
 
 * Klister does not yet support custom readers, and thus every ``#lang`` looks like a
-  Lisp. This also limits languages to Integer literals and String literals.
+  Lisp. This also limits languages to Integer literals, builtin fixnums and String literals.
 * `local-expand`_ is planned, but not yet implemented.
 * `Syntax parameters`_ are planned, but not yet implemented.
 

examples/anaphoric-if.kl

@@ -33,6 +33,6 @@
                 ,else])))))
 
 (example
-  (if-non-empty (snoc (list 1 2 3) 4)
+  (if-non-empty (snoc (list (the Integer 1) 2 3) 4)
     (:: 0 it)
     (list 0)))

examples/datatype-macro.kl

@@ -32,9 +32,9 @@
            [(cons x xs)
             (pure (quasiquote/loc more (:: ,x ,(cons-list-syntax 'list xs xs))))])]))]))
 
-(example (reverse (:: 1 (:: 2 (:: 3 (nil))))))
+(example (reverse (:: (the Integer 1) (:: 2 (:: 3 (nil))))))
 
-(example (reverse (list 1 2 3)))
+(example (reverse (list (the Integer 1) 2 3)))
 
 (define-macros
   ([null (lambda (stx) (pure '(nil)))]))
@@ -48,5 +48,4 @@
 
 (example (case (reverse null) [null 'a]))
 
-(example (case (reverse (list 1 2 3)) [(head x) x]))
-         
+(example (case (reverse (list (the Integer 1) 2 3)) [(head x) x]))

examples/define-syntax-rule-test.kl

@@ -9,16 +9,16 @@
 (define-macro (lambda2a x y body)
   (pure `(lambda (,x ,y) ,body)))
 (define mk-pair-a (lambda2a x y (pair x y)))
-(example (mk-pair-a 1 2))
+(example (mk-pair-a (the Integer 1) (the Integer 2)))
 
 (define-variadic-macro (lambda2b stx)
   (case (open-syntax stx)
     [(list-contents (list _ x y body))
      (pure `(lambda (,x ,y) ,body))]))
 (define mk-pair-b (lambda2b x y (pair x y)))
-(example (mk-pair-b 1 2))
+(example (mk-pair-b (the Integer 1) (the Integer 2)))
 
 (define-syntax-rule (lambda2c x y body)
-  (lambda (x y) body))
+   (lambda (x y) body))
 (define mk-pair-c (lambda2c x y (pair x y)))
-(example (mk-pair-c 1 2))
+(example (mk-pair-c (the Integer 1) (the Integer 2)))

examples/either-datatype.kl

@@ -49,7 +49,7 @@
 (example (run-either integer->string id))
 
 -- "42"
-(example (run-either integer->string id (left 42)))
+(example (run-either integer->string id (left (the Integer 42))))
 
 
 -- Next, let's define a variant of Either with three cases: leftmost, center,
@@ -115,10 +115,10 @@
          (pure `(:: ,x (nil)))]))))
 
 -- (:: 42 (nil))
-(example (head 42))
+(example (head (the Integer 42)))
 
 -- 1
-(example (case (list 1 2 3)
+(example (case (list (the Integer 1) 2 3)
            [(head x)
             x]))
 

examples/eta-case.kl

@@ -19,13 +19,13 @@
     [(:: x xs)
      (pair x xs)]
     [(nil)
-     (pair 0 (nil))]))
+     (pair (the Integer 0) (nil))]))
 
 (example (list-to-pair (list)))
 -- =>
 --   (pair 0 (nil))
 
-(example (list-to-pair (list 1 2 3)))
+(example (list-to-pair (list (the Integer 1) 2 3)))
 -- =>
 --   (pair 1 (list 2 3))
 
@@ -332,11 +332,11 @@
 -- =>
 --   (lambda (x xs) (:: x xs))
 
-(example (cons-lambda 1))
+(example (cons-lambda (the Integer 1)))
 -- =>
 --   (lambda (xs) (:: 1 xs))
 
-(example (cons-lambda 1 (list 2 3)))
+(example (cons-lambda (the Integer 1) (list 2 3)))
 -- =>
 --   (list 1 2 3)
 
@@ -381,40 +381,40 @@
 -- =>
 --   (lambda (x xs) (:: x xs))
 
-(example (cons 1))
+(example (cons (the Integer 1)))
 -- =>
 --   (lambda (xs) (:: 1 xs))
 
-(example (cons 1 (list 2 3)))
+(example (cons (the Integer 1) (list 2 3)))
 -- =>
 --   (list 1 2 3)
 
 (example
-  (case (list 1 2 3)
+  (case (list (the Integer 1) 2 3)
     [(cons x xs)
      (pair x xs)]))
 -- =>
 --   (pair 1 (list 2 3))
 
 -- All right, we can finally test eta-case and eta-case-aux!
 (example
-  ((eta-case-aux (list 1 2 3)
+  ((eta-case-aux (list (the Integer 1) 2 3)
      (cons)
      (pair)
-     [(nil) (pair 0 (nil))])
+     [(nil) (pair (the Integer 0) (nil))])
    (cons)))
 -- =>
 --   (pair 1 (list 2 3))
 
 (defun eta-list-to-pair (xs0)
   (eta-case xs0
     [(cons) (pair)]
-    [(nil) (pair 0 (nil))]))
+    [(nil) (pair (the Integer 0) (nil))]))
 
 (example (eta-list-to-pair (list)))
 -- =>
 --   (pair 0 (nil))
 
-(example (eta-list-to-pair (list 1 2 3)))
+(example (eta-list-to-pair (list (the Integer 1) 2 3)))
 -- =>
 --   (pair 1 (list 2 3))

examples/fixnum.golden

@@ -0,0 +1,14 @@
+12 : Integer
+255 : Word64
+26 : Word32
+22 : Word16
+12 : Word8
+12 : Int64
+12 : Int32
+12 : Int16
+0 : Int8
+8 : Int32
+92 : Int8
+-8 : Int8
+25 : Integer
+129 : Integer

examples/fixnum.kl

@@ -0,0 +1,17 @@
+#lang "prelude.kl"
+
+
+(example (the Integer 0b1100)) -- 12
+(example (the Word64 0xFF))    -- 255
+(example (the Word32 0o32))    -- 26
+(example (the Word16 22))
+(example (the Word8 12))
+(example (the Int64 12))
+(example (the Int32 12))
+(example (the Int16 12))
+(example (the Int8  256))  -- note no bounds checking with the primitives this is 0
+(example (int32-popcount 0xFF)) -- 8
+(example (int8-+ 42 50))
+(example (int8-compliment 7)) -- will be -8 because 2's complement
+(example (+ 0b0111 0o22))
+(example (+ 0b0111 0x7A))

examples/free-identifier-case-test.kl

@@ -9,13 +9,13 @@
      (syntax-case stx
        [(list (_ x))
         (free-identifier-case x
-          [if (pure '1)]
-          [else (pure '2)]
-          [define (pure '3)]
-          [#%app (pure '4)]
+          [if (pure '(the Integer 1))]
+          [else (pure '(the Integer 2))]
+          [define (pure '(the Integer 3))]
+          [#%app (pure '(the Integer 4))]
           [(else y) (pure y)])]))]))
 
-(define hello 32)
+(define hello (the Integer 32))
 (example (test if))
 (example (test else))
 (example (test define))

examples/hygiene.kl

@@ -39,14 +39,14 @@
                   (let [,misc-id 'other]
                     x)))]))]))
 (example
-  ((should-be-id x) 5))
+  ((should-be-id x) (the Integer 5)))
 
 -- The following example demonstrates that we can have two (define x ...)
 -- declarations with overlapping scopes without any accidental captures.
 (define-syntax-rule (define-six misc-id)
   (group
     (define x "defined six")
-    (define misc-id 6)
+    (define misc-id (the Integer 6))
     (example x)))
 (define-six x)
 (example x)