My personal little scheme lib to make my life easier

RRRLib.rkt

;MIT License
;
;Copyright (c) 2020 Rubin Romeo Raithel
;
;Permission is hereby granted, free of charge, to any person obtaining a copy
;of this software and associated documentation files (the "Software"), to deal
;in the Software without restriction, including without limitation the rights
;to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
;copies of the Software, and to permit persons to whom the Software is
;furnished to do so, subject to the following conditions:
;
;The above copyright notice and this permission notice shall be included in all
;copies or substantial portions of the Software.
;
;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
;SOFTWARE.


;Use by putting `(require "RRRLib.rkt")` in your own racket files


#lang racket

(provide PRINT)
(provide forI)
(provide for)
(provide type?)

;(PRINT *args)
;Print function, just like in python, but without ',' seperator
(define (PRINT . args) (for-each (lambda (x) (display x) (display " ")) args)(newline))

;(n func(i, *args) *args)
;Normal for loop that provides i - (iteration counter staring from 0)
(define (forI n func . args)
  (let loop ((i 0))
    (when (< i n)
      (apply func (append (list i) args))
      (loop (+ i 1))
      )
    )
  )

;(n func(*args) *args)
;Normal for loop
(define (for n func . args)
  (let loop ((i 0))
    (when (< i n)
      (apply func args)
      (loop (+ i 1))
      )
    )
  )

;(type? arg) -> {elemt of types}
;Get type of argument
;types: ['int, 'float, 'str, 'bool, 'list]
(define (type? arg)
    (cond
    ((number? arg)
        (cond
            ((exact? arg)   'int   )
            ((inexact? arg) 'float )
        )
    )
    ((string? arg)  'str   )
    ((boolean? arg) 'bool  )
    ((list? arg)    'list  )
    ((pair? arg)    'pair  )
    (else (raise "TypeError: type can not be deduced" #t))
    )
)