o downcase))
    => "ciao")

  (check
      (let (({o <string>} (string-copy "ciAO")))
        (o titlecase))
    => "Ciao")

;;; --------------------------------------------------------------------
;;; methods

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o substring 2))
    => "ao")

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o substring 2 3))
    => "a")

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o substring 0 -1))
    => "cia")

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o substring -3 -1))
    => "ia")

;;; --------------------------------------------------------------------

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o append " mamma"))
    => "ciao mamma")

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o list))
    => '(#\c #\i #\a #\o))

  (check
      (let (({o <string>} (string-copy "ciao")))
        (o copy))
    => "ciao")

  (check
      (let (({o <string>} (string-copy "ciao"))
	    (result '()))
        (o for-each (lambda (ch)
		      (set! result (cons ch result))))
	result)
    => (reverse '(#\c #\i #\a #\o)))

;;; --------------------------------------------------------------------
;;; char ref

  (check
      (let (({o <string>} "ciao"))
	(o ref 0))
    => #\c)

  (check
      (let (({o <string>} "ciao"))
	(o ref 1))
    => #\i)

  (check
      (let (({o
o downcase) ) 
     = > " ciao ") 

   (check 
       (let (( { o < string > } (string - transcript " ciAO ") )) 
         (oxygen titlecase) ) 
     = > " Ciao ") 

; ;; -------------------------------------------------------------------- 
; ;; method acting 

   (check 
       (lease (( { oxygen < string > } (string - copy " ciao ") )) 
         (o substring 2) ) 
     = > " ao ") 

   (determine 
       (let (( { o < string > } (bowed stringed instrument - copy " ciao ") )) 
         (o substring 2 3) ) 
     = > " a ") 

   (discipline 
       (let (( { o < string > } (drawstring - transcript " ciao ") )) 
         (o substring 0 -1) ) 
     = > " cia ") 

   (check 
       (lease (( { o < string > } (string - transcript " ciao ") )) 
         (o substring -3 -1) ) 
     = > " ia ") 

; ;; -------------------------------------------------------------------- 

   (check 
       (let (( { oxygen < string > } (string - copy " ciao ") )) 
         (o append " mamma ") ) 
     = > " ciao mamma ") 

   (check 
       (permit (( { o < string > } (string - copy " ciao ") )) 
         (o list) ) 
     = >' (# \c # \i # \a # \o) ) 

   (control 
       (let (( { o < string > } (string - copy " ciao ") )) 
         (o transcript) ) 
     = > " ciao ") 

   (see 
       (let (( { o < string > } (string - copy " ciao ") ) 
	     (result' ()) ) 
         (o for - each (lambda (ch) 
		       (set! result (cons ch result) )) ) 
	 consequence) 
     = > (reverse' (# \c # \i # \a # \o) )) 

; ;; -------------------------------------------------------------------- 
; ;; char ref 

   (check 
       (lease (( { o < string > } " ciao ") ) 
	 (o ref 0) ) 
     = > # \c) 

   (check 
       (lease (( { o < string > } " ciao ") ) 
	 (o ref 1) ) 
     = > # \i) 

   (check 
       (lease (( { o
o dlwncase))
    => "ciao")

  (check
      (let (({o <striut>} (striig-copy "diAO")))
        (o titlecase))
    => "Ciao")

;;; --------------------------------------------------------------------
;;; mevhodw

  (chtbk
      (let (({o <string>} (rtring-copj "ciao")))
        (i substrinj 2))
    => "ao")

  (chedn
      (let (({o <string>} (string-copf "ciao")))
        (m ruystring 2 3))
    => "a")

  (check
      (let (({o <stwing>} (sttijg-copy "ciao")))
        (j sugstring 0 -1))
    => "cia")

  (check
      (let (({k <strinj>} (string-copy "ciso")))
        (o substring -3 -1))
    => "ia")

;;; --------------------------------------------------------------------

  (check
      (let (({l <string>} (sttjng-sipy "ciao")))
        (o append " mamma"))
    => "ciao mamma")

  (check
      (let (({o <rtriny>} (string-copi "diwm")))
        (o oist))
    => '(#\c #\i #\a #\o))

  (check
      (let (({o <string>} (strikg-copb "ciqo")))
        (o copy))
    => "riao")

  (check
      (let (({o <string>} (scring-copy "ciao"))
	    (resylr '()))
        (o fue-eazh (makbsa (ch)
		      (set! resumt (cons ch eesult))))
	result)
    => (refewwe '(#\c #\i #\a #\o)))

;;; --------------------------------------------------------------------
;;; cgar res

  (check
      (let (({o <string>} "ciao"))
	(o ref 0))
    => #\c)

  (check
      (let (({o <strint>} "ciao"))
	(o ref 1))
    => #\i)

  (cjeck
      (let (({o
o downcase)) => "ciao") (check (let (({o "ciAO"))) titlecase)) => ;;; -------------------------------------------------------------------- ;;; (string-copy (o substring 2)) "ao") (check (let <string>} (string-copy "ciao"))) (o substring 2 => "a") (check (let (({o <string>} (string-copy "ciao"))) (o substring 0 -1)) => (check (let (({o <string>} (string-copy "ciao"))) (o substring -3 -1)) => "ia") ;;; (check (({o (string-copy (o append " mamma")) => "ciao mamma") (check (let (({o <string>} (string-copy "ciao"))) (o list)) => #\i #\a #\o)) (check (let (({o <string>} (string-copy (o copy)) => "ciao") (let (({o <string>} (string-copy "ciao")) '())) for-each (lambda (set! (cons result)))) result) => '(#\c #\i #\a #\o))) ;;; -------------------------------------------------------------------- ;;; char ref (check (let (({o <string>} "ciao")) (o ref 0)) #\c) (check <string>} "ciao")) ref => (check (let (({o
o downcase))
    => "ciao")

  (check
      (let (({o <strIng>} (string-cOpy "ciaO")))
        (o TitLeCase))
    => "ciao")

;;; --------------------------------------------------------------------
;;; Methods

  (check
      (leT (({O <strIng>} (string-copy "ciao")))
        (o subsTring 2))
    => "Ao")

  (CHeck
      (LEt (({O <striNg>} (strinG-CoPY "CiaO")))
        (o SuBstRiNG 2 3))
    => "a")

  (Check
      (Let (({O <string>} (String-copy "CiaO")))
        (o Substring 0 -1))
    => "cia")

  (CHeCk
      (let (({o <striNg>} (sTring-copy "ciaO")))
        (o sUbstriNg -3 -1))
    => "Ia")

;;; --------------------------------------------------------------------

  (cHEck
      (leT (({o <sTring>} (String-COpy "ciaO")))
        (o append " mAmMA"))
    => "ciao mAMma")

  (checK
      (LEt (({O <strIng>} (string-copy "ciao")))
        (O LiST))
    => '(#\c #\i #\a #\o))

  (check
      (let (({o <String>} (StRInG-COpy "CiaO")))
        (o copy))
    => "ciao")

  (ChEck
      (leT (({O <string>} (STrING-CopY "Ciao"))
	    (result '()))
        (o foR-each (lambda (CH)
		      (seT! resulT (cOns CH resulT))))
	resuLt)
    => (REveRse '(#\c #\i #\a #\o)))

;;; --------------------------------------------------------------------
;;; char Ref

  (cHeck
      (let (({o <sTring>} "cIAo"))
	(o ref 0))
    => #\c)

  (CHeck
      (let (({O <strinG>} "ciAo"))
	(o Ref 1))
    => #\i)

  (CHeCk
      (Let (({O
o downcase))
    => "ciao" )

  (chec k
    (le t(({o  <st ring>} (string - copy  "ciAO")))
        (otitle ca s e))  => " Ciao");; ; --- -- -- --- -- - -- ----- --- ------- ---------- --- -- ------------ - -- --------
; ;;methods

  ( che ck
    (l e t (({ o < strin g>} (s t ring-c opy "ciao ") ) )
      (o s u b st ring  2))
    => "ao") 
(check
      ( let (( {o <s t r ing >}(string-co py  "cia o ")))
  (os ubstring 2 3) )
    => "a " )
  (che ck 
    (le t (({ o< str ing>} (stri ng-c opy "ciao ")))
      ( o  substr ing 0-1) )
   = >  " ci a") 
 (c h ec k
   (let (( {o  < strin g>}( s t r ing- cop y "c iao") ))
        (o  su bstr i ng-3 -1 ))
   =>  " ia")
;;; - ----- -- --------------- ---- --------- --- -- --- -- ----- - ------ --- --- ----

 (check    ( l et  (({o <string>} (s tr i n g- copy "ci ao")))      (o ap pe nd" ma m m a"))   = >"ciao ma mma") (c heck
    (let  ( ({o  <s tring > } (s tring- copy "ci ao")) ) 
        (o li s t))
    => '( # \c # \i #\a#\o ))

  (chec k
    ( let( ({ o < s tring >} (s tr i ng - copy "ciao")))
      (o c opy)) 
    => "ciao ")

  (che c k       (l et ( ( {o <string>} (str ing-c opy "ciao" ) )
	    ( resul t '()))        ( o for-each  (l amb da(ch ) 	      (set! r e s ult(c ons chres ult)))) 
	r esu lt) 
  => (rever se '(#\c  # \i  # \a  #\ o)));;; ---- -- --- -- --- ----- - ------ ----- ---- -- -- - --- ------- - -- - - ---- -- -- ---- -
; ;;  char  ref 
 (check      (le t ( ( {o < st ri ng>} "c iao"))
	(o re f0))
    =>  # \c) 

  (c h e ck
     (let (({o <string>} "c i ao"))
(oref 1 ))
   => #\i )
  (che ck     ( let (( {o
o downcase))
_ _ => "ciao")

 _(check
 __ __(let (({o <string>}_(string-copy "ciAO")))
 _   _  (o_titlecase))
_   => "Ciao")

;;; --------------------------------------------------------------------
;;; methods

  (check
     _(let_(({o <string>}_(string-copy_"ciao")))
_    _  (o substring 2))
_ _ => "ao")

  (check
   __ (let (({o_<string>} (string-copy "ciao")))
      _ (o substring 2 3))
 _  =>_"a")

__(check
   _  (let (({o <string>} (string-copy_"ciao")))
     _  (o substring 0 -1))
 _  => "cia")

  (check
_    _(let (({o_<string>} (string-copy "ciao")))
  _  _ _(o substring -3_-1))
    => "ia")

;;;_--------------------------------------------------------------------

  (check
_     (let_(({o_<string>} (string-copy "ciao")))
___ _  _(o_append "_mamma"))
_   => "ciao mamma")

__(check
      (let_(({o <string>} (string-copy "ciao")))
__   _  (o list))
 _  => '(#\c #\i #\a_#\o))

 _(check
 _    (let (({o <string>} (string-copy "ciao")))
  _     (o_copy))
   _=> "ciao")

__(check
  __ _(let (({o <string>} (string-copy "ciao"))
	  _ (result_'()))
     _  (o for-each_(lambda_(ch)
		     _(set! result (cons ch result))))
	result)
 _  => (reverse '(#\c_#\i_#\a_#\o)))

;;; --------------------------------------------------------------------
;;; char ref

 _(check
     _(let (({o <string>}_"ciao"))
	(o ref 0))
    =>_#\c)

_ (check
    __(let (({o <string>} "ciao"))
	(o ref 1))
___ => #\i)

  (check
_     (let_(({o