Hello,

i present some features of the latest release (version 7.3) of Scheme+.

Scheme+ is an extension of the syntax of Scheme. It is 100% compatible with
the implementations of Scheme (Guile, Kawa, Racket,...).

Here are a few features:

Infix notation with operator precedence optimized by parser before
compilation for all Scheme implementation:

an infix expression like this formula (left equation - Lorentz
transformation):
[image: image.png]
can be written in Scheme+ like this:

{xp <- {x - v * t} / (sqrt {1 - v ** 2 / c ** 2})}

and is converted in a classic Scheme prefix expression with the rules of
operator precedence (before being passed to the scheme compiler or
interpreter) in:

(<- xp (/ (- x (* v t)) (sqrt (- 1 (/ (** v 2) (** c 2))))))

Assignment or definitions no more require any sort of *let *form, Scheme+
use *<- *for assignment.

Examples:

(use-modules (Scheme+))

{i <- 0}
{z[0] <- x}
{(x y) <- Lexemples[ip]}
{Ck+1 <- (replace Ck+1 'Bₖ₋₁ Bk-1-symb)}


Access to vectors,array,hash tables,string,etc with [ ] :

{z_1 <- #(1) + z[i]}
{z̃[i + 1] <- M[i] * z_1} ; z̃ = matrix * vector , return a vector

{M_i_o[j {i + 1}]  <-  M_i_o[j {i + 1}] + η * z_input[i] *
მzⳆმz̃(z_output[j] z̃_output[j]) * ᐁ_i_o[j]})

{M_i_o[j {i + 1}]  <-  M_i_o[j {i + 1}] + η * z_input[i] *
მzⳆმz̃(z_output[j] z̃_output[j]) * ᐁ_i_o[j]})


<http://hilite.me/api>
Possibility of use of neoteric expression style:
{z[i + 1] <- vector-map(activation_function_hidden_layer z̃[i + 1])}

{M <- (vector-ec (: n {lnc - 1}) ; vectors by eager comprehension (SRFI 42)
			  create-matrix-by-function(uniform-dummy nc[n + 1] {nc[n] + 1}))}
;; Matrix-vect


Definition of variable with <+ , this add a new variable in the current
envionment:
{n <+ vector-length(z)}

When needed ,declaration of variables without assigning a specific value
(in fact NIL by default):
(declare i)
(declare z z̃ M ᐁ)

*def* is a new special form for function definition it allows *return *from
the current call and recursive return with *return-rec *from all the
possibly recursive call from the defined procedure.

Example from the Guile source code itself of Scheme+:

;; split the expression between [ ] using slice as separator(def
(parse-square-brackets-arguments args-brackets)

  (when (null? args-brackets)
	(return args-brackets))

  (declare result partial-result)

  (def (psba args) ;; parse square brackets arguments


       ;;(display partial-result) (newline)
       (when (null? args)
	     {result <- (append result (!*prec partial-result))} ;; !*prec is
defined in scheme-infix.scm
	
	     (return-rec result)) ;; return from all recursive calls

       {fst <+ (car args)}

       (if (equal? slice fst)
	
	   ($>
	    (when (not (null? partial-result))
		  {result <- (append result (!*prec partial-result))} ;; evaluate
and store the expression
		  {partial-result <- '()}) ;; empty for the next possible portion
between slice operator
	    {result <- (append result (list fst))}) ;; append the slice operator
	
	   {partial-result <- (append partial-result (list fst))}) ;; not a
slice operator but append it

       (psba (cdr args))) ;; end def, recurse

  (psba args-brackets)) ;; initial call


The *repeat ... until *special form:

 (repeat

      {Ck+1-symb <+ (create-Ck-symb {k + 1})}
      ;; note: as we substitute symbol, not expressions the order has
no importance (no risk of expression containing another substitued
symbol or expression)
      {Ck+1 <- (replace Ck+1 'Cₖ Ck)} ;; substitute in Ck+1 ,Ck symbol
by his previous computation
      {Ck+1-infix <- (prefix->infix-symb Ck+1)}
      {Bk-symb <+ (create-Bk-symb k)}
      {Ck+1 <- (replace Ck+1 'Bₖ Bk-symb)}
      {Bk-1-symb <+  (create-Bk-symb {k - 1})}
      {Ck+1 <- (replace Ck+1 'Bₖ₋₁ Bk-1-symb)}

      ;; those replacements are only effective for the first steps of
loop k=0,k=1 when B0 and B-1 exists in expression of Ck+1
      {Ck+1 <- (replace Ck+1 'B₋₁ 'F)}
      {Ck+1 <- (replace Ck+1 'C₀ C0)} ;; for the anxious ones (
useless as C0 does not appear anymore after first step )
      {Ck+1 <- (replace Ck+1 'B₀ 'T)}

      {Ck+1 <- (minimal-dnf Ck+1)}
      {Ck+1-infix <- (prefix->infix-symb Ck+1)}
      (display-nl (format "~a = ~a" Ck+1-symb Ck+1-infix))
      (newline)

      {Ck <- Ck+1}
      {Ck+1 <- Ck+1-backup}
      {k <- k + 1}

      until {k >= n})


another example:


(def (product-set-with-set-imperative set1 set2)

     (when (null? set1) (return set1)) ;; empty set result
     (when (null? set2) (return set2)) ;; empty set result

     {result <+ '()}

     (repeat

      {a <+ (first set1)}
      {set1 <- (rest set1)}

      {set2-iterator <+ set2}

      (repeat

       {b <+ (first set2-iterator)}
       {set2-iterator <- (rest set2-iterator)}
       {result <- (cons (list a b) result)}

       until (null? set2-iterator))

      until (null? set1))

     result)


*for *as in C++ permits *break *and *continue*:

(for ({i <+ 0} {i < 5} {i <- i + 1})
{x <+ 7}
(display x)
(newline)
(break))

(for ({i <+ 0} {i < 5} {i <- i + 1})
 {x <+ 7}
 (continue)
 (display x)
 (newline)
 (break))

Example of Matrix multiplication implementation in Scheme+ :

(define (multiply-matrix-matrix M1 M2)

  {(n1 p1) <+ (dim-matrix-vect M1)}
  {(n2 p2) <+ (dim-matrix-vect M2)}

  (when {p1 ≠ n2} (error "matrix-by-vectors.* : matrix product
impossible, incompatible dimensions"))

  {v1 <+ (matrix-vect-v M1)}
  {v2 <+ (matrix-vect-v M2)}

  (define (res i j)
    {sum <+ 0}
    (for ({k <+ 0} {k < p1} {k <- k + 1})
    	 {sum <- sum + v1[i][k] * v2[k][j]})
    sum)

  {v <+ (create-vector-2d res n1 p2)}

  (matrix-vect v))



code example using Scheme+ for Racket,Kawa and Guile can be find also here:

https://github.com/damien-mattei/AI_Deep_Learning
https://github.com/damien-mattei/library-FunctProg/blob/296e9c7a217d59a6c1469b45cdc7353d94c0aa70/guile/logiki%2B.scm#L2532
https://github.com/damien-mattei/library-FunctProg/blob/296e9c7a217d59a6c1469b45cdc7353d94c0aa70/racket/logiki%2B.rkt#L2812
https://github.com/damien-mattei/AI_Deep_Learning/blob/2d9d080ad35cecd0471ac8f8e7e867cea205ca75/exo_retropropagationNhidden_layers_matrix_v2_by_vectors4kawa%2B.scm#L206


for now Scheme+ is available for:

Guile : https://damien-mattei.github.io/Scheme-PLUS-for-Guile/Scheme+io.html

Racket :
https://damien-mattei.github.io/Scheme-PLUS-for-Racket/Scheme+io.html

Kawa: https://github.com/damien-mattei/Scheme-PLUS-for-Kawa

Damien