Hi, I added a better README with som more guts... Here is some introduction,
This Toolset for guile that is a subset of the python-on-guile toolset that is stand alone and does not depend on any other scheme projects then guile itself being installed. go to modules: autoreconf -i ./configure make sudo make install And you are ready to go. For documentation of most of the scheme interface see http://c-lambda.se/python-on-guile/ If you want to have functioning persistence you need to have the guile-persist guile libs installed (https://gitlab.com/tampe/guile-persist). Example: > (use-modules (util scheme-python)) > (define b (bytes "abc")) > b b'abc' ;; we wrap bytevectors and represent ;; standardize representing them as ;; latin 1 > (define b (bytearray b)) > (define c b) > (=* b 10) > b bytearray(b'abcabcabcabcabcabcabcabcabcabc') > (eq? b c) #t ;; pythons += *= is implemented and for ;; bytesarrays the lhs is modified ;; similar for set operations on set's ;; should be more scalable then using ;; + of * > (define l (py-list '(1 2 3))) > l [1,2,3] > (+ l l) [1,2,3,1,2,3] > (define ll l) > (+= l l) > l [1,2,3,1,2,3] > (eq? l ll) #t > (define b (bytes "abö")) ;; defaults to encode using latin1 comp ;; (not utf-8 comp) > (py-upper b) b'ABÖ' > (define b (bytes "the red fox")) > (py-capitalize b) b'The Red Fox' > (define a (py-set '(1,2))) > (define b (py-set '(2,3))) > (py-logxor a b) set([1,3]) ;; symmetric difference > (py-logior a b) ;; union set([1,2,3]) > (py-logand a b) ;; intersection set([2]) > (- a b) ;; set difference set([1]) > (&= a b) ;; intersection with a and put the result ;; in a similarly we hav or= ^= -= > a set([2]) ;; On bytes, bytearray and string objects all the following function works ;; see documentation py-format py-capitalize py-center py-endswith py-expandtabs py-find py-rfind py-isalnum py-isalpha py-isdigit py-islower py-isspace py-isupper py-istitle py-join py-ljust py-rjust py-rljust py-lower py-upper py-lstrip py-rstrip py-partition py-replace py-strip py-title py-rpartitio py-rindex py-split py-rsplit py-splitlines py-startswith py-swapcase py-translate py-zfill py-encode ;; translate a string object to a bytes object using UTF-8 per ;; default. py-decode ;; translates a bytes/bytearray object to a string object using ;; UTF-8 per default. ;; LISTS > (define l (py-list '(1 2 3 4))) > (pylist-ref l 0) 1 > (puylist-append! l 1) > l [1,2,3,4,1] > (pylist-slice 1 None None) ;; l[1:] [2,3,4,1] > (pylist-slice 1 2 None) ;; l[1:2] [2] > (pylist-slice None 2 None) ;; l[:2] [1,2] > (pylist-slice 1 None 2) ;; l[1:2:] [2,4] (pylist-subset l 1 3 None '(10 10)) ;; l[1:3] = '(10 10) > l [1,10,10,4,1] ;; pylist-ref and pylist-set! is single position setting and can be used for ;; hash-maps strings lists vectors python lists bytevectors bytes bytearrays ;; etc ;; We also have furthermore the following list and sequence types ;; pylist-insert! pylist-reverse! ;; pylist-append! pylist-listing pylist-set! ;; pylist-count pylist-null pylist-slice ;; pylist-delete! pylist-pop! pylist-sort! ;; pylist-extend! pylist-ref pylist-subset! ;; pylist-index pylist-remove! ;; FOR LOOPS ;; here is a generic map that works for all sequence types, > (define (map f l) (for ((x : l)) ((ret '())) (cons (f x) l) #:final l)) > (map (lambda (x) (+ "-" x)) "abc") ("-c "-b" "-a") > (map pk (bytes "abc")) ;; (97) ;; (98) ;; (99) > (define d (dict '((1 . 2) (3 . 4)))) > d 1: 2, 3: 4} > (for ((k v : d) (i : (range 10))) ((r -1)) (pk r k v i)) ;;; (-1 1 2 0) ;;; ( 0 3 4 1) ;; Further dictionary functions are: ;; py-copy py-fromkeys py-has_key py-items py-iteritems ;; py-iterkeys py-itervalues py-keys py-values ;; py-popitem py-setdefault py-update ;; py-hash-ref ;; LAMBDAS ;; One can get python lambda semantics if one wishes with = * ** ;; use (def (f (= x 1) (* l) (** kw)) ...) > (def (f a (* l) (= b 1) (** kw)) (list a l b kw)) > (f 1 2 3 #:q 1 #:w 2 #:b 3) (1 (2 3) 1 {"q": 1, "w": 2, "b": 3}) > (define f (lam (x y) (list x y))) > (f #:y 1 #:x 2) (2 1) ;; YIELD, python has a generator framework that i schemeified > (define-generator (gen1 yield l) (for-each yield l)) > (py-list (gen1 '(1 2 3))) [1, 2, 3] > (define gen2 (make-generator (lambda (yield l) (for ((x : l)) () (yield x))))) > (py-list (gen2 #(1 2 3))) [1, 2, 3] > (define-generator (gen3 yield l1 l2) (yield-from yield (gen1 l1)) (yield-from yield (gen2 l2))) > (py-list (gen3 '(1 2 3)) "abc") [1, 2, 3, "a", "b", "c"] ;; there is also utilities: ;; ;; next send sendException ;; ;; se Python doc's for for them On Thu, Sep 17, 2020 at 8:50 AM Zelphir Kaltstahl < zelphirkaltst...@posteo.de> wrote: > Hi Stefan! > > Can you explain a little more how it is used? > > If I understand correctly, one could write Scheme code, but with forms, > which implement (by themselves or in some combination) Python keywords > or Python semantics. You mentioned, that it does not have a Python > compiler. So there is no way of translating Python into the Scheme code > for those modules. Basically that is a different concern, separation of > concerns, modularization, better maintainability, etc.? > > Do you have an example project, where this separated code is used in? > > Regards, > Zelphir > > On 12.09.20 19:59, Stefan Israelsson Tampe wrote: > > Hi, > > > > I am the author of python-on-guile and I just took out the scheme > > infrastructure for python and put it is a self contained project of not > too > > large size. It does not have a python compiler and cannot use python > code. > > So scheme only. > > > > You can find the project at > > > > docs for the interfaces is mostly documented at, > > http://c-lambda.se/python-on-guile/ > > -- > repositories: https://notabug.org/ZelphirKaltstahl > >