versions 11.7

Author: damien-mattei

README.md

@@ -28,12 +28,20 @@ Another method is to use the [Makefile](https://github.com/damien-mattei/Scheme-
 <br>
 
 
+
+
+**Changes of version 11.7:**
+
+Removed debug info display that should have been commented before releasing the previous version.
+Some new doc will be commited, but it should not be as it is work in progress.
+
+<br>
+
 **Changes of version 11.5:**
 
 Correct a bug introduced in v11.3: in ```def+``` source code it is no more ```$nfx$``` that should be used but instead ```$nfx$-rec```.
 Rationale: ```def+``` allows both infix and prefix expression in normal parenthesis ( ) by autodetection and this feature is mainly done by ```$nfx$-rec```, at contrary ```$nfx$``` is now generally preferred for expressions that should be only infix,for example the ones in curly parenthesis { }.
 
-<br>
 
 **Changes of version 11.4:**
 

examples/racket/exo_retropropagationNhidden_layers_matrix_v3_by_vectors+.rkt

@@ -1,4 +1,6 @@
-#lang reader SRFI-105
+#reader SRFI-105
+
+;;#lang reader SRFI-105
 
 ;; SRFI-105 Curly-infix-expressions and a few more
 

infix-with-precedence-to-prefix.rkt

@@ -613,22 +613,22 @@
 
 ;; Welcome to DrRacket, version 8.13 [cs].
 ;; Language: r6rs, with debugging; memory limit: 8192 MB.
-;; > (!*prec-generic-infix-parser '(x <- 10.0 - 3.0 - 4.0 + 1 - 5.0 * 2.0 ** 3.0 / 7.0 ** 3.0)   infix-operators-lst-for-parser (lambda (op a b) (list op a b)))
+;; (!*prec-generic-infix-parser '(x <- 10.0 - 3.0 - 4.0 + 1 - 5.0 * 2.0 ** 3.0 / 7.0 ** 3.0)   infix-operators-lst-for-parser (lambda (op a b) (list op a b)))
 ;; ((<- x (- (+ (- (- 10.0 3.0) 4.0) 1) (/ (* 5.0 (** 2.0 3.0)) (** 7.0 3.0)))))
-;; > (- (+ (- (- 10.0 3.0) 4.0) 1) (/ (* 5.0 (** 2.0 3.0)) (** 7.0 3.0)))
-;; > (define ** expt)
-;; > (- (+ (- (- 10.0 3.0) 4.0) 1) (/ (* 5.0 (** 2.0 3.0)) (** 7.0 3.0)))
+;; (- (+ (- (- 10.0 3.0) 4.0) 1) (/ (* 5.0 (** 2.0 3.0)) (** 7.0 3.0)))
+;; (define ** expt)
+;; (- (+ (- (- 10.0 3.0) 4.0) 1) (/ (* 5.0 (** 2.0 3.0)) (** 7.0 3.0)))
 ;; 3.883381924198251
 
 ;; Python:
 ;; 10.0 - 3.0 - 4.0 + 1 - 5.0 * 2.0 ** 3.0 / 7.0 ** 3.0
 ;; 3.883381924198251
 
 
-;; > (!*prec-generic-infix-parser '(a ** b ** c)  infix-operators-lst-for-parser (lambda (op a b) (list op a b)))
+;; (!*prec-generic-infix-parser '(a ** b ** c)  infix-operators-lst-for-parser (lambda (op a b) (list op a b)))
 ;; ((** a (** b c)))
 
-;; >  (!*prec-generic-infix-parser '(a - b - c) infix-operators-lst-for-parser (lambda (op a b) (list op a b)))
+;;  (!*prec-generic-infix-parser '(a - b - c) infix-operators-lst-for-parser (lambda (op a b) (list op a b)))
 ;; ((- (- a b) c))
 
 
@@ -654,7 +654,7 @@
 ;; $nfx$ : parsed-args=.#<syntax (- (+ (* 3 5) (* 2 (sin 0.5))...>
 ;; -4.041148922791594
 
-;; > {(3 + 1) * (2 * (2 + 1) - 1) + (2 * 5 - 5)}
+;; {(3 + 1) * (2 * (2 + 1) - 1) + (2 * 5 - 5)}
 
 
 ;; ($nfx$ (3 + 1) * (2 * (2 + 1) - 1) + (2 * 5 - 5))
@@ -675,7 +675,7 @@
 
 
 
-;; > x
+;; x
 ;; x
 ;; 3
 
@@ -700,7 +700,7 @@
 ;; {2 ¹⁰}
 ;; 1024
 
-;; > {5 -  - 2}
+;; {5 -  - 2}
 
 
 ;; ($nfx$ 5 - - 2)

info.rkt

@@ -11,7 +11,7 @@
 	       ;"SRFI-105-for-Racket"
 	       "try-catch"))
 (define pkg-desc "Scheme+ for Racket")
-(define version "11.5")
+(define version "11.7")
 (define pkg-authors '(mattei))
 (define scribblings '(("scribblings/scheme-plus.scrbl" ())))
 (define build-deps '("scribble-lib" "racket-doc" "scribble-code-examples" "scribble-doc"))

parse-square-brackets.rkt

@@ -66,7 +66,7 @@
 	       (if (infix? #;infix-simple? partial-result) ; we test but we do not need to check all the syntax
 
 		   ($> ; then
-		    (display "psba 1 : infix detected ") (newline)
+		    ;;(display "psba 1 : infix detected ") (newline)
 
 		    (insert-tail-set! #;append-tail-set! result (!*prec-generic-infix-parser partial-result
 											     creator
@@ -102,14 +102,14 @@
   	    (when (not (null? partial-result)) ;; check infix expression exist really
   	      ;;(display "not null") (newline)
 
-	      (display "psba : result =") (display result) (newline)
-	      (display "psba 2 : partial-result =") (display partial-result) (newline)
+	      ;;(display "psba : result =") (display result) (newline)
+	      ;;(display "psba 2 : partial-result =") (display partial-result) (newline)
 
 	      ;; check it is in infix, not already prefixed (we are in scheme...) we test but we do not need to check all the syntax
   	      (if (infix? #;infix-simple?  partial-result) ;;  operateurs quotés ou syntaxés !
 
   		      (begin ; yes
-  			(display "psba 2 : infix detected ") (newline)
+  			;;(display "psba 2 : infix detected ") (newline)
 
   			(insert-tail-set! #;append-tail-set! result (!*prec-generic-infix-parser partial-result
 												 creator

scribblings/scheme-plus.scrbl

@@ -1,7 +1,119 @@
 #lang scribble/manual
 
-@title{Scheme+ for Racket}
- 
+	   
+@title[#:style '(toc)]{Scheme+ for Racket}
+
+@author[(author+email "Damien Mattei" "[email protected]")]
+
+source code: @url["https://github.com/damien-mattei/Scheme-PLUS-for-Racket"]
+
+
+@defmodule[SRFI-105 #:reader]{
+This reader package provides the SRFI-105 Curly Infix reader/parser.
+}
+
+
+
+@defmodule[Scheme+]{
+This package provides the Scheme+ language definitions.
+}
+
+
+Scheme+ is an extension of the syntax of the Scheme language.
+
+Scheme+ adds to Scheme a way to use also infix notation with a compatibility near 100% and not as a sub-system of Lisp syntax as it is often done but with a complete integration in the Scheme reader/parser system and also for Racket at REPL (Read Eval Print Loop).
+
+Scheme+ is to Scheme what a concept-car is to automobile.Scheme+ is a concept-language.It is ideally what should be a modern Scheme.
+
+Scheme+ makes it easy the assignment of Scheme objects in infix (works also in prefix) notation with a few new operators <- (or: ← , :=),⥆ (or <+) for definitions.
+
+Scheme+ makes it easy the access and assignment for arrays,strings,hash tables,etc by allowing the classic square brackets [ ] of others languages.
+
+
+@table-of-contents[]
+
+
+@section[#:tag "installation"]{Scheme+ Installation and Depandencies}
+
+Scheme+ can be installed via the Racket Package system or downloaded from Github.
+Scheme+ is designed to be used with the package SRFI-105 for Racket which is a curly infix reader also available in the same way described above.
+
+@section[#:tag "syntax"]{Scheme+ Syntax and Conventions}
+
+In general Scheme+ use the same convention for infix expression than SRFI-105 Curly Infix that is an infix expression is between curly parenthesis { }.
+But infix sub-expressions are allowed to be between normal parenthesis ( ). Infix or prefix is then autodetected,in cas of ambiguities { } force infix mode.
+
+@codeblock|{
+#reader SRFI-105
+(require Scheme+)
+{3 * 5 + 2}
+17
+}|
+
+
+@codeblock|{
+#lang reader SRFI-105
+(require Scheme+)
+{3 · 5 + 2 ³}
+23
+}|
+
+
+@section[#:tag "reference"]{Scheme+ Reference}
+
+
+@subsection[#:tag "declarations"]{Declarations}
+
+@defform[(declare name1 name2 ...)]{
+Declare new variables named @racket[name1],@racket[name2],....
+}
+
+Note: this is rarely used,instead assignment macros are used but could be usefull in case a variable used in a block must be used outside too.
+
+@subsection[#:tag "definitions"]{Definitions}
+
+@defthing[⥆ macro]{}
+
+@defform[{name <+ value}]{
+Define new variable @racket[name] and assign value @racket[value].
+}
+
+Note: this is almost never used in Racket,because Scheme+ for Racket as a special feature of autodetection if a variable needs to be defined before assignment.
+
+There is some alias of this:
+
+@defform[{name ⥆ value}]{}
+
+Note: a lot of operators of Scheme+ that works left to right exist in the opposite sense, i will document them as it is obvious,example:
+
+@defform[{value ⥅ name}]{}
+
+@subsection[#:tag "assignment"]{Assignments}
+
+@defthing[← macro]{}
+
+@defform[{name <- value}]{
+Assign to the variable @racket[name] the value @racket[value].
+}
+
+@codeblock|{
+#lang reader SRFI-105
+(require Scheme+)
+{x <- 7}
+}|
+
+There is some alias of this:
+
+@defform[{name := value}]{}
+
+
+@defform[{name ← value}]{}
+
+@codeblock{
+{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]}
+}
+
+
 The documentation is hosted on Github:
 
 @hyperlink["https://github.com/damien-mattei/Scheme-PLUS-for-Racket/blob/gh-pages/README.md"]{Documentation of Scheme+ for Racket on Github pages}