Typed JOE examples

Here are the JOE test programs re-written to be TJOE programs.
I've also included some invalid programs below.

This assignment is about type checking, not evaluating.  So, what
I want to see with each of these is a run of the type checker
program ("get-type" in the assignment).  For instance,

  (get-type (parse '{with {x : number 3} : boolean
  		{= x 3}}) (mtTypeSub))
  		
should return something like

  (boolean)
  
------------------------------


{with {x : number 2} : number
  {with {y : number 12} : number
    {+ {* x x} {* y y}}
}}



{- 1 {- 2 {- 3 {- 4 {- 5 6}}}}}



{with {x : number 3} : boolean ;; this should evaluate to a boolean value
  {= x 2}}
  
  
  
{with {x : number 3} : boolean
  {= x 3}}
  
  
  
{if {= {* 5 21} {* 7 15}}
    9999
    5555
}


{with {number {fun {number : number} : number
        {* number number}}}
   {with {num : number 8} : number
     {number num} }}
     

{with {x : number 9} : number    ; you can change these vals, but the larger one should
  {with {y : number 3} : number  ; always wind up at the left of the final number
               ; and the smaller one at the right
     {with  {min : number {if {< x y}
                     x 
                     y}} : number 
        {with  {max : number {if {< x y}
                        y 
                        x}} : number 
           {+ {* max 1000} min} ; output will be best if smaller is
 }}}}                           ; no more than two digits



{with {double : (number -> number) {fun {n : number} : number {* 2 n}}} : number
  {double 12}}



{with {abs : (number -> number) {fun {x : number} : number {if {< x 0} {- x} x}}} : number ;; absolute value
   {abs -101}
}



{rec {fac : (number -> number) {fun {n : number} : number ;; basic factorial function
	    {if {< n 2}
	        1
	        {* n {fac {- n 1}}} }}
     }
  {fac 7}}
  
  

{with {sqrt : (number -> number) {fun {n : number} : number  ;; integer square root
  {with {new-guess : (number -> number) {fun {g : number} : number {/ {+ g {/ n g}} 2}}} : number  
     {rec {root-of-n : (number -> number) {fun {s : number} : number ;; compute square root of (non-local) n
             {if {< n {* s s}} ;; if s is too big, get a new guess
    		{root-of-n {new-guess s}}
    		{if {with {s1 : number {+ s 1}} : number {< {* s1 s1} n}} ;; if s is too small,
    		       {root-of-n {new-guess s}}     ;; get a new guess
    		       s}          ;; otherwise, s is our answer
    		    }}}
       {root-of-n {/ n 2}}  ;; use half of n as initial guess
     }
  }}} : number
  {sqrt 123}   ;; so, try out our sqrt function
 }


----------------------------

Invalid programs the parser shouldn't like:

{+ 3 4 5}

{with {x:number 3}:number
   x}
   
{with {x : number 12}
    x}

{6 - 7}

{fun {n : number 12} : number
   {+ n 3}}
   
{with {y : number} : number
   {+ x y}}

----------------------------

Invalid programs the parser will like, but the type
checker shouldn't:

{* 3 {< 7 8}}


{with {double : (number -> number) {fun {n : number} : number {* 2 n}}} : number
  {with {x : number 7} : number
    {if {= x 10} x double}
 }}


{if 5 3 4}


{with {double : (number -> number) {fun {n : number} : number {* 2 n}}} : number
  {with {val : boolean {< 8 7}} : number
    {double val}}}
    
    
{with {b : boolean {= 0 0}} : boolean
    45 }
  
  
{with {b : boolean 5} : boolean
    b }