Re: access slot of a class

[Damien Mattei]

just forget to say that in my previous examples, <- is a macro that
contain a set! case that is used with single variable.(does not use
setter, just set!)

On Tue, Nov 21, 2023 at 9:19 AM Damien Mattei <damien.mattei@gmail.com> wrote:
>
> that is interesting answer about guile's features i did not know ,
> it is related with code i'm writing that instead of fetching the value
> modify it using the fetch syntax in Scheme+ but my question was just
> about how to have a class method in a class that can set! the value of
> a slot. This does nt seem to be available in Guile because "A method
> is not formally associated with any single class (as it is in many
> other object oriented languages)" [0].
>
> i will explain the problem more in my answer to Mikael and you, i just
> wanted to be able to create a class method that can access the slot
> directly , more than in the example [2] :
>
> (define-class <my-complex> (<number>)
>    (r #:init-value 0 #:accessor real-part #:init-keyword #:r)
>    (i #:init-value 0 #:accessor imag-part #:init-keyword #:i))
>
> (set! (real-part c) new-value)
>
> in othe Scheme i can do simply:
>
> (set! r new-value)
>
> for example in Kawa:
>
> (define-simple-class ReseauRetroPropagation ()
>
>   (nbiter init-value: 3)
>   (activation_function_hidden_layer)
>   (activation_function_output_layer)
>   (activation_function_hidden_layer_derivative)
>   (activation_function_output_layer_derivative)
>
>   (ηₛ 1.0)
>
>   (z)
>   (z̃)
>
>   (M)
>
>   (ᐁ)
>
>   (error 0)
>
>   ((*init* nc nbiter0 ηₛ0 activation_function_hidden_layer0
>                      activation_function_output_layer0
>               activation_function_hidden_layer_derivative0
>               activation_function_output_layer_derivative0)
>
>    (display "*init* : nc=") (display nc) (newline)
>    {nbiter <- nbiter0}
>    {ηₛ <- ηₛ0}
>
> ...
>
> or in Racket :
>
> (define ReseauRetroPropagation
>
>   (class object%
>
>      (super-new)
>
>      ; this is the initialisation parameters
>      (init-field (nc #(2 3 1)) ;; on crée le tableau des couches du réseau
>                     (nbiter 10000)
>                     (ηₛ 1.0)
>              (activation_function_hidden_layer tanh)
>              (activation_function_output_layer tanh)
>              (activation_function_hidden_layer_derivative der_tanh)
>              (activation_function_output_layer_derivative der_tanh))
>
>      {lnc <+ (vector-length nc)}
>
>      ; les entrées concrètes seront fournies avec la méthode accepte
>      ;; (field (z (vector-ec (: i (vector-length nc)) (make-vector {nc[i]} 
> 0))))
>      ;;(field (z (vector-ec (:vector lg nc)
>     ;;              (make-vector lg 0))))
>      (field (z (vector-map (lambda (lg) (make-vector lg 0))
>                    nc)))
>
>      ;; (field (z (for/vector ([lg nc])
>      ;;                (make-vector lg 0))))
>
>      (display "z=") (display z) (newline)
>
>
>      ; z̃[0] is not used as z[0] is x, the initial data
>      ;;(field (z̃ (vector-ec (:vector lg nc)
>         ;;          (make-vector lg 0))))
>      (field (z̃ (vector-map (lambda (lg) (make-vector lg 0))
>                    nc)))
>
>
>      (display "z̃=") (display z̃) (newline)
>
>
>      {M <+ (vector-ec (: n {lnc - 1}) ; vectors by eager comprehension (SRFI 
> 42)
>               create-matrix-vect-by-function(uniform-dummy nc[n + 1]
> {nc[n] + 1}))} ;; Matrix-vect
>
>      ;(field (M (vector-ec (: n {lnc - 1}) ; vectors by eager
> comprehension (SRFI 42)
>      ;          (create-matrix-vect-by-function uniform-dummy {nc[n +
> 1]} {nc[n] + 1})))) ;; Matrix-vect
>
>
>      (display "M=") (display M) (newline)
>
>      (field (ᐁ (for/vector ([lg nc])
>                    (make-vector lg 0))))
>
>
>      (display "ᐁ=") (display ᐁ) (newline)
>
>      (display "nbiter=") (display nbiter) (newline)
>
>      (field (error 0))
>
>
>      ; forward propagation
>
>          ; z_* sans le coef. 1 constant pour le bias
>      (define (accepte_et_propage x) ; on entre des entrées et on les propage
>
>         (when {vector-length(x) ≠ vector-length(z[0])}
>           (display "Mauvais nombre d'entrées !") (newline)
>           (exit #f))
>
>         {z[0] <- x} ; on ne touche pas au biais
>
> in those 2 example z is a slot (or field in Racket) of the class
> ReseauRetroPropagation that can directly be accessed from a class
> method without using the accessors (getter and setter)
>
> Regards,
> Damien
>
>
>
>
> [0] 8.6 Methods and Generic Functions
> https://www.gnu.org/software/guile/manual/html_node/Methods-and-Generic-Functions.html
>
> [2] 8.5  Illustrating Slot Description:
> https://www.gnu.org/software/guile/manual/html_node/Slot-Description-Example.html
>
> On Mon, Nov 20, 2023 at 11:43 PM Nate Rosenbloom
> <nate.rosenbloom@gmail.com> wrote:
> >>
> >> is there a way to access a slot of a class like other variable with set! ,
> >> Racket,Kawa allow that, but it does not seem to be the case in Guile.
> >
> >
> > Hello Damien:
> > Does 'generalized set'[0] do what you want?
> > You can create accessor procedures that have an attached setter -
> >
> > Or were you speaking specifically about class slots? In which case it looks 
> > like the accessor can be used in in set!: [2]
> > Thanks,
> > Nate
> > [0] 7.5.14 sfri 17 Generalized set!: 
> > https://www.gnu.org/software/guile/manual/html_node/SRFI_002d17.html
> > [1] 6.7.8 Procedures with Setters: 
> > https://www.gnu.org/software/guile/manual/html_node/Procedures-with-Setters.html
> > [2] 8.5  Illustrating Slot Description: 
> > https://www.gnu.org/software/guile/manual/html_node/Slot-Description-Example.html
> >