ytzi/the-stack-v2-dedup-racket-macros · Datasets at Hugging Face

b7a785ff5eda05291d4cbe1a11edc040c09c86ca

42814fb3168a44672c8d69dbb56ac2e8898f042e

/private/accessor.ss

e9c05f15101fcae7e42f1caa031eb05c15bfffa8

[]

no_license

dyoo/gui-world

520096c3e66b904a9b361fe852be3c5e2ab35e88

41e52a1c4686cc6ee4014bf7ded2fcbec337f6eb

refs/heads/master

2016-09-06T14:54:13.316419

2009-04-02T19:10:18

159,708

1

0

null

UTF-8

Scheme

false

1,456

ss

accessor.ss

#lang scheme/base (require scheme/contract) ;; Accessors ;; ;; (accessorof world X) ;; where getter is (world -> X) ;; and updater is (world X -> world) (define-struct accessor (getter updater)) ;; get/accessor: (accessorof world X) world -> X ;; Gets at substructure within a world. (define (get/accessor acc a-world) ((accessor-getter acc) a-world)) ;; update/accessor: (accessorof world X) world X -> world ;; updates a substructure within the world, using the provided accessor. (define (update/accessor acc a-world a-val) ((accessor-updater acc) a-world a-val)) ;; chain-accessors: (accessorof world-1 world-2) (accessorof world-2 X) -> (accessorof world-1 X) (define (chain-accessors acc1 acc2) (make-accessor (lambda (a-world) ((accessor-getter acc2) ((accessor-getter acc1) a-world))) (lambda (a-world a-val) ((accessor-updater acc1) a-world ((accessor-updater acc2) ((accessor-getter acc1) a-world) a-val))))) (provide/contract [struct accessor ([getter (any/c . -> . any)] [updater (any/c any/c . -> . any)])] [get/accessor (accessor? any/c . -> . any)] [update/accessor (accessor? any/c any/c . -> . any)] [chain-accessors (accessor? accessor? . -> . accessor?)])

false

999022144f0d0801500170391fb2e9fd060826e1

2c01a6143d8630044e3629f2ca8adf1455f25801

/xitomatl/tests/sxml-tools/xtest-lib.sls

7c561455075d288b10efb87dca36804e53b51376

[ "X11-distribute-modifications-variant" ]

permissive

stuhlmueller/scheme-tools

e103fac13cfcb6d45e54e4f27e409adbc0125fe1

6e82e873d29b34b0de69b768c5a0317446867b3c

refs/heads/master

2021-01-25T10:06:33.054510

2017-05-09T19:44:12

1,092,490

5

1

null

UTF-8

Scheme

false

446

sls

xtest-lib.sls

#!r6rs ;; Copyright 2009 Derick Eddington. My MIT-style license is in the file named ;; LICENSE from the original collection this file is distributed with. (library (xitomatl tests sxml-tools xtest-lib) (export xtest-filter xtest-ppw) (import (rnrs) (xitomatl include) (rename (only (xitomatl common) pretty-print) (pretty-print pp))) (include/resolve ("xitomatl" "tests" "sxml-tools") "xtest-lib.scm") )

false

88361712eb61e033ef374c77f1a47c3e6c1dc2cb

6f86602ac19983fcdfcb2710de6e95b60bfb0e02

/input/exercises/queen-attack/queen-attack.scm

66ba0f6012f26642ffd0ca0f06a23d9b766091b1

[ "MIT", "CC-BY-SA-3.0" ]

permissive

exercism/scheme

a28bf9451b8c070d309be9be76f832110f2969a7

d22a0f187cd3719d071240b1d5a5471e739fed81

refs/heads/main

2023-07-20T13:35:56.639056

2023-07-18T08:38:59

30,056,632

34

37

MIT

2023-09-04T21:08:27

2015-01-30T04:46:03

Scheme

UTF-8

Scheme

false

69

scm

queen-attack.scm

(import (rnrs)) (define (attacking? white black) 'implement-me!)

false

bbd237ddab9c557ecb8987cca3e17180c970011c

9b2eb10c34176f47f7f490a4ce8412b7dd42cce7

/lib/yuni/ffi/abi/abiv0-runtime.sls

ef16aacf1945a88f3010568ab4eb1bb95818bc86

[ "LicenseRef-scancode-public-domain", "CC0-1.0" ]

permissive

okuoku/yuni

8be584a574c0597375f023c70b17a5a689fd6918

1859077a3c855f3a3912a71a5283e08488e76661

refs/heads/master

2023-07-21T11:30:14.824239

2023-06-11T13:16:01

2023-07-18T16:25:22

17,772,480

36

6

CC0-1.0

2020-03-29T08:16:00

2014-03-15T09:53:13

Scheme

UTF-8

Scheme

false

2,339

sls

abiv0-runtime.sls

(library (yuni ffi abi abiv0-runtime) (export yuniffi-abiv0-lookup/constants yuniffi-abiv0-lookup/bridgestubs yuniffi-abiv0-get-table yuniffi-abiv0-register-callback-helper!) (import (yuni scheme) (yuni ffi abi abiv0) (yuni compat bitwise primitives) (yuni compat ffi primitives)) ;; (define (constants-name x) (string-append x yuniffi-abiv0-export-suffix/constants)) (define (bridgestubs-name x) (string-append x yuniffi-abiv0-export-suffix/bridgestubs)) (define (lookupbody mod name) (yuniffi-module-lookup mod name)) (define (yuniffi-abiv0-lookup/constants module name) ;; => func / #f (lookupbody module (constants-name name))) (define (yuniffi-abiv0-lookup/bridgestubs module name) (lookupbody module (bridgestubs-name name))) (define (yuniffi-abiv0-register-callback-helper! func ptr) (define in (make-bytevector (* 8 4) 0)) (define out (make-bytevector (* 8 8))) (bv-write/u64! in 0 1) (bv-write/u64! in 8 0) (bv-write/w64ptr! in 16 ptr) (yuniffi-nccc-call func in 0 4 out 0 8) #t) (define (getrow func idx) ;; => ("name" flags value size offset) (define in (make-bytevector (* 8 4) 0)) (define out (make-bytevector (* 8 8))) (define out3v (make-bytevector 8)) ;; Setup in packet (bv-write/u64! in 8 idx) ;; Query (yuniffi-nccc-call func in 0 4 out 0 8) ;; Check for valid bit (let ((out0 (bv-read/u64 out 0)) (out1p (bv-read/w64ptr out (* 8 1))) (out2 (bv-read/u64 out (* 8 2))) (out4 (bv-read/u64 out (* 8 4))) (out5 (bv-read/u64 out (* 8 5)))) (when (not (= out0 0)) ;; Copy value (bytevector-copy! out3v 0 out (* 8 3) (* 8 4))) (and (not (= out0 0)) (list (and (not (= out0 YUNIFFI_SYMBOL__TERMINATE)) (ptr-read/asciiz out1p 0 (+ out2 1))) out0 ;; Flags out3v ;; Value out4 ;; Size and offset out5)))) (define (yuniffi-abiv0-get-table tbl) (define (itr idx cur) (define row (getrow tbl idx)) (if row (let ((flags (cadr row))) (if (= YUNIFFI_SYMBOL__TERMINATE flags) (reverse cur) (itr (+ 1 idx) (cons row cur))) ) (itr (+ 1 idx) cur))) (itr 1 '())) )

false

33aec0c8739b672f7a45b13886b8b7a857301a4c

c74dcb1facbd920d762017345171f47f8e41d0c5

/chapter_1/1.19.scm

3a72e18bbed9d2d57f79570df8e62f14a0b5d9f5

[]

no_license

akash-akya/sicp-exercises

5125c1118c7f0e4400cb823508797fb67c745592

c28f73719740c2c495b7bc38ee8b790219482b67

refs/heads/master

2021-06-15T19:12:47.679967

2019-08-03T14:03:20

136,158,517

0

null

UTF-8

Scheme

false

771

scm

1.19.scm

#lang sicp (define (fib n) (fib-iter 1 0 0 1 n)) (define (sq a) (* a a)) (define (cb a) (* a a a)) (define (comp-p p q) (+ (sq p) (* 2 p (sq q)) (* p (cb q)))) (define (comp-q p q) (* q (+ (* (sq q) (+ 1 p (sq p))) (* p (+ (* 2 p) q))))) (define (fib-iter a b p q count) (cond ((= count 0) b) ((even? count) (fib-iter a b (comp-p p q) (comp-q p q) (/ count 2))) (else (fib-iter (+ (* b q) (* a q) (* a p)) (+ (* b p) (* a q)) p q (- count 1)))))

false

0f699567eeed133baf0f748fe7484796197fcfc5

b380ad04b28001fb5633e86ff3f925375836c362

/display-until-valid.ss

8cdb093071bef10132041c2afd7b279089b277b9

[]

no_license

jeapostrophe/wtk

3cb3f70b1667e202ed254d57c1a6e0f391a0ed56

13424f3d0907b466de652b48e6e476c53c19ce93

refs/heads/master

2020-12-24T13:52:30.417406

2013-10-31T01:29:38

null

0

null

UTF-8

Scheme

false

7,426

ss

display-until-valid.ss

(module display-until-valid mzscheme (require (lib "plt-match.ss") (lib "etc.ss") (lib "list.ss") (lib "servlet.ss" "web-server")) (require (planet "number.ss" ("jaymccarthy" "mmss.plt" 1)) (planet "maybe.ss" ("jaymccarthy" "mmss.plt" 1))) (provide interface-version timeout start) ; data (define-struct (exn:fail:contract:form exn:fail:contract) ()) (define (raise-form-error msg) (raise (make-exn:fail:contract:form msg (current-continuation-marks)))) ; field : a * (request -> a) (define-struct field (init extract)) ; test (define interface-version 'v1) (define timeout 60) (define (start init-request) (match (form/macro) [(list name age) (send/back `(html (body (h1 "Success") (h2 ,name) (h3 ,(number->string age)))))])) (define (form/macro) (send/suspend/dispatch (lambda (embed/url) `(html (body ,(display-until-valid embed/url request errors embed/url/form ([name "Init" (match (extract-binding/single 'name (request-bindings request)) [(regexp "^[a-zA-Z0-9]+$" (list s)) s] [_ (raise-form-error "Error")])] [age 18 (with-handlers ([exn:fail? (lambda _ (raise-form-error "Error"))]) (string->number* (extract-binding/single 'age (request-bindings request))))]) `(form ([method "POST"] [action ,(embed/url/form (lambda () (list name age)))]) ,@(map (match-lambda [(struct just (err)) `(h2 ,err)]) (filter just? errors)) (input ([name "name"] [type "text"] [value ,name])) (input ([name "age"] [type "text"] [value ,(number->string age)])) (input ([type "submit"]))))))))) (define (form) (send/suspend/dispatch (lambda (embed/url) (define name (make-field "" (lambda (req) (match (extract-binding/single 'name (request-bindings req)) [(regexp "^[a-zA-Z0-9]+$" (list s)) s] [_ (raise-form-error "Error")])))) (define age (make-field 18 (lambda (req) (with-handlers ([exn:fail? (lambda _ (raise-form-error "Error"))]) (string->number* (extract-binding/single 'age (request-bindings req))))))) `(html (body ,(display-until-valid* embed/url (list name age) (match-lambda* [(list embed/url errors (list name age)) `(form ([method "POST"] [action ,(embed/url (match-lambda* [(list request (list name age)) (list name age)]))]) ,@(map (match-lambda [(struct just (err)) `(h2 ,err)]) (filter just? errors)) (input ([name "name"] [type "text"] [value ,name])) (input ([name "age"] [type "text"] [value ,(number->string age)])) (input ([type "submit"])))]))))))) (define-syntax display-until-valid (syntax-rules () [(_ embed/url request errors embed/url/form ([field init extract] ...) form) (let ([field (make-field init (lambda (request) extract))] ...) (display-until-valid* embed/url (list field ...) (lambda (basic-embed/url errors the-values) (define-syntax (embed/url/form stx) (syntax-case stx (lambda) [(e/u/f (lambda () body (... ...))) (with-syntax ([field (datum->syntax-object (syntax e/u/f) 'field)] ...) #`(basic-embed/url (lambda (request the-new-values) (let-values ([(field ...) (apply values the-new-values)]) body (... ...)))))])) (let-values ([(field ...) (apply values the-values)]) form))))])) ; extractv a = Okay a | Fail msg (define-struct extractv ()) (define-struct (extractv:okay extractv) (value)) (define-struct (extractv:fail extractv) (msg)) ; display-until-valid* : embed/url (list (field a^)) ((request (list a^)) -> alpha) -> alpha (define display-until-valid* (match-lambda* [(list embed/url (list (struct field (init extract)) ...) gen-form) (let/cc k (let loop ([errors empty] [values init]) (define (new-embed/url proc) (embed/url (lambda (request) (redirect/get) (let* ([extracts (map (lambda (extract) (with-handlers ([exn:fail:contract:form? (lambda (exn) (make-extractv:fail (exn-message exn)))]) (make-extractv:okay (extract request)))) extract)] [okay? (andmap extractv:okay? extracts)] [errors (map (match-lambda [(struct extractv:okay (v)) (make-nothing)] [(struct extractv:fail (msg)) (make-just msg)]) extracts)] [values (map (match-lambda* [(list (struct extractv:okay (new)) cur) new] [(list (struct extractv:fail (msg)) cur) cur]) extracts values)]) (if okay? (proc request values) (k (loop errors values))))))) (gen-form new-embed/url errors values)))])))

true

9ef96d3c7c19889dab4c2c4e05b7a3ffc21a6ff1

ac67f848928f0fb5d749fc19183c6ec601c37648

/src/parser.scm

7fa6d262b5bbbdfb5c5acb0ad1b538d5f8549725

[ "MIT" ]

permissive

mbal/parsifal

ce5ff84523c9a77c5617557239abe75540c50fa3

6d7d3ae041d71e7ef324f99925ad9ab0413e2b2a

refs/heads/master

2021-01-20T22:28:52.147131

2013-07-31T14:49:33

null

0

null

UTF-8

Scheme

false

13,927

scm

parser.scm

(module parser (many1 many sep-by sep-by1 either then bind word run str try succeed digit anychar parse char one-of skip-many skip-many1 named-bind <?> eof number defparser >> >>= letter between many-until opt stringify skip satisfy none-of after signed-number chainr1 chainr chainl1 chainl chainl1-exp chainl-exp chainr-exp chainr1-exp) (import chicken r5rs data-structures) (import utils state) (define (unexpected-input in state) (make-state (input state) (position state) (value state) #t (list "unexpected" in))) (define (unexpected sym state) (make-state (input state) (position state) (value state) #t (list "unexpected" sym))) (define (eof? x) (equal? x '())) ;; allows to define a combinator and defines alternatives names for the ;; function (using the symbol &). A combinator is a (partially curried) ;; function that takes one or more parsers, and a state. ;; ;; (defcomb ((name args) state) body) ;; is equivalent to ;; (define (name args) (lambda (state) body)) ;; ;; USAGE: ;; (defcomb ((NAME (& OTHERNAMES) P1 P2) STATE) ;; BODY) ;; ;; The whole (& OTHERNAMES) is optional. ;; It's possible to define a parser through the . notation, which means ;; that the parser will `reduce' (fold) the body of the function over the ;; list of parameters. ;; For example, (>> a b c d e) == (reduce2 >> (a b c d e)) == ;; (>> (>> (>> (>> a b) c) d) e) (define-syntax defcomb (syntax-rules (&) ((defcomb ((name (& altname altnames ...) params ...) state) body) (begin (defcomb ((name params ...) state) body) (define altname name) (define altnames name) ...)) ((defcomb ((name (& altname altnames ...) p q . rest) state) body) (begin (defcomb ((name p q . rest) state) body) (define altname name) (define altnames name) ...)) ((defcomb ((name params ...) state) body) (define (name params ...) (lambda (state) body))) ((defcomb ((name p q . rest) state) body) (define name (case-lambda ((p q) (lambda (state) body)) ((p q . rest) (reduce2 name (append (list p q) rest)))))))) ;;; transforms this: ;;; (bind anychar (lambda (c) (char c))) into this: ;;; (named-bind (c <- anychar) (char c)) (define-syntax named-bind (syntax-rules (<-) ((named-bind (x <- parser) body) (bind parser (lambda (x) body))) ((named-bind (x1 <- parser1) rest ...) (bind parser1 (lambda (x1) (named-bind rest ...)))) ((named-bind parser body) (then parser body)) ((named-bind parser body ...) (then parser (named-bind body ...))))) ;; defines a parser. ;; Wraps the body of the parser with a lambda expression, so you can ;; emulate lazyness without explicitly writing the closure. (define-syntax defparser (syntax-rules () ((defparser (name args) (body ...)) (define (name args) (lambda (state) ((body ...) state)))) ((defparser name (body ...)) (define name (lambda (state) ((body ...) state)))))) ;; runs p and, if not successful, returns the specified error. (defcomb ((<?> p err) state) (let ((result (p state))) (if (successful? result) result (copy-state-except result error (list err))))) ;; successful if the first character of the input satisfies ;; the predicate. ;; satisfy :: (Char -> Bool) -> Parser Char (defcomb ((satisfy pred) state) (let ((data (input state))) (if (eof? data) (unexpected "EOF" state) (if (pred (car data)) (make-state (cdr data) (+ 1 (position state)) (car data) #f #f) (unexpected-input (car data) state))))) ;; runs p1 and, if successful, runs p2. ;; is the then combinator associative? ;; EQUIVALENT TO haskell's >> (and to p1 >>= \x . p2) ;; (define then (bind p1 (lambda (x) p2))) ;; Is associative, as it follows from the monads laws. (defcomb ((then (& >>) p1 p2 . more) state) (let ((result1 (p1 state))) (if (successful? result1) (let ((result2 (p2 result1))) (copy-state-except result2 empty? (and (empty? result2) (empty? result1)))) result1))) (defparser (after p1 p2) (named-bind (x <- p1) p2 (succeed x))) (defcomb ((between bra ket inside) state) ;; yeah, pretty ugly. It's **almost** equivalent to ;; (named-bind bra (x <- (many inside)) ket (succeed x)), but: ;; (parse (between (char #\a) (char #\b) letter) "ajkbcdeb") ;; returns "jk", while the named-bind version raises an ;; unexpected EOF error. The named bind version is good enough for ;; e.g. comments in programming languages, since there are two ;; delimiters (e.g # and newline) that cannot appear anywhere ;; in the comment. Is it good enough for the general case? (let ((start (bra state))) (if (successful? start) (let loop ((prev start) (parsed '())) (let ((end (ket prev))) (if (successful? end) (copy-state-except end value (reverse parsed)) (let ((middle (inside prev))) (if (successful? middle) (loop middle (cons (value middle) parsed)) middle))))) (if (eof? (input state)) (unexpected "EOF" state) (unexpected-input (car (input state)) state))))) ;; this is the return in the monad. (defcomb ((succeed v) state) (copy-state-except state value v)) ;; bind :: Parser a -> (a -> Parser b) -> Parser b (defcomb ((bind (& >>=) p1 f) state) (let ((result1 (p1 state))) (if (successful? result1) (let ((result2 ((f (value result1)) result1))) (copy-state-except result2 empty? (and (empty? result2) (empty? result1)))) result1))) ;; runs p1, and, if successful, returns. If not not successful and ;; p1 didn't consume any input (i.e. it failed at the first match) ;; runs p2 (defcomb ((either (& <or>) p1 p2 . more) state) (let ((result1 (p1 state))) (if (and (not (successful? result1)) (empty? result1)) (p2 state) result1))) ;; kleene star operator. ;; many :: Parser a -> Parser [a] ;; basically, it allows to transform character parsers to string parsers. ;; equivalent to: ;; (either ;; (named-bind (x <- p) (xs <- (many p)) (succeed (cons x xs))) ;; (succeed '())) (defcomb ((many p) state) (let loop ((s state) (acc '())) (let ((result (p s))) (if (and (successful? result) (not (empty? result))) (loop result (cons (value result) acc)) (if (empty? result) (make-state (input result) (position result) (reverse acc) (empty? state) #f) result))))) ;; kleene plus (defparser (many1 p) (named-bind (x <- p) (y <- (many p)) (succeed (cons x y)))) (defparser (skip p) (then p (succeed '()))) (defparser (skip-many p) (either (then p (skip-many p)) (succeed '()))) (defparser (skip-many1 p) (then p (skip-many p))) ;; (try p) behaves like p, but, on failing, it pretends that nothing ;; happened (i.e. that the parser hasn't read any character) (defcomb ((try p) state) (let ((result (p state))) (if (successful? result) result (make-state (input state) (position state) (value state) #t (error result))))) (define (sep-by1 p sep) (named-bind (x <- p) (xs <- (many (then sep p))) (succeed (cons x xs)))) (define (sep-by p sep) (either (sep-by1 p sep) (succeed '()))) ;; parses p, and, as long as there is a binary operation op, this parser ;; reads it and another p, then applies the operator returned by the ;; parser op on the two values returned by the successive invocation of p. ;; The operator should be left associative. ;; Similar to chainl1-exp, but the operation is implicit from the parser. (define (chainl1 p op) (begin (define (func prev) (either (named-bind (o <- op) (b <- p) (func (o prev b))) (succeed prev))) (named-bind (a <- p) (in <- (func a)) (succeed in)))) ;; as chainl1, but returns a default if there's no initial match (define (chainl p op default) (either (chainl1 p op) (succeed default))) ;; accumulates p to the right. While it parses the sequence op p, it ;; traverse the string. When there are no more op, it rewinds itself, ;; folding back the results of p, applying `perform`. (define (chainr1 p op) (named-bind (a <- p) (either (named-bind (o <- op) (b <- (chainr1 p op)) (succeed (o a b))) (succeed a)))) (define (chainr p op default) (either (chainr1 p op) (succeed default))) ;; EXPLICIT VERSIONS of chainL/R. They are the same as the implicit version ;; but they take another parameter, which is the operator to apply to ;; the matches. (define (chainl1-exp p op perform) (begin (define (func prev) (either (named-bind op (b <- p) (func (perform prev b))) (succeed prev))) (named-bind (a <- p) (in <- (func a)) (succeed in)))) (define (chainl-exp p op perform default) (either (chainl1-exp p op perform) (succeed default))) (define (chainr1-exp p op perform) (named-bind (a <- p) (either (named-bind op (b <- (chainr1-exp p op perform)) (succeed (perform a b))) (succeed a)))) (define (chainr-exp p op perform default) (either (chainr1-exp p op perform) (succeed default))) ;; simpler derived parsers (define (char c) (satisfy (lambda (x) (char=? c x)))) (define letter (satisfy char-alphabetic?)) (define anychar (satisfy (constantly #t))) (define digit (satisfy char-numeric?)) (define (one-of l) (satisfy (lambda (x) (member x l)))) (define (none-of l) (satisfy (lambda (x) (not (member x l))))) (define (opt p #!optional (default '())) (either p (succeed default))) (define number (<?> (lambda (state) (let ((result ((many1 digit) state))) (if (successful? result) (copy-state-except result value (list->number (value result))) result))) "expected number")) (defparser signed-number (named-bind (s <- (opt (either (char #\+) (char #\-)) #\+)) (n <- number) (succeed (if (char=? #\+ s) n (- n))))) (define (word state) (let ((result ((many1 letter) state))) (if (successful? result) (copy-state-except result value (list->string (value result))) result))) ;; do you want a word, right? Let's get back the result to a string ;; this version is very general, and, in fact, in Haskell the whole ;; thing is called mapM. That this is hardly an improvement over ;; the standard recursive version. The only good thing is the ;; lack of explicit recursion, but since we are schemers, we don't ;; care about it very much ;; (foldr (lambda (m n) ;; (bind ;; (lambda (s1) (m s1)) ;; (lambda (x) ;; (bind (lambda (s1) (n s1)) ;; (lambda (xs) ;; (succeed (string-append1 x xs))))))) ;; (succeed "") (map-string char s))) ;; The following version is more or less equivalent, and should be ;; faster (but not as elegant as the Haskell mapM version) (define (str s) (foldr then (succeed s) (map-string char s))) (defparser (many-until repeat limit) (either (then limit (succeed '())) (named-bind (x <- repeat) (xs <- (many-until repeat limit)) (succeed (cons x xs))))) ;; matches if the input ends at the position (define (eof state) (if (eof? (input state)) state (unexpected-input (car (input state)) state))) (defparser (stringify p) (named-bind (x <- p) (succeed (list->string x)))) ;; ------------------------------------ (define (parse P input) (P (make-state (string->list input) 0 '() #t #f))) (define (prettify x) (define (loop xs acc) (cond ((null? xs) (reverse acc)) ((list? (car xs)) (loop (cdr xs) (cons (loop (car xs)) acc))) ((string? (car xs)) (loop (cdr xs) (cons (car xs) acc))) ((char? (car xs)) (loop (cdr xs) (cons (string (car xs)) acc))) ((number? (car x)) (loop (cdr xs) (cons (number->string (car xs)) acc))) (else (loop (cdr xs) acc)))) (apply string-append (intersperse (loop x '()) " "))) (define (run P input) (let ((result (parse P input))) (if (successful? result) (listify (value result)) (prettify (error result))))) )

true

4c2759fb1a6408cb7a42a84b3548f7a5bca24da7

de8cbafb251719894f5f97839b4dda1ec81ef996

/s17/generalized-set!.sls

bb5288d5db6ce9c27b1f3070dfc45f8c4bed972f

[ "X11-distribute-modifications-variant" ]

permissive

vkochan/srfi

7763d29633566ea6caa2e41cb2d1efcb4f4fd2da

5f9a207ddce01206fc2564b3cf185552809039df

refs/heads/master

2021-12-27T18:44:41.971933

2018-01-15T07:16:17

null

0

null

UTF-8

Scheme

false

5,807

sls

generalized-set!.sls

;; Copyright (C) Taylan Ulrich Bayırlı/Kammer (2015). All Rights Reserved. ;; Permission is hereby granted, free of charge, to any person obtaining ;; a copy of this software and associated documentation files (the ;; "Software"), to deal in the Software without restriction, including ;; without limitation the rights to use, copy, modify, merge, publish, ;; distribute, sublicense, and/or sell copies of the Software, and to ;; permit persons to whom the Software is furnished to do so, subject to ;; the following conditions: ;; The above copyright notice and this permission notice shall be ;; included in all copies or substantial portions of the Software. ;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #!r6rs (library (srfi s17 generalized-set!) (export (rename (%set! set!)) setter getter-with-setter) (import (rnrs base) (rnrs bytevectors) (rnrs hashtables) (rnrs mutable-strings) (rnrs mutable-pairs) (except (srfi s1) map for-each)) (begin (define-syntax %set! (syntax-rules () ((_ (getter arg ...) val) ((setter getter) arg ... val)) ((_ var val) (%set! var val)))) (define setter (let ((setters (make-eq-hashtable 64))) (letrec ((setter (lambda (proc) (hashtable-ref setters proc (lambda () (error "No setter for " proc))))) (set-setter! (lambda (proc setter) (hashtable-set! setters proc setter)))) (define (fn-swap-3-4 setter) (lambda (bv k e v) (setter bv k v e))) (set-setter! setter set-setter!) (set-setter! car set-car!) (set-setter! cdr set-cdr!) (set-setter! caar (lambda (p v) (set-car! (car p) v))) (set-setter! cadr (lambda (p v) (set-car! (cdr p) v))) (set-setter! cdar (lambda (p v) (set-cdr! (car p) v))) (set-setter! cddr (lambda (p v) (set-cdr! (cdr p) v))) (set-setter! caaar (lambda (p v) (set-car! (caar p) v))) (set-setter! caadr (lambda (p v) (set-car! (cadr p) v))) (set-setter! cadar (lambda (p v) (set-car! (cdar p) v))) (set-setter! caddr (lambda (p v) (set-car! (cddr p) v))) (set-setter! cdaar (lambda (p v) (set-cdr! (caar p) v))) (set-setter! cdadr (lambda (p v) (set-cdr! (cadr p) v))) (set-setter! cddar (lambda (p v) (set-cdr! (cdar p) v))) (set-setter! cdddr (lambda (p v) (set-cdr! (cddr p) v))) (set-setter! list-ref (lambda (l n v) (let loop ((l l)) (cond ((zero? n) (set-car! l v)) (else (loop (cdr l))))))) (set-setter! vector-ref vector-set!) (set-setter! string-ref string-set!) (set-setter! hashtable-ref hashtable-set!) (set-setter! bytevector-uint-ref (lambda (bv k e s n) (bytevector-uint-set! bv k n e s))) (set-setter! bytevector-sint-ref (lambda (bv k e s n) (bytevector-sint-set! bv k n e s))) (set-setter! bytevector-u8-ref bytevector-u8-set!) (set-setter! bytevector-s8-ref bytevector-s8-set!) (set-setter! bytevector-u16-ref (fn-swap-3-4 bytevector-u16-set!)) (set-setter! bytevector-s16-ref (fn-swap-3-4 bytevector-s16-set!)) (set-setter! bytevector-u32-ref (fn-swap-3-4 bytevector-u32-set!)) (set-setter! bytevector-s32-ref (fn-swap-3-4 bytevector-s32-set!)) (set-setter! bytevector-u64-ref (fn-swap-3-4 bytevector-u64-set!)) (set-setter! bytevector-s64-ref (fn-swap-3-4 bytevector-s64-set!)) (set-setter! bytevector-u16-native-ref bytevector-u16-native-set!) (set-setter! bytevector-s16-native-ref bytevector-s16-native-set!) (set-setter! bytevector-u32-native-ref bytevector-u32-native-set!) (set-setter! bytevector-s32-native-ref bytevector-s32-native-set!) (set-setter! bytevector-u64-native-ref bytevector-u64-native-set!) (set-setter! bytevector-s64-native-ref bytevector-s64-native-set!) (set-setter! bytevector-ieee-single-ref (fn-swap-3-4 bytevector-ieee-single-set!)) (set-setter! bytevector-ieee-single-ref (fn-swap-3-4 bytevector-ieee-single-set!)) (set-setter! bytevector-ieee-double-ref (fn-swap-3-4 bytevector-ieee-double-set!)) (set-setter! bytevector-ieee-double-ref (fn-swap-3-4 bytevector-ieee-double-set!)) (set-setter! bytevector-ieee-single-native-ref bytevector-ieee-single-native-set!) (set-setter! bytevector-ieee-single-native-ref bytevector-ieee-single-native-set!) (set-setter! bytevector-ieee-double-native-ref bytevector-ieee-double-native-set!) (set-setter! bytevector-ieee-double-native-ref bytevector-ieee-double-native-set!) setter))) (define (getter-with-setter get set) (let ((proc (lambda args (apply get args)))) (%set! (setter proc) set) proc)) ))

true

04f3a0df561cac12fa8d272a623f370d04630b55

d881dacf2327ecd474f11318ea8e2b9536fe3e73

/srfi-tools/local.example.sld

76ee359f58516cf38d46f51017cde33e1b070eda

[ "MIT" ]

permissive

scheme-requests-for-implementation/srfi-common

a84c7eaa6a40a4d1b80ef723759c2d3aed480177

78b45ab8028cfbd462fb1231cafec4ff4c5c5d30

refs/heads/master

2023-07-19T23:14:26.615668

2023-07-14T18:03:06

37,961,335

31

7

MIT

2023-05-11T13:57:14

2015-06-24T04:00:50

HTML

UTF-8

Scheme

false

1,000

sld

local.example.sld

(define-library (srfi-tools local) (import (scheme base) (srfi-tools private command) (srfi-tools private external) (srfi-tools core) (srfi-tools data) (srfi-tools path) (srfi-tools interactive)) (begin ;; You can define custom commans in this file. For example: (define-command (links num) "Browse SRFI <num> using the links browser." (browse-url-with "links" (srfi-html-file (parse-srfi-number num)))) (define-command (lynx num) "Browse SRFI <num> using the Lynx browser." (browse-url-with "lynx" (srfi-html-file (parse-srfi-number num)))) (define-command (w3m num) "Browse SRFI <num> using the W3M browser." (browse-url-with "w3m" (srfi-html-file (parse-srfi-number num)))) ;; Define what you want the shell command `srfi` to do. (srfi-default-command "list") ;; Define what you want the shell command `srfi 123` to do. (srfi-default-number-command "info")))

false

c6ce40b1d081d3ff2ed3af056f1e6e9335faf123

3604661d960fac0f108f260525b90b0afc57ce55

/SICP-solutions/2/2.88-sub-poly.scm

4874cff7b751fd0382fb9f44dcf981a55c390c78

[]

no_license

rythmE/SICP-solutions

b58a789f9cc90f10681183c8807fcc6a09837138

7386aa8188b51b3d28a663958b807dfaf4ee0c92

refs/heads/master

2021-01-13T08:09:23.217285

2016-09-27T11:33:11

69,350,592

0

null

UTF-8

Scheme

false

380

scm

2.88-sub-poly.scm

;;for generic package (define (negtive x) (apply-generic 'negtive x)) ;;for ploy package (define (sub-poly p1 p2) (add-poly p1 (negtive p2))) (put 'negtive '(polynomial) (lambda (x) (define (neg p t) (if (empty-termlist? p) t (neg (rest-terms p) (adjoin-term (make-term (order (first-term p)) (- 0 (coeff (first-term p)))))))) (neg x '())))

false

9547df2bd6463f4772a175f3cb78ceff84e2aff1

1a64a1cff5ce40644dc27c2d951cd0ce6fcb6442

/testing/ffi/examples/magick.ss

1beec942051ac30366916844416e238fc25ecc00

[]

no_license

skchoe/2007.rviz-objects

bd56135b6d02387e024713a9f4a8a7e46c6e354b

03c7e05e85682d43ab72713bdd811ad1bbb9f6a8

refs/heads/master

2021-01-15T23:01:58.789250

2014-05-26T17:35:32

null

0

null

UTF-8

Scheme

false

12,731

ss

magick.ss

#! /usr/bin/env mzscheme #lang scheme/base (require ffi/magick (for-syntax scheme/base)) (define-syntax (test stx) (syntax-case stx () [(_ (func arg ...)) (with-syntax ([(tmp ...) (generate-temporaries #'(arg ...))]) #'(let ([tmp arg] ...) (printf ">>> ~s~s\n" 'func `(,tmp ...)) (let ([r (func tmp ...)]) (printf " -> ~s\n" r) r)))])) ;; (test (MagickGetPackageName)) ;; (test (MagickGetCopyright)) ;; (test (MagickGetVersion)) ;; (test (MagickGetReleaseDate)) ;; (test (MagickGetQuantumDepth)) ;; (test (MagickQueryConfigureOptions "CO*")) ;; (test (MagickQueryFonts "Cou*")) ;; (test (MagickQueryFormats "J*")) ;; (test (MagickGetHomeURL)) ;; (define w (test (NewMagickWand))) ;; (test (MagickGetImageFilename w)) ;; (test (MagickReadImage w "~/html/images/eli.jpg")) (define w (test (MagickReadImage "~/html/images/eli.jpg"))) ;; (test (MagickGetImageFilename w)) ;; (test (MagickGetImageFilename w)) ;; (test (MagickGetImageFormat w)) ;; (test (MagickGetImageCompression w)) ;; (test (MagickGetImageDispose w)) ;; (test (MagickGetImageType w)) ;; (test (MagickGetImageInterlaceScheme w)) ;; (test (MagickGetImageIndex w)) ;; (test (MagickGetImageSize w)) ;; (test (MagickGetImageSignature w)) ;; (test (MagickBlurImage w 2.0 1.0)) ;; ;; (test (MagickReadImage w "~/html/images/eeli.jpg")) ;; ;; (test (MagickGetException w)) ;; (test (MagickSwirlImage w 90.0)) ;; (test (MagickWaveImage w 4.0 40.0)) ;; (test (MagickCharcoalImage w 5.0 0.7)) ;; (test (MagickGetImageCompose w)) ;; (test (MagickGetImageColorspace w)) ;; (test (MagickCommentImage w "This is my test image")) ;; (test (MagickWriteImage w "~/tmp/x.jpg")) ;; (test (MagickDisplayImage w #f)) ;; (test (MagickDescribeImage w)) ;; (test (MagickGetImageWidth w)) ;; (test (MagickGetImageHeight w)) ;; (test (MagickGetImageChannelDepth w 'RedChannel)) ;; (test (MagickGetImageExtrema w)) ;; (test (MagickGetImageChannelExtrema w 'RedChannel)) ;; (test (MagickGetImageChannelMean w 'RedChannel)) ;; (test (MagickGetImageColors w)) ;; (test (MagickGetImageDelay w)) ;; (test (MagickSetImageDelay w 20)) ;; (test (MagickGetImageDelay w)) ;; (test (MagickGetImageDepth w)) ;; (test (MagickSetImageDepth w 2)) ;; (test (MagickGetImageDepth w)) ;; (test (MagickGetImageIterations w)) ;; (test (MagickSetImageIterations w 4)) ;; (test (MagickGetImageIterations w)) ;; (test (MagickGetSamplingFactors w)) ;; (test (MagickSetSamplingFactors w '(2.0 1.0 0.5))) ;; (test (MagickGetSamplingFactors w)) ;; (test (MagickGetImageRenderingIntent w)) ;; (test (MagickSetImageRenderingIntent w 'SaturationIntent)) ;; (test (MagickGetImageRenderingIntent w)) ;; (test (MagickGetImageUnits w)) ;; (test (MagickSetImageUnits w 'PixelsPerInchResolution)) ;; (test (MagickGetImageUnits w)) ;; (test (MagickGetImageVirtualPixelMethod w)) ;; (test (MagickSetImageVirtualPixelMethod w 'EdgeVirtualPixelMethod)) ;; (test (MagickGetImageVirtualPixelMethod w)) ;; (test (MagickGetImageWhitePoint w)) ;; (test (MagickSetImageWhitePoint w 3.0 4.0)) ;; (test (MagickGetImageWhitePoint w)) ;; (test (MagickGetImageResolution w)) ;; (test (MagickSetImageResolution w 33.0 33.0)) ;; (test (MagickGetImageResolution w)) ;; (test (MagickGetSize w)) ;; (test (MagickSetSize w 20 20)) ;; (test (MagickGetSize w)) ;; (test (MagickGetImageProfile w "ICC")) ;; (test (MagickAdaptiveThresholdImage w 2 2 0)) ;; (test (MagickAddNoiseImage w 'LaplacianNoise)) ;; (test (MagickEmbossImage w 1.0 0.5)) ;; (test (MagickEvaluateImage w 'MaxEvaluateOperator 30768.0)) ;; (test (MagickEvaluateImage w 'MinEvaluateOperator 34768.0)) ;; (test (MagickEvaluateImageChannel w 'RedChannel 'MaxEvaluateOperator 28768.0)) ;; (test (MagickEvaluateImageChannel w 'RedChannel 'MinEvaluateOperator 36768.0)) ;; (test (MagickGetImageGamma w)) ;; (test (MagickGammaImage w 0.5)) ;; (test (MagickSetImageGamma w 0.5)) ;; (test (MagickGetImageGamma w)) ;; (test (MagickGaussianBlurImage w 5.0 2.0)) ;; (test (MagickGaussianBlurImageChannel w 'RedChannel 1.0 0.1)) ;; (test (MagickGetImageRedPrimary w)) ;; (test (MagickSetImageRedPrimary w 20.0 20.0)) ;; (test (MagickGetImageRedPrimary w)) ;; (test (MagickTransformImage w "120x120+10+10" "100x100+0+0")) ;; (test (MagickThresholdImage w 32768.0)) ;; (test (MagickThresholdImageChannel w 'RedChannel 32768.0)) ;; (test (MagickSpreadImage w 2.0)) ;; (test (MagickOilPaintImage w 3.0)) ;; (test (MagickSpliceImage w 100 100 50 50)) ;; (test (MagickSolarizeImage w 2.0)) ;; (test (MagickShaveImage w 20 50)) ;; (test (MagickSharpenImage w 10.0 9.0)) ;; (test (MagickPosterizeImage w 2 #t)) ;; (test (MagickContrastImage w 20)) ;; (test (MagickEdgeImage w 5.0)) ;; (test (MagickImplodeImage w 0.5)) ;; (test (MagickConvolveImage ;; w '(( 0.0 -1.0 0.0) ; sharpen ;; (-1.0 5.0 -1.0) ;; ( 0.0 -1.0 0.0)))) ;; (test (MagickConvolveImage ; sharpen++ ;; w '((-1.0 -1.0 -1.0) ;; (-1.0 9.0 -1.0) ;; (-1.0 -1.0 -1.0)))) ;; (test (MagickConvolveImage ; blur ;; w '(( 1.0 1.0 1.0) ;; ( 1.0 1.0 1.0) ;; ( 1.0 1.0 1.0)))) ;; (test (MagickConvolveImage ; edge enhance ;; w '(( 0.0 0.0 0.0) ;; (-1.0 1.0 0.0) ;; ( 0.0 0.0 0.0)))) ;; (test (MagickConvolveImage ; edge enhance++ ;; w '((-1.0 0.0 1.0) ;; (-1.0 0.0 1.0) ;; (-1.0 0.0 1.0)))) ;; (test (MagickConvolveImage ; edge detect ;; w '(( 0.0 1.0 0.0) ;; ( 1.0 -4.0 1.0) ;; ( 0.0 1.0 0.0)))) ;; (test (MagickConvolveImage ; emboss ;; w '((-2.0 -1.0 0.0) ;; (-1.0 1.0 1.0) ;; ( 0.0 1.0 2.0)))) ;; (test (MagickConvolveImageChannel ;; w 'RedChannel '((1.0 0.0 0.0 0.0 1.0) ;; (0.0 0.0 0.0 0.0 0.0) ;; (0.0 0.0 -1.0 0.0 0.0) ;; (0.0 0.0 0.0 0.0 0.0) ;; (1.0 0.0 0.0 0.0 1.0)))) ;; (define pixels (test (MagickGetImagePixels w 0 0 40 40 "RGB" 'ShortPixel))) ;; (test (MagickSetImagePixels ;; w 0 0 "RGB" 'ShortPixel ;; (let ([pixels (map (lambda (x) (append x x)) ;; pixels)]) ;; (append pixels ;; (map (lambda (row) ;; (map (lambda (pixel) ;; (list (cadr pixel) (caddr pixel) (car pixel)) ;; ;; (map (lambda (v) (- 65535 v)) pixel) ;; ) ;; row)) ;; pixels))))) ;; (test (MagickLabelImage w "FOO")) ;; (test (MagickLevelImage w 20000.0 1.0 45535.0)) ;; (test (MagickMedianFilterImage w 2.0)) ;; (test (MagickModulateImage w 100.0 100.0 40.0)) ;; (test (MagickMotionBlurImage w 10.0 10.0 60.0)) ;; (test (MagickNegateImage w #f)) ;; (test (MagickNegateImageChannel w 'GreenChannel #f)) ;; (test (MagickNormalizeImage w)) ;; (test (MagickRaiseImage w 10 10 20 20 #f)) ;; (MagickMinifyImage w) (MagickMinifyImage w) (MagickMinifyImage w) ;; (test (MagickResampleImage w 576.0 576.0 'UndefinedFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'BoxFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'TriangleFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'HermiteFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'HanningFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'HammingFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'BlackmanFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'GaussianFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'QuadraticFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'CubicFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'CatromFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'MitchellFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'LanczosFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'BesselFilter 1.0)) ;; (test (MagickResampleImage w 576.0 576.0 'SincFilter 1.0)) ;; (test (MagickOpaqueImage w "black" "yellow" 20000.0)) ;; (test (MagickColorFloodfillImage w "yellow" 20000.0 "black" 0 0)) ;; (test (MagickColorFloodfillImage w "yellow" 20000.0 #f 0 0)) ;; (test (MagickColorFloodfillImage w '(65535 0 0) 20000.0 "black" 0 0)) ;; (test (MagickColorFloodfillImage w '(65535 0 0 32737) 20000.0 "black" 0 0)) ;; (test (MagickTransparentImage w "black" 16384 20000.0)) ;; (test (MagickWriteImage w "~/tmp/x.png")) ;; (test (MagickResetIterator w)) ;; (test (MagickGetImageProfile w "ICC")) ;; (test (MagickSetImageProfile w "ICC" "foo")) ;; (test (MagickGetImageProfile w "ICC")) ;; (test (MagickGetImageBackgroundColor w)) ;; (test (MagickDisplayImage w)) ;; (for-each ;; (lambda (p) (MagickDisplayImage (test (MagickPreviewImages w p)))) ;; '(UndefinedPreview RotatePreview ShearPreview RollPreview HuePreview ;; SaturationPreview BrightnessPreview GammaPreview SpiffPreview DullPreview ;; GrayscalePreview QuantizePreview DespecklePreview ReduceNoisePreview ;; AddNoisePreview SharpenPreview BlurPreview ThresholdPreview ;; EdgeDetectPreview SpreadPreview SolarizePreview ShadePreview RaisePreview ;; SegmentPreview SwirlPreview ImplodePreview WavePreview OilPaintPreview ;; CharcoalDrawingPreview JPEGPreview)) ;; (test (MagickDisplayImage ;; (MagickFxImageChannel w 'AllChannels "(p[-4,-4].r+p[4,4].g)/2"))) ;; (test (MagickMagnifyImage w)) ;; (let ([ww (CloneMagickWand w)]) ;; (test (MagickMinifyImage ww)) ;; (test (MagickMinifyImage ww)) ;; (test (MagickMinifyImage ww)) ;; (test (MagickDisplayImage (MagickTextureImage w ww)))) ;; (test (MagickChopImage w 100 100 10 10)) ;; (test (MagickCropImage w 100 100 10 10)) ;; (test (MagickDisplayImage w)) ;; (define w1 (test (CloneMagickWand w))) ;; (test (MagickBlurImage w1 1.0 0.18)) ;; (define t (cadr (test (MagickCompareImageChannels ;; w w1 'RedChannels 'MeanSquaredErrorMetric)))) ;; (test (MagickDisplayImage t)) ;; (test (MagickReadImage w "~/html/images/EliRegina.jpg")) ;; (define morph (test (MagickMorphImages w 20))) ;; (test (MagickWriteImage morph "~/tmp/x.gif")) ;; (MagickAnimateImages morph) ;; (let ([x (test (MagickWriteImageBlob w))]) ;; (with-output-to-file "~/tmp/x" (lambda () (display x)) 'truncate) ;; (let ([ww (NewMagickWand)]) ;; (test (MagickReadImageBlob ww x)) ;; (MagickDisplayImage ww))) ;; (define w (test (NewMagickWand))) ;; (test (MagickReadImage w "~/html/images/spinlambda.gif")) ;; (test (MagickDisplayImage (test (MagickAppendImages w #f)))) ;; (test (MagickDisplayImage (MagickAverageImages w))) ;; (test (MagickDisplayImage (test (MagickDeconstructImages w)))) ;; (MagickAnimateImages w) ;; (let ([y (NewPixelWand "yellow")] ;; [c (test (PixelGetQuantumColor "yellow"))] ;; [r (NewPixelWand "red")] ;; [rgb (lambda (p) ;; (map (lambda (f) (f p)) ;; (list PixelGetRedQuantum ;; PixelGetGreenQuantum ;; PixelGetBlueQuantum)))]) ;; (printf ">>> y = ~s\n" (rgb y)) ;; (printf ">>> r1 = ~s\n" (rgb r)) ;; (PixelSetQuantumColor r c) ;; (printf ">>> r2 = ~s\n" (rgb r))) ;; (define i (test (NewPixelRegionIterator w 0 0 10 10))) ;; (test (PixelSetIteratorRow i 5)) ;; (test (map PixelGetRedQuantum (PixelGetNextRow i))) ;; (test (map PixelGetRedQuantum (PixelGetNextRow i))) ;; (test (map PixelGetRedQuantum (PixelGetNextRow i))) (define d (test (NewDrawingWand))) ;; (test (DrawGetTextEncoding d)) ;; (test (MagickQueryFonts "Cou*")) (test (DrawSetFont d "Courier-Bold")) (test (DrawGetFont d)) (test (DrawSetFontSize d 96.0)) (test (DrawSetFontStretch d 'UltraCondensedStretch)) (test (DrawSetFontStyle d 'ObliqueStyle)) (test (DrawSetFontWeight d 24)) (test (DrawSetGravity d 'CenterGravity)) (test (DrawGetStrokeDashArray d)) (test (DrawSetStrokeDashArray d '(20.0 20.0))) (test (DrawGetStrokeDashArray d)) (test (DrawSetStrokeColor d "red")) (test (DrawSetStrokeAntialias d #t)) (test (DrawSetStrokeWidth d 5.0)) (test (DrawSetStrokeLineCap d 'RoundCap)) (test (DrawSetStrokeOpacity d 0.5)) ;; (test (DrawLine d 0.0 0.0 200.0 200.0)) (define line '((10.0 10.0) (100.0 100.0) (100.0 10.0) (50.0 20.0))) ;; (test (DrawPolyline d line)) ;; (test (DrawPolygon d line)) ;; (test (DrawBezier d line)) ;; (test (DrawLine d 0.0 0.0 100.0 100.0)) ;; (test (DrawLine d 5.0 0.0 105.0 100.0)) ;; (test (DrawLine d 10.0 0.0 110.0 100.0)) (test (DrawAffine d '(0.0 1.0 1.0 0.5 0.0 0.0))) (test (DrawAnnotation d 0.0 0.0 "FOO")) ;; (test (DrawArc d 0.0 0.0 100.0 100.0 0.0 270.0)) ;; (test (DrawCircle d 50.0 50.0 50.0 0.0)) (test (MagickDrawImage w d)) (test (MagickDisplayImage w))

true

ec945ff35e5db628b5c38c4331474010b0cfcb51

a74932f6308722180c9b89c35fda4139333703b8

/edwin48/reccom.scm

9d913d96051f5820e7828d23ce511b0868db07b9

[]

no_license

scheme/edwin48

16b5d865492db5e406085e8e78330dd029f1c269

fbe3c7ca14f1418eafddebd35f78ad12e42ea851

refs/heads/master

2021-01-19T17:59:16.986415

2014-12-21T17:50:27

1,035,285

39

10

null

2022-02-15T23:21:14

2010-10-29T16:08:55

Scheme

UTF-8

Scheme

false

4,780

scm

reccom.scm

#| -*-Scheme-*- $Id: reccom.scm,v 1.20 2008/01/30 20:02:04 cph Exp $ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Massachusetts Institute of Technology This file is part of MIT/GNU Scheme. MIT/GNU Scheme is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. MIT/GNU Scheme is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with MIT/GNU Scheme; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. |# ;;;; Rectangle Commands (define rectangle-ring (list 'RECTANGLE)) (define (delete-rectangle mark1 mark2 #!optional fill-flag move?) ;mark2 is always "point" (let ((fill-flag (and (not (default-object? fill-flag)) fill-flag)) (move? (and (not (default-object? move?)) move?))) (let* ((mark-order (if (mark> mark1 mark2) (cons mark2 mark1) (cons mark1 mark2))) (first (car mark-order)) (last (cdr mark-order)) (column-order (let ((c1 (mark-column first)) (c2 (mark-column last))) (if (< c1 c2) (cons c1 c2) (cons c2 c1)))) (column1 (car column-order)) (column2 (cdr column-order)) (spacenum (- column2 column1)) (spacenum$ (make-string spacenum #\space))) (define (iter line-mark ring-list) (let ((perm-mark (if line-mark (mark-left-inserting line-mark) #f))) (if (or (not perm-mark) (mark> perm-mark last)) ring-list (let* ((mark-1 (mark-permanent! (move-to-column perm-mark column1))) (mark-2 (mark-permanent! (move-to-column perm-mark column2))) (line$ (extract-string mark-1 mark-2))) (if (not move?) (delete-string mark-1 mark-2)) (if fill-flag (let ((colend (mark-column (line-end mark-1 0)))) (if (< colend column1) (set! mark-1 (make-space-to-column column1 mark-1))) (insert-string spacenum$ mark-1))) (iter (line-start perm-mark 1) (append ring-list (list line$))))))) (iter first (list spacenum))))) (define-command kill-rectangle "Delete rectangle with corners at point and mark; save as last killed one." () (lambda () (set-cdr! rectangle-ring (delete-rectangle (current-mark) (current-point))))) (define-command delete-rectangle "Delete (don't save) text in rectangle with point and mark as corners. The same range of columns is deleted in each line starting with the line where the region begins and ending with the line where the region ends." () (lambda () (delete-rectangle (current-mark) (current-point)))) (define-command open-rectangle "Blank out rectangle with corners at point and mark, shifting text right. The text previously in the region is not overwritten by the blanks, but instead winds up to the right of the rectangle." () (lambda () (delete-rectangle (current-mark) (current-point) #t #t))) (define-command clear-rectangle "Blank out rectangle with corners at point and mark. The text previously in the region is overwritten by the blanks." () (lambda () (delete-rectangle (current-mark) (current-point) #t))) (define (make-space-to-column column mark) (let ((mark (mark-permanent! mark))) (change-column column mark) (line-end mark 0))) (define (yank-rectangle rectangle point) (let ((goal (mark-column point))) (if (null? (cdr rectangle)) (editor-error "No rectangle to yank.") (let ((columns (cadr rectangle))) (define (iter line-mark before-line-mark insert$) (if (not (null? insert$)) (let* ((next$ (car insert$)) (sl (string-length next$)) (final$ (if (< sl columns) (string-append next$ (Make-string (- columns sl) #\space)) next$)) (end-of-line (if line-mark (mark-left-inserting line-mark) (let () (insert-newline before-line-mark) before-line-mark))) (current-col (mark-column end-of-line))) (insert-string final$ (if (< current-col goal) (make-space-to-column goal end-of-line) (move-to-column end-of-line goal))) (iter (line-end end-of-line 1) end-of-line (cdr insert$))))) (iter (line-end point 0) point (cddr rectangle)))))) (define-command yank-rectangle "Yank the last killed rectangle with upper left corner at point." () (lambda () (yank-rectangle rectangle-ring (current-point))))

false

d4aff529a9fb7b0a65fe3ea6f9a3427faef45da7

be06d133af3757958ac6ca43321d0327e3e3d477

/99problems/12.scm

483d957d9b2cf911640627239a20e3bd5f1d5948

[]

no_license

aoyama-val/scheme_practice

39ad90495c4122d27a5c67d032e4ab1501ef9c15

f133d9326699b80d56995cb4889ec2ee961ef564

refs/heads/master

2020-03-13T12:14:45.778707

2018-04-26T07:12:06

131,115,150

0

null

UTF-8

Scheme

false

137

scm

12.scm

(define (sum-list lis) (cond ((null? lis) 0) (else (+ (car lis) (sum-list (cdr lis)))))) (print (sum-list '(1 2 3 4 5))) ; 15

false

166ca3993418c3b6c1bfaeea0f7e44372525ecfb

a4cd5242b2825972f6c8b905ade8d13b10ed9bf2

/test-all.scm

0f76301994b28ef17602e424389dcc047b2767c6

[]

no_license

zephyrfalcon/nepenthe

c46d7ec785a0bb4aa197d153a7da78ba40877032

2891f1aae55f728d235f81384134bd5299bf3bd5

refs/heads/master

2021-01-10T22:06:20.097187

2016-08-20T21:04:35

5,472,352

1

null

UTF-8

Scheme

false

228

scm

test-all.scm

;; test-all.scm ;; Just load the test-*.scm files here. (use test) ;; set parameters (current-test-verbosity #f) (load "test-tools") (load "test-opcodes") (load "test-assembler") (load "test-disassembler") (load "test-sasm")

false

e7d8671db595e708c75fc0bc6c472ab54b586c5b

23a00b9f5709b38169e0514cd3965d8b6f1f3863

/lib/compiler/reader/lexer.sld

5b7e70473a8e0a1b2beea09a9ba5b59ed153f8cb

[]

no_license

uson-compiladores/r7rs-scheme

cd80812ed335fa24e78522005df95ccdfbb544c4

dd88b31b260687aa9c702b659d54a7a3f60c7047

refs/heads/master

2021-01-10T02:09:16.711983

2015-12-01T01:04:56

45,621,985

0

null

UTF-8

Scheme

false

259

sld

lexer.sld

(define-library (compiler reader lexer) (import (scheme base) (compiler utils regex) (compiler utils lexer) (compiler utils scanner) (streams)) (export r4rs-lex test-r4rs-lex) ;(include "./lexer/spec.scm") (include "./lexer/r4rs.scm"))

false

b833b70ee192e384f264c0a2525d2215a50c6e79

b62560d3387ed544da2bbe9b011ec5cd6403d440

/cogs/time/cog.scm

d820e62d894583e1e0896fd835bc2fe327896595

[ "LicenseRef-scancode-unknown-license-reference", "MIT", "Apache-2.0" ]

permissive

mattwparas/steel

c6fb91b20c4e613e6a8db9d9310d1e1c72313df2

700144a5a1aeb33cbdb2f66440bbe38cf4152458

refs/heads/master

2023-09-04T03:41:35.352916

2023-09-01T03:26:01

241,949,362

207

10

Apache-2.0

2023-09-06T04:31:21

2020-02-20T17:39:28

Rust

UTF-8

Scheme

false

127

scm

cog.scm

(define package-name 'steel/time) (define version "0.1.0") ;; Core library, requires no dependencies (define dependencies '())

false

2b9dedc446858c37173f2be6bbdd785cb4dfff97

ab05b79ab17619f548d9762a46199dc9eed6b3e9

/sitelib/ypsilon/pango/language.scm

dab85485b7c5d8b36e580de589920b4557ee6171

[ "BSD-2-Clause" ]

permissive

lambdaconservatory/ypsilon

2dce9ff4b5a50453937340bc757697b9b4839dee

f154436db2b3c0629623eb2a53154ad3c50270a1

refs/heads/master

2021-02-28T17:44:05.571304

2017-12-17T12:29:00

2020-03-08T12:57:52

245,719,032

1

0

NOASSERTION

2020-03-07T23:08:26

2020-03-07T23:08:25

null

UTF-8

Scheme

false

2,210

scm

language.scm

#!nobacktrace ;;; Ypsilon Scheme System ;;; Copyright (c) 2004-2009 Y.FUJITA / LittleWing Company Limited. ;;; See license.txt for terms and conditions of use. (library (ypsilon pango language) (export pango_language_from_string pango_language_get_default pango_language_get_sample_string pango_language_get_scripts pango_language_get_type pango_language_includes_script pango_language_matches pango_language_to_string) (import (rnrs) (ypsilon ffi)) (define lib-name (cond (on-linux "libpango-1.0.so.0") (on-sunos "libpango-1.0.so.0") (on-freebsd "libpango-1.0.so.0") (on-openbsd "libpango-1.0.so.0") (on-darwin "Gtk.framework/Gtk") (on-windows "libpango-1.0-0.dll") (else (assertion-violation #f "can not locate Pango library, unknown operating system")))) (define lib (load-shared-object lib-name)) (define-syntax define-function (syntax-rules () ((_ ret name args) (define name (c-function lib lib-name ret name args))))) ;; PangoLanguage* pango_language_from_string (const char* language) (define-function void* pango_language_from_string (char*)) ;; PangoLanguage* pango_language_get_default (void) (define-function void* pango_language_get_default ()) ;; const char* pango_language_get_sample_string (PangoLanguage* language) (define-function char* pango_language_get_sample_string (void*)) ;; const PangoScript* pango_language_get_scripts (PangoLanguage* language, int* num_scripts) (define-function void* pango_language_get_scripts (void* void*)) ;; GType pango_language_get_type (void) (define-function unsigned-long pango_language_get_type ()) ;; gboolean pango_language_includes_script (PangoLanguage* language, PangoScript script) (define-function int pango_language_includes_script (void* int)) ;; gboolean pango_language_matches (PangoLanguage* language, const char* range_list) (define-function int pango_language_matches (void* char*)) ;; const char* pango_language_to_string (PangoLanguage* language) (define-function char* pango_language_to_string (void*)) ) ;[end]

true

942fe7fe62a6d6d2d7e6ddb20a4caa60102047af

4b570eebce894b4373cba292f09883932834e543

/mit-scheme/web.mit.edu/alexmv/6.037/calculus.scm

ffeb2d0acab39dfb7d623621304120f5c343257c

[]

no_license

Pulkit12083/sicp

ffabc406c66019e5305ad701fbc022509319e4b1

8ea6c57d2b0be947026dd01513ded25991e5c94f

refs/heads/master

2021-06-17T13:44:06.381879

2021-05-14T16:52:30

197,695,022

0

null

2021-04-14T17:04:01

2019-07-19T03:25:41

Scheme

UTF-8

Scheme

false

1,915

scm

calculus.scm

#lang racket "Part 1: Numerical integration" "Problem 1: Integrating any function" (define (integral func num-steps x1 x2) 'your-code-here) ;; Test cases: ;; With only one step, the integral of y = x^2 from 3 to 5 ;; should be 3^2 * 2 = 18 (integral (lambda (x) (expt x 2)) 1 3 5) ;; With two steps, we should get 3^2 + 4^2 = 25 (integral (lambda (x) (expt x 2)) 2 3 5) "Problem 2: Area of a unit circle" (define (approx-pi num-steps) 'your-code-here) (approx-pi 1) ;; Should be 4 (approx-pi 2) ;; Hopefully lower than 4 (approx-pi 600) ;; Right to the first two decimal places? "Problem 3: Integrating with pieces of any shape" (define (rectangle func x1 x2) 'your-code-here) (define (trapezoid func x1 x2) 'your-code-here) (define (integral-with piece func num-steps x1 x2) 'your-code-here) ;; Write your own test cases. Start with checking that calling ;; (integral-with rectangle ...) is the same as calling (integral ...) ;; Then check that (integral-with trapezoid ...) produces better answers ;; for a given num-steps than the same (integral-with rectangle ...) "Problem 4: Better approximation of pi" (define (better-pi num-steps) 'your-code-here) ;; How many digits does (better-pi 600) get correct, compared to ;; the earlier (approx-pi 600) ? "Part 2: Symbolic differentiation" (define (deriv-constant wrt constant) 0) "Problem 5: Derivative of a variable" (define (deriv-variable wrt var) 'your-code-here) "Problem 6: Calling the right function" (define (derivative wrt expr) (cond ; your code here (else (error "Don't know how to differentiate" expr)))) "Problem 7: Derivative of a sum" (define (deriv-sum wrt expr) 'your-code-here) "Problem 8: Derivative of a product" (define (deriv-product wrt expr) 'your-code-here) "Problem 9: Additional testing" ; Additional test cases for 'derivative' go here.

false

c638db9cdae3008bb29d7fce952f9ea571867eeb

defeada37d39bca09ef76f66f38683754c0a6aa0

/mscorlib/system/runtime/remoting/messaging/construction-call.sls

86c9f583e3bf58858b56737ceb8013167c1f4889

[]

no_license

futsuki/ironscheme-port

2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5

4e7a81b0fbeac9a47440464988e53fb118286c54

refs/heads/master

2016-09-06T17:13:11.462593

2015-09-26T18:20:40

42,757,369

0

null

UTF-8

Scheme

false

2,132

sls

construction-call.sls

(library (system runtime remoting messaging construction-call) (export new is? construction-call? get-object-data activation-type activation-type-name activator-get activator-set! activator-update! call-site-activation-attributes context-properties properties) (import (ironscheme-clr-port)) (define-syntax new (lambda (e) (syntax-case e () ((_ a ...) #'(clr-new System.Runtime.Remoting.Messaging.ConstructionCall a ...))))) (define (is? a) (clr-is System.Runtime.Remoting.Messaging.ConstructionCall a)) (define (construction-call? a) (clr-is System.Runtime.Remoting.Messaging.ConstructionCall a)) (define-method-port get-object-data System.Runtime.Remoting.Messaging.ConstructionCall GetObjectData (System.Void System.Runtime.Serialization.SerializationInfo System.Runtime.Serialization.StreamingContext)) (define-field-port activation-type #f #f (property:) System.Runtime.Remoting.Messaging.ConstructionCall ActivationType System.Type) (define-field-port activation-type-name #f #f (property:) System.Runtime.Remoting.Messaging.ConstructionCall ActivationTypeName System.String) (define-field-port activator-get activator-set! activator-update! (property:) System.Runtime.Remoting.Messaging.ConstructionCall Activator System.Runtime.Remoting.Activation.IActivator) (define-field-port call-site-activation-attributes #f #f (property:) System.Runtime.Remoting.Messaging.ConstructionCall CallSiteActivationAttributes System.Object[]) (define-field-port context-properties #f #f (property:) System.Runtime.Remoting.Messaging.ConstructionCall ContextProperties System.Collections.IList) (define-field-port properties #f #f (property:) System.Runtime.Remoting.Messaging.ConstructionCall Properties System.Collections.IDictionary))

true

0605b9e4a0761eebee0252f7ead9c1550093e27c

f1a8c6d5d1178b81132f70e61ab5a53361902e90

/1.1/exercises.scm

750cf6119991628aa2bdd656ca8c30afed3a0c9f

[]

no_license

jlam55555/sicp

99862a8eedcb47034f361b38639247ecf0800b50

64d15f48b9b8ea77f7d38794179874c7d65e975a

refs/heads/master

2023-07-14T11:08:57.981072

2021-08-24T01:10:20

371,579,084

1

0

null

UTF-8

Scheme

false

4,562

scm

exercises.scm

;;; this file relies on some of the code from the text (load "1.1.scm") ;;; 1.1 10 ; 10 (+ 5 3 4) ; 12 (- 9 1) ; 8 (/ 6 2) ; 3 (+ (* 2 4) (- 4 6)) ; 6 (define a 3) ; void (a=3) (define b (+ a 1)) ; void (b=4) (+ a b (* a b)) ; 19 (= a b) ; #f (if [and (> b a) (< b (* a b))] ; 4 b a) (cond ([= a 4] 6) ; 16 ([= b 4] (+ 6 7 a)) (else 25)) (+ 2 (if [> b a] b a)) ; 6 (* (cond ([> a b] a) ; 16 ([< a b] b) (else -1)) (+ a 1)) ;;; 1.2 (/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 4 5))))) (* 3 (- 6 2) (- 2 7))) ;;; 1.3 (define (sum-of-squares x y) (+ (square x) (square y))) (define ssq sum-of-squares) ; alias for convenience (define (sum-of-squares-max x y z) ; note: denote conditionals with [] (if [< x y] (if [< x z] (ssq y z) (ssq x y)) (if [< y z] (ssq x z) (ssq x y)))) ;;; 1.4 ;;; This function adds b to a if b is positive, and adds b to a otherwise. This ;;; is effectively a+|b|. ;;; 1.5 (define (p) (p)) (define (test x y) (if [= x 0] 0 y)) ;;; this will end badly ;; (test 0 (p)) ;;; with normal-order we get the following expansion: ;; (if [= 0 0] ;; 0 ;; (p)) ;; (if #t ;; 0 ;; (p)) ;; 0 ;;; with applicative-order we get the following (infinite) expansion: ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; (test 0 (p)) ;; ... ;;; unfortunately (or not), our interpreter is applicative order. However, ;;; even with this infinite recursion we do not get a stack overflow ;;; 1.6: rewriting if as a cond (define (new-if predicate then-clause else-clause) (cond (predicate then-clause) (else else-clause))) ;;; using this will lead to INFINITE RECURSION because of applicative-order ;;; evaluation; in particular, the special construct (if) has hidden control ;;; that won't evaluate the recursive statement unnecesarily ;;; 1.7 ;;; The fixed threshold of 0.001 won't work equally well across numbers of all ;;; magnitudes, intuitively. (sqrt 1e-10) ;;; The precision for subtracting two large numbers may not work so well ;;; because the mantissa takes up more bits. Thus the following may not complete ;;; because the |difference| > 0.001 always. ;; (sqrt 1e20) (define frac-ratio-threshold 1e-6) (define (good-enough?-2 guess x) (< (abs (- (square guess) x)) (* guess frac-ratio-threshold))) (define (sqrt-iter-2 guess x) (if [good-enough?-2 guess x] guess (sqrt-iter-2 (improve guess x) x))) (define (sqrt-2 x) (sqrt-iter-2 1.0 x)) ;;; tests; these perform much better (sqrt-2 1e-10) (sqrt-2 1e20) ;;; 1.8 (define (improve-cbrt guess x) (/ (+ (/ x (square guess)) (* 2 guess)) 3)) ;;; need to change this a little to work well with small numbers (same goes ;;; for sqrt) (define (good-enough?-cbrt guess x) (< (abs (- (* guess guess guess) x)) (* (min x guess) frac-ratio-threshold))) ;;; these functions are defined analogously to the sqrt case (define (cbrt-iter guess x) (if [good-enough?-cbrt guess x] guess (cbrt-iter (improve-cbrt guess x) x))) (define (cbrt x) (cbrt-iter 1.0 x)) ;;; tests (cbrt 27) (cbrt 231) (cbrt 1e-24) (cbrt 1e24) ;;; FROM THE SAMPLE PSET ;;; 3 (define p1 (lambda (x y) (+ (p2 x y) (p3 x y)))) (define p2 (lambda (z w) (* z w))) (define p3 (lambda (a b) (+ (p2 a) (p2 b)))) ;;; 4.1 (define fold (lambda (x y) (* (spindle x) (+ (mutilate y)) (spindle x)))) (define spindle (lambda (w) (* w w))) (define mutilate (lambda (z) (+ (spindle z) z))) ;;; 4.2 (define fact (lambda (n) (if [= n 0] 1 (* n (fact (- n 1)))))) ;;; 4.3 ;;; commands (in emacs): ;;; C-h t M-> C-p (a few times) C-Space C-n (a few times) M-w ;;; C-x RET C-y ;; Copyright (C) 1985, 1996, 1998, 2001-2021 Free Software Foundation, ;; Inc. ;; This file is part of GNU Emacs. ;; GNU Emacs is free software: you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation, either version 3 of the License, or ;; (at your option) any later version. ;; GNU Emacs is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.

false

32152e858aad590a5345f569fe728bc270d67e71

51559ef0a71416e78eadc50dec4d3143a9f0e680

/srfi/examples.scm

3d6ba4ae6b5b016d0853d614fb03c9fefc02734e

[]

no_license

vyzo/srfi-175

207c2532a14981098681d1db688375d0337b3f91

91ee56de5d23a3c9044368b37647a06abe3a9656

refs/heads/master

2020-07-30T23:36:36.154309

2019-09-22T17:37:38

210,400,673

0

null

2019-09-23T16:18:49

2019-09-23T16:18:48

null

UTF-8

Scheme

false

1,752

scm

examples.scm

(import (scheme base) (scheme file) (scheme read) (scheme write) (srfi 175)) (define (hex-digit char) (or (ascii-digit-value char 10) (ascii-upper-case-value char 10 6) (ascii-lower-case-value char 10 6))) (define (caesar-char rot char) (or (let ((n (ascii-upper-case-value char rot 26))) (and n (ascii-nth-upper-case n))) (let ((n (ascii-lower-case-value char rot 26))) (and n (ascii-nth-lower-case n))) char)) (define (caesar rotation s) (let loop ((i 0) (chars '())) (if (= i (string-length s)) (list->string (reverse chars)) (let ((char (string-ref s i))) (loop (+ i 1) (cons (caesar-char rotation char) chars)))))) (define (strings byte-port) (define (disp stride) (when (>= (length stride) 4) (display (list->string (map integer->char (reverse stride)))) (newline))) (let loop ((stride '())) (let ((byte (read-u8 byte-port))) (cond ((eof-object? byte) (disp stride)) ((not (ascii-display? byte)) (disp stride) (loop '())) (else (loop (cons byte stride))))))) ;; (define (span a b) (let loop ((b b) (acc '())) (if (< b a) acc (loop (- b 1) (cons b acc))))) (define-syntax dribble (syntax-rules () ((_ x) (begin (write 'x) (display " => ") (write x) (newline))))) (dribble (hex-digit #\a)) (dribble (hex-digit #\0)) (dribble (hex-digit #\9)) (dribble (hex-digit #\A)) (dribble (hex-digit #\F)) (dribble (hex-digit #\G)) (dribble (ascii-nth-upper-case 0)) (dribble (ascii-nth-upper-case -1)) (dribble (ascii-nth-lower-case 15)) (dribble (caesar -55 (caesar 55 "hello world"))) (dribble (call-with-port (open-binary-input-file "/bin/ls") strings))

true

f7a2008a95e3ff3d1c73c89c1c114891f4883a93

9b2eb10c34176f47f7f490a4ce8412b7dd42cce7

/lib-r6rs/r7b-util/port-open.sls

37d5b8f992320acff5f31e698b3b5dd3724ecba9

[ "LicenseRef-scancode-public-domain", "CC0-1.0" ]

permissive

okuoku/yuni

8be584a574c0597375f023c70b17a5a689fd6918

1859077a3c855f3a3912a71a5283e08488e76661

refs/heads/master

2023-07-21T11:30:14.824239

2023-06-11T13:16:01

2023-07-18T16:25:22

17,772,480

36

6

CC0-1.0

2020-03-29T08:16:00

2014-03-15T09:53:13

Scheme

UTF-8

Scheme

false

215

sls

port-open.sls

(library (r7b-util port-open) (export input-port-open? output-port-open?) (import (rnrs)) ;; FIXME: (define (input-port-open? p) #t) (define (output-port-open? p) #t) )

false

08cae8dbdf8c0d60171625008f085c4ffd7463a9

cc6a300f6d5414a5e7173968c7a6be1f8a8425dc

/tests/or4.scm

923d09958925d2d8f619969497b58e658b7ab615

[ "Artistic-2.0" ]

permissive

hdijkema/speme

2b4058164c8d59df721a7f54fa4f6c805e7e5621

e5d72c54d07af81e98f0f5e059f7180e36ff4f4a

refs/heads/master

2020-05-17T21:41:34.617879

2013-07-24T08:04:51

null

0

null

UTF-8

Scheme

false

77

scm

or4.scm

(package or4 0.1 (or4) (use mor) (define (or4 a b c d) (mor a b c d)) )

false

73989cde0a80641a185a891bb35c31a0729c35cd

8a0660bd8d588f94aa429050bb8d32c9cd4290d5

/sitelib/apropos.scm

699078d34a223b72f6fab76446393735b27cdb88

[ "BSD-2-Clause" ]

permissive

david135/sagittarius-scheme

dbec76f6b227f79713169985fc16ce763c889472

2fbd9d153c82e2aa342bfddd59ed54d43c5a7506

refs/heads/master

2016-09-02T02:44:31.668025

2013-12-21T07:24:08

32,497,456

0

null

UTF-8

Scheme

false

4,870

scm

apropos.scm

;;; -*- mode: scheme; coding: utf-8; -*- ;;; ;;; apropos.scm: REPL support ;;; ;;; Copyright (c) 2000-2011 Takashi Kato <[email protected]> ;;; ;;; Redistribution and use in source and binary forms, with or without ;;; modification, are permitted provided that the following conditions ;;; are met: ;;; ;;; 1. Redistributions of source code must retain the above copyright ;;; notice, this list of conditions and the following disclaimer. ;;; ;;; 2. Redistributions in binary form must reproduce the above copyright ;;; notice, this list of conditions and the following disclaimer in the ;;; documentation and/or other materials provided with the distribution. ;;; ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ;;; #!compatible (library (apropos) (export apropos) (import (rnrs) (core base) ;; for hashtable->alist (srfi :1 lists) (srfi :13 strings) (srfi :26 cut) (sagittarius) (sagittarius regex) (sagittarius control) (sagittarius object) (sagittarius vm) (pp)) #| library parents structure got changed. this is the memo. paretns ::= ((#<self library> #<parent> . spec) ...) spec is the import spec and might be null. |# (define (apropos arg :key (port (current-output-port))) (define (->regex arg) (cond ((symbol? arg) (regex (symbol->string arg) LITERAL)) ((string? arg) (regex arg)) ((regex-pattern? arg) arg) (else (assertion-violation 'apropos (format "symbol, string or regex-pattern required, but got ~a" arg))))) (let1 pattern (->regex arg) (define (match? e) (and (pattern (symbol->string e)) e)) (define core (format "~a" '(core))) (define (library->string lib) (let1 name (library-name lib) (if (eq? name 'null) core (symbol->string name)))) ;; search parents ;; we don't consider the renaming so only export spec is important. (define (store-variable real renamed library store) (and-let* (( (symbol? real) ) ( (match? real) ) (gloc (find-binding library real #f)) (val (gloc-ref gloc)) (key (cons (or renamed real) val)) (name (library->string library))) (cond ((~ store key) => (^n (set! (~ store key) (lset-union eq? n (list name))))) (else (set! (~ store key) (list name)))))) (define (search-library library using-name store seen) (unless (~ seen library) ;; check export spec (let1 exported (library-exported library) (cond ((not exported) ;; c library ;; we need to check all defined variables (let ((keys (hashtable-keys-list (library-table library))) (name (library-name library))) (for-each (cut store-variable <> #f library store) keys))) ((memq :all (car exported)) ;; search parent but put the current name (for-each (cut search-library <> library store seen) (map car (library-parents library)))) (else (let ((vars (car exported)) (renamed (cdr exported)) (library (or using-name library))) (for-each (cut store-variable <> #f library store) vars) (for-each (^p (store-variable (car p) (cdr p) library store)) renamed))))))) (define (search-parents library store seen) (unless (~ seen library) (set! (~ seen library) #t) (and-let* ((parents (library-parents library)) ( (not (null? parents)) ) (flat (map car parents))) (for-each (cut search-library <> #f store seen) flat) ;; should we walk through all parents? (for-each (cut search-parents <> store seen) flat)))) (let* ((keys (hashtable-keys-list (library-table (vm-current-library)))) (library (library-name (vm-current-library))) (ret (filter-map match? keys))) (for-each (cut format port ";; ~30,,,,a ~a~%" <> library) ret)) (let ((h (make-equal-hashtable)) (seen (make-eq-hashtable))) (search-parents (vm-current-library) h seen) (for-each (lambda (p) (format port ";; ~30,,,,a ~a~%" (caar p) (string-join (cdr p) " "))) (hashtable->alist h))))) )

false

02146a89cae96906f5d1c7c288392b3f5f437006

222b42ba803bfecd4ec31166dd2be107a840f2bd

/macros/define-syntax-files/swap!.scm

4c82c615168e580b6b6c95d951daac6f67272ad9

[]

no_license

ab3250/ablib

83512c2c2cadd0eb49ad534548c058e3ed119d4c

887c8661ce99e8edfe89bcf707400e55c3943dd4

refs/heads/master

2023-06-12T13:36:49.487467

2021-07-11T13:29:45

384,955,137

0

null

UTF-8

Scheme

false

83

scm

swap!.scm

(define-syntax-rule (swap! x y) (let ((tmp x)) (set! x y) (set! y tmp)))

true

dcab04dbfe1019fac841a48641e7feee9524da64

5609fb7205b8aeb4f18767440b2b893d1be6695c

/examples/chicken/library-examples/strings.scm

717aafb0bdac76debdc6c569c7e897477596b486

[]

no_license

kyleburton/sandbox

d2a5e59df14f13581ece884738107da571cb2232

ae7d1ec0c8dbce8806f4019a13dcd3501d4af667

refs/heads/master

2023-07-25T20:16:28.474155

2023-06-22T17:32:49

188,580

13

5

null

2023-06-22T17:32:51

2009-04-29T16:34:21

Clojure

UTF-8

Scheme

false

513

scm

strings.scm

#!/usr/bin/env csi -q (use posix ports srfi-13) (define (string->sexp s) (call-with-input-string s (lambda (p) (read p)))) (let ((input "1")) (printf "parsing: ~s yields: ~s\n" input (string->sexp input))) (let [(s "foo,bar,qux,baz")] (printf "~s split on ',' => ~a\n" s (string-split s ","))) (printf "foo starts with x: ~a\n" (string-prefix? "a" "foo")) (printf "foo starts with f: ~a\n" (string-prefix? "f" "foo")) (exit)

false

341526fb67cabd168ec199c8d3c12c5ad6f5bba4

c42881403649d482457c3629e8473ca575e9b27b

/src/kahua/util.scm

1949794509b8d54393c1d9c29a6dced701142c65

[ "BSD-2-Clause", "BSD-3-Clause" ]

permissive

kahua/Kahua

9bb11e93effc5e3b6f696fff12079044239f5c26

7ed95a4f64d1b98564a6148d2ee1758dbfa4f309

refs/heads/master

2022-09-29T11:45:11.787420

2022-08-26T06:30:15

4,110,786

19

5

null

2015-02-22T00:23:06

2012-04-23T08:02:03

Scheme

UTF-8

Scheme

false

9,654

scm

util.scm

;; ;; kahua.util - miscellaneous utility collection ;; ;; Copyright (c) 2004-2007 Scheme Arts, L.L.C., All rights reserved. ;; Copyright (c) 2004-2007 Time Intermedia Corporation, All rights reserved. ;; See COPYING for terms and conditions of using this software ;; ;; This module contains generally useful routines, which don't belong to ;; a particular module. (define-module kahua.util (use srfi-1) (use srfi-19) (use util.list) (use file.util) (use gauche.collection) (use gauche.sequence) (use gauche.parseopt) (use gauche.charconv) (use gauche.logger) (use kahua.config) (export *default-charset* make-content-type kahua-error-string <kahua-error> kahua-error? stack-trace-of with-sigmask filter-map1 ref-car assq-ref-car assoc-ref-car http-date->date time->rfc1123-string date->rfc1123-string setuidgid! write-pid-file read-pid-file check-pid make-filter-pipeline kahua:call-with-output-file kahua:log-open kahua:log-format with-ignoring-exception )) (select-module kahua.util) (define-condition-type <kahua-error> <error> kahua-error? (stack-trace stack-trace-of)) (define-method initialize ((self <kahua-error>) initargs) (next-method) (unless (get-keyword :stack-trace initargs #f) (let1 st (vm-get-stack-trace-lite) (slot-set! self 'stack-trace (if (and (pair? st) (equal? (car st) '(vm-get-stack-trace-lite))) (cdr st) st))))) (define-constant *default-charset* (case (gauche-character-encoding) ((utf-8) 'UTF-8) ((euc-jp) 'EUC-JP) ((sjis) 'Shift_JIS) (else #f))) (define (make-content-type ct) (if *default-charset* (format "~a; charset=~a" ct *default-charset*) ct)) ;; utility (define (ref-car cmp lis item . maybe-default) (cond ((assoc item lis cmp) => cadr) (else (get-optional maybe-default #f)))) (define assq-ref-car (pa$ ref-car eq?)) (define assoc-ref-car (pa$ ref-car equal?)) ;; (define pair-attribute-get (with-module gauche.internal pair-attribute-get)) ;; test ;; (define fmt (format "~~,,,,~d:a\n" (debug-print-width))) ;; test ;; KAHUA-ERROR-STRING <error> [detail?] ;; Returns a string representation of error. If detail? is given, ;; includes the stack trace. Otherwise, just an error message. (define (kahua-stack-trace e) (guard (e (else (let1 mess (condition-ref e 'message) (kahua:log-format "kahua-stack-trace: message: ~a: error: ~a" mess e) mess))) (let ((fmt (format "~~,,,,~d:a\n" (debug-print-width))) (pair-attribute-get (with-module gauche.internal pair-attribute-get))) (call-with-output-string (lambda (out) (with-port-locking out (lambda () (format out "*** ~a: ~a\n" (class-name (class-of e)) (condition-ref e 'message)) (display "----------------------------------------\n" out) (for-each (lambda (cp) (format out fmt (unwrap-syntax cp)) (when (pair? cp) (let1 sinfo (pair-attribute-get cp 'source-info #f) (if (pair? sinfo) (if (pair? (cdr sinfo)) (format out " At line ~d of ~s\n" (cadr sinfo) (car sinfo)) (format out " In ~s\n" (car sinfo))) (display " [unknown location]:\n" out))))) (stack-trace-of e))))))))) (define (kahua-error-string e . maybe-detail?) (cond ((not (get-optional maybe-detail? #f)) (slot-ref e 'message)) ((kahua-error? e) (kahua-stack-trace e)) (else (call-with-output-string (cut with-error-to-port <> (cut report-error e)))))) (define (with-sigmask how mask thunk) (let1 old_sigset (sys-sigmask how mask) (unwind-protect (thunk) (sys-sigmask SIG_SETMASK old_sigset)))) (define-method filter-map1 (f (c <collection>)) (reverse! (fold (lambda (e res) (let1 v (f e) (if v (cons v res) res))) '() c))) ;; ;; HTTP/1.1 Date string handling ;; (define-constant days-of-week-abbrev #("Sun" "Mon" "Tue" "Wed" "Thu" "Fri" "Sat")) (define-constant days-of-week-full #("Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday")) (define-constant month-abbrev #("Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec")) ;; Sun, 06 Nov 1994 08:49:37 GMT <= RFC 822, updated by RFC 1123 (define-constant rfc1123-date-rx #/^(Sun|Mon|Tue|Wed|Thu|Fri|Sat), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d\d\d\d) (\d\d):(\d\d):(\d\d) GMT$/) ;; Sunday, 06-Nov-94 08:49:37 GMT <= RFC 850, obsoleted by RFC 1036 (define-constant rfc850-date-rx #/^(Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/) ;; Sun Nov 6 08:49:37 1994 <= ANSI C's asctime() format (define-constant asctime-date-rx #/^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ?(\d?\d) (\d\d):(\d\d):(\d\d) (\d\d\d\d)/) (define (http-date->date str) (define (yy->integer yy) (let ((y (x->integer yy))) (cond ((< y 70) (+ 2000 y)) ((< y 100) (+ 1900 y)) (else y)))) (define (mon->integer mon) (+ (find-index (pa$ string=? mon) month-abbrev) 1)) (rxmatch-case str (rfc1123-date-rx (#f #f date mon year hour min sec) (make-date 0 (x->integer sec) (x->integer min) (x->integer hour) (x->integer date) (mon->integer mon) (x->integer year) 0)) (rfc850-date-rx (#f #f date mon yy hour min sec) (make-date 0 (x->integer sec) (x->integer min) (x->integer hour) (x->integer date) (mon->integer mon) (yy->integer yy) 0)) (asctime-date-rx (#f #f mon date hour min sec year) (make-date 0 (x->integer sec) (x->integer min) (x->integer hour) (x->integer date) (mon->integer mon) (x->integer year) 0)) (else #f))) (define-method time->rfc1123-string ((time <number>)) (sys-strftime "%a, %d %b %Y %H:%M:%S GMT" (sys-gmtime time))) (define-method time->rfc1123-string ((time <time>)) (time->rfc1123-string (time->seconds time))) (define (date->rfc1123-string date) (time->rfc1123-string (date->time-utc date))) (define (setuidgid! user:group) (when user:group (and-let* ((m (#/([^\:]+)(?::([^\:]+))?/ user:group)) (pw (sys-getpwnam (m 1))) (uid (ref pw 'uid)) (gid (or (and-let* ((g (m 2))) (sys-group-name->gid g)) (ref pw 'gid)))) (sys-setgid gid) (sys-setuid uid)))) (define (check-pid pid) (guard (e (else #f)) (sys-kill pid 0) #t)) (define (read-pid-file path) (with-input-from-file path read :if-does-not-exist #f)) (define (write-pid-file path) (and-let* ((pid (read-pid-file path))) (when (check-pid pid) (error <kahua-error> :message (format "Process #~d on PID file ~s" pid path))) (sys-unlink path)) (with-output-to-file path (cut write (sys-getpid)) :if-exists :error)) (define (make-filter-pipeline filter-list) (let1 filtered-filters (filter identity filter-list) (lambda (obj) (let/cc break (fold (lambda (f obj) (if obj (and (f obj) obj) (break #f))) obj filtered-filters))))) (define (kahua:call-with-output-file outfile proc . kargs) (let-keywords kargs ((backup-file #f) (tmpbase #f) (perm #f) (encoding (gauche-character-encoding)) . kargs) (let1 outdir (sys-dirname outfile) (make-directory* outdir) (receive (out tmpfile) (sys-mkstemp (build-path outdir (or tmpbase "kahua-tmp-"))) (let1 out (wrap-with-output-conversion out encoding) (when (and backup-file (file-is-regular? outfile)) (sys-link outfile backup-file)) (guard (e (else (sys-unlink tmpfile) (unless (port-closed? out) (close-output-port out)) (raise e))) (proc out outfile) (close-output-port out) (when perm (sys-chmod tmpfile perm)) (sys-rename tmpfile outfile))))))) (define kahua:log-open log-open) (define kahua:log-format log-format) (define (with-ignoring-exception thunk) (guard (e (else e)) (thunk))) (provide "kahua/util")

false

41aba1a7ff7c44ced9d9ac41e3ac9b80fbc070da

d57239c14ab14ee3a119ba3f1091d0016f46b7e5

/submission/icfp08/src/scheme/misc-syntax.ss

1a74f7c57c756fed17ea48b711e97abbbd8f3dc9

[]

no_license

magnusjonsson/tidder-icfpc-2008

c09b0684825375180ca7216fb30c3420af68d153

84d68fd9ac358c38e7eff99117d9cdfa86c1864a

refs/heads/master

2021-05-16T02:58:02.169244

2020-10-03T06:54:11

25,338

3

1

null

2020-10-03T06:54:12

2008-06-14T20:05:00

Scheme

UTF-8

Scheme

false

1,805

ss

misc-syntax.ss

#lang mzscheme (provide push! pop! mergesort! while until min! max! inc! dec! dotimes dolist swap!) (define-syntax push! (syntax-rules () ((_ place value) (set! place (cons value place))))) (define-syntax pop! (syntax-rules () ((_ place) (begin0 (car place) (set! place (cdr place)))))) (require mzlib/list) (define-syntax mergesort! (syntax-rules () ((_ place <) (set! place (mergesort place <))))) (define-syntax while (syntax-rules () ((_ cond body ...) (let loop () (if cond (begin body ... (loop)) (values)))))) (define-syntax until (syntax-rules () ((_ cond body ...) (let loop () (if cond (values) (begin body ... (loop))))))) (define-syntax min! (syntax-rules () ((_ place candidate) (set! place (min place candidate))))) (define-syntax max! (syntax-rules () ((_ place candidate) (set! place (max place candidate))))) (define-syntax inc! (syntax-rules () ((_ place) (set! place (add1 place))) ((_ place increment) (set! place (+ place increment))))) (define-syntax dec! (syntax-rules () ((_ place) (set! place (sub1 place))) ((_ place decrement) (set! place (- place decrement))))) (define-syntax dotimes (syntax-rules () ((_ (var num-times) body ...) (do ((var 0 (add1 var))) ((>= var num-times)) body ...)))) (define-syntax dolist (syntax-rules () ((_ (var list) body ...) (do ((iter list (cdr iter))) ((empty? iter)) (let ((var (car iter))) body ...))))) (define-syntax swap! (syntax-rules () ((_ place1 place2) (set!-values (place1 place2) (values place2 place1)))))

true

04b9bc7f4fedf9a90266ba601dd38a733de62e82

9bbaaf26a910461d1ff9195e735008a5a15dc7bc

/function.ss

6b81e2278a537bdcf49e1a617b87256a42f90451

[]

no_license

jinluchang/cslib

1f1901985ac7eba6edc1dc9f5928ae89fb706156

bd16f79b246d56e1333c10d6416b235ae1d8f979

refs/heads/master

2022-11-21T05:24:36.272331

2020-07-22T16:27:35

null

0

null

UTF-8

Scheme

false

2,355

ss

function.ss

#!chezscheme (library (cslib function) (export id compose on cmp <? >? =? number-cmp string-cmp vector-cmp curry curry-1 ) (import (chezscheme) ) (define (id x) x) (define (compose f g) (lambda (x) (f (g x)))) (define (on cmp f) (lambda (x y) (cmp (f x) (f y)))) (define (number-cmp x y) (cond [(< x y) 'lt] [(> x y) 'gt] [(= x y) 'eq])) (define (string-cmp x y) (cond [(string<? x y) 'lt] [(string>? x y) 'gt] [(string=? x y) 'eq])) (define (symbol-cmp x y) (string-cmp (symbol->string x) (symbol->string y))) (define (boolean-cmp x y) ; #f < #t (cond [(eq? x y) 'eq] [x 'gt] [y 'lt])) (define (vector-cmp x y) (let ([r (number-cmp (vector-length x) (vector-length y))]) (if (not (eq? r 'eq)) r (cmp (vector->list x) (vector->list y))))) (define (cmp x y) ; boolean < number < symbol < string < vector < list (cond [(and (number? x) (number? y)) (number-cmp x y)] [(eq? x y) 'eq] [(and (pair? x) (pair? y)) (let ([c1 (cmp (car x) (car y))]) (if (not (eq? c1 'eq)) c1 (cmp (cdr x) (cdr y))))] [(pair? x) 'gt] [(pair? y) 'lt] [(and (vector? x) (vector? y)) (vector-cmp x y)] [(and (string? x) (string? y)) (string-cmp x y)] [(and (symbol? x) (symbol? y)) (symbol-cmp x y)] [(and (boolean? x) (boolean? y)) (boolean-cmp x y)] [(boolean? x) 'lt] [(boolean? y) 'gt] [(number? x) 'lt] [(number? y) 'gt] [(symbol? x) 'lt] [(symbol? y) 'gt] [(string? x) 'lt] [(string? y) 'gt] [(vector? x) 'lt] [(vector? y) 'gt] [else (pretty-print (format "cmp error ~a ~a" x y))])) (define (<? x y) (eq? (cmp x y) 'lt)) (define (>? x y) (eq? (cmp x y) 'gt)) (define (=? x y) (eq? (cmp x y) 'eq)) (define curry (case-lambda [(f) f] [(f x) (lambda rs (apply f x rs))] [(f x y) (lambda rs (apply f x y rs))] [(f x y z) (lambda rs (apply f x y z rs))])) (define curry-1 (case-lambda [(f) f] [(f x) (lambda (r) (f x r))] [(f x y) (lambda (r) (f x y r))] [(f x y z) (lambda (r) (f x y z r))])) )

false

441a18c5ad9dd5bf1435c95c99049c585865a905

9b2eb10c34176f47f7f490a4ce8412b7dd42cce7

/lib-runtime/generic/std/string-map.scm

0704e240dda4f914ae17d41af8abff380b1a615c

[ "LicenseRef-scancode-public-domain", "CC0-1.0" ]

permissive

okuoku/yuni

8be584a574c0597375f023c70b17a5a689fd6918

1859077a3c855f3a3912a71a5283e08488e76661

refs/heads/master

2023-07-21T11:30:14.824239

2023-06-11T13:16:01

2023-07-18T16:25:22

17,772,480

36

6

CC0-1.0

2020-03-29T08:16:00

2014-03-15T09:53:13

Scheme

UTF-8

Scheme

false

2,220

scm

string-map.scm

(define (string-map4/itr! v pos len proc a b c d) (unless (= pos len) (string-set! v pos (proc (string-ref a pos) (string-ref b pos) (string-ref c pos) (string-ref d pos))) (string-map4/itr! v (+ pos 1) len proc a b c d))) (define (string-map4 proc a b c d) (let* ((len (min (string-length a) (string-length b) (string-length c) (string-length d))) (v (make-string len))) (string-map4/itr! v 0 len proc a b c d) v)) (define (string-map3/itr! v pos len proc a b c) (unless (= pos len) (string-set! v pos (proc (string-ref a pos) (string-ref b pos) (string-ref c pos))) (string-map3/itr! v (+ pos 1) len proc a b c))) (define (string-map3 proc a b c) (let* ((len (min (string-length a) (string-length b) (string-length c))) (v (make-string len))) (string-map3/itr! v 0 len proc a b c) v)) (define (string-map2/itr! v pos len proc a b) (unless (= pos len) (string-set! v pos (proc (string-ref a pos) (string-ref b pos))) (string-map2/itr! v (+ pos 1) len proc a b))) (define (string-map2 proc a b) (let* ((len (min (string-length a) (string-length b))) (v (make-string len))) (string-map2/itr! v 0 len proc a b) v)) (define (string-map1/itr! v pos len proc a) (unless (= pos len) (string-set! v pos (proc (string-ref a pos))) (string-map1/itr! v (+ pos 1) len proc a))) (define (string-map1 proc a) (let* ((len (string-length a)) (v (make-string len))) (string-map1/itr! v 0 len proc a) v)) (define (string-map proc a . args) (if (null? args) (string-map1 proc a) (let ((b (car args)) (bb (cdr args))) (if (null? bb) (string-map2 proc a b) (let ((c (car bb)) (cc (cdr bb))) (if (null? cc) (string-map3 proc a b c) (let ((d (car cc)) (dd (cdr cc))) (if (null? dd) (string-map4 proc a b c d) (error "Too many...")))))))))

false

b7cbf5b72a433789673ac7da7d4e1a51659e3b2f

fa80e42a24ba32525839f9ed2453b92f5566be1c

/src/data-generators/base.scm

a9a3dfa7947f2fd49749644c4450523627e84a7c

[]

no_license

alicemaz/data-generators

efedf1d2bd347110c40cf673028b37dfe36de4e3

caeb9f74e080dce81cc361a53ced320c77b08308

refs/heads/master

2022-12-04T09:44:37.262712

2020-08-18T05:35:16

288,353,032

0

null

UTF-8

Scheme

false

14,005

scm

base.scm

(module data-generators.base (gen-current-fixnum-min gen-current-fixnum-max gen-current-default-size generator <- gen-for-each register-generator-for-type! gen gen-constant gen-int8 gen-uint8 gen-int16 gen-uint16 gen-int32 gen-uint32 gen-int64 gen-uint64 fixnums even-fixnums odd-fixnums gen-flonum flonums gen-bool booleans gen-series gen-char chars gen-fixnum gen-even-fixnum gen-odd-fixnum gen-real gen-rational gen-sample gen-sample-of gen-pair-of gen-tuple-of gen-list-of gen-alist-of gen-vector-of gen-string-of gen-symbol-of gen-symbol gen-keyword-of gen-keyword #;gen-procedure gen-hash-table-of gen-record gen-values-of gen-transform with-size range size-spec->gen) (import scheme) (import chicken.base) (import chicken.type) (import chicken.string) (import chicken.format) (import chicken.keyword) (import chicken.port) (import chicken.random) (import srfi-1) (import srfi-14) (import srfi-69) ;; get a random integer uniformly (: %random-integer (number number -> integer)) (define (%random-integer lo hi) (let ((range (- hi lo -1))) (inexact->exact (+ (pseudo-random-integer range) lo)))) (: %random-real (float float -> float)) (define (%random-real #!optional (size 1.0) (start 0.0)) (let ((ub (+ size start))) (%clamp (+ start (* size (pseudo-random-real))) start ub))) (: %clamp (float float float -> float)) (define (%clamp val lower upper) (cond ((> val upper) upper) ((and (> val lower) (<= val upper)) val) (else lower))) ;;== ranges are used to configure some generators (: range (forall (start (stop *)) (start stop -> (pair start stop)))) (define (range start stop) (cond ((and (not start) stop) (cons (gen-current-fixnum-min) stop)) ((and start (not stop)) (cons start (gen-current-fixnum-max))) (else (cons start stop)))) (: range? (* -> boolean)) (define range? pair?) (: range-start (forall (e (p (pair e e))) (p -> e))) (define range-start car) (: range-end (forall (e (p (pair e e))) (p -> e))) (define range-end cdr) ;;== generator implementation (define-syntax generator (syntax-rules () ((_ ?body ...) (lambda () ?body ...)))) (define generator? procedure?) ;;== accessing elements from a generator (define <- (case-lambda ((gen) (gen)) ((amount gen) (map (lambda _ (gen)) (iota amount))))) (define (gen-for-each rounds proc gen) (do ((i 1 (add1 i))) ((>= i rounds)) (proc (<- gen) i))) ;;== generic generator ;; convenience procedure to quickly create a generator for a given range that dispatches on ;; the type of the arguments (define gen (case-lambda ((lower upper) (range->generator (range lower upper))) ((range) (range->generator range)))) (define type-generator-map '()) (define (register-generator-for-type! type-pred gen) (set! type-generator-map (cons (cons type-pred gen) type-generator-map))) (define (find-generator-for value) (let ((match (find (lambda (p) ((car p) value)) type-generator-map))) (if match (cdr match) #f))) (define (range->generator rng) (let ((gen (find-generator-for (range-start rng)))) (unless gen (error "Could not find generator for given range. Did you register one for that type?" rng)) (gen rng))) ;;== primitive generators (define gen-current-fixnum-min (make-parameter -214748364)) (define gen-current-fixnum-max (make-parameter 214748364)) (define (gen-constant value) (generator value)) (define (size-spec->bounds size-spec #!optional (lower (gen-current-fixnum-min))) (cond ((range? size-spec) (list (range-start size-spec) (range-end size-spec))) (else (error "invalid size specification" size-spec)))) (define-syntax safe-apply-range (syntax-rules () ((_ ?proc ?rng ?args ...) (begin (unless (range? ?rng) (error (quote ?proc) "expected range got " ?rng)) (?proc (range-start ?rng) (range-end ?rng) ?args ...))))) (define-syntax assert-valid-bounds (syntax-rules () ((_ ?lower ?upper) (begin (unless (and (number? ?lower) (number? ?upper)) (error "expected two numbers but got " ?lower " and " ?upper)) (unless (<= ?lower ?upper) (error "lower bound must be less or equal than upper bound")))))) (define gen-fixnum (case-lambda (() (gen-fixnum (gen-current-fixnum-min) (gen-current-fixnum-max))) ((range) (safe-apply-range gen-fixnum range)) ((lower upper) (assert-valid-bounds lower upper) (generator (%random-integer lower upper))))) (define fixnums gen-fixnum) (register-generator-for-type! fixnum? gen-fixnum) (define gen-odd-fixnum (case-lambda (() (gen-odd-fixnum (gen-current-fixnum-min) (gen-current-fixnum-max))) ((range) (safe-apply-range gen-odd-fixnum range)) ((lower upper) (assert-valid-bounds lower upper) (let ((lower (if (odd? lower) lower (+ 1 lower))) (upper (if (odd? upper) upper (- upper 1)))) (generator (let ((val (%random-integer lower upper))) (if (odd? val) val (+ 1 val)))))))) (define odd-fixnums gen-odd-fixnum) (define gen-even-fixnum (case-lambda (() (gen-even-fixnum (gen-current-fixnum-min) (gen-current-fixnum-max))) ((range) (safe-apply-range gen-even-fixnum range)) ((lower upper) (assert-valid-bounds lower upper) (let ((lower (if (even? lower) lower (+ 1 lower))) (upper (if (even? upper) upper (- upper 1)))) (generator (let ((val (%random-integer lower upper))) (if (even? val) val (+ 1 val)))))))) (define even-fixnums gen-even-fixnum) (define-syntax define-fixed-range-generator (syntax-rules () ((_ ?name ?lower ?upper) (define (?name) (generator (%random-integer ?lower ?upper)))))) ;; since these generators ;; will most likely be used to feed some foreign code ;; the ranges have been selected to conform to those present on most platforms (define-fixed-range-generator gen-int8 -127 127) (define-fixed-range-generator gen-uint8 0 255) (define-fixed-range-generator gen-int16 -32767 32767) (define-fixed-range-generator gen-uint16 0 65535) (define-fixed-range-generator gen-int32 -2147483647 2147483647) (define-fixed-range-generator gen-uint32 0 4294967295) (define-fixed-range-generator gen-int64 -9223372036854775807 9223372036854775807) (define-fixed-range-generator gen-uint64 0 18446744073709551615) (define gen-real (case-lambda (() (gen-real 0.0 1.0)) ((range) (safe-apply-range gen-real range)) ((lower upper) (assert-valid-bounds lower upper) (generator (%random-real (- upper lower) lower))))) ;; TODO: find better name (define (gen-flonum-specialties) (gen-sample (list +nan.0 +inf.0 -inf.0))) (define gen-flonum (case-lambda (() (gen-sample-of (gen-flonum-specialties) (gen-flonum 0.0 1.0))) ((range) (safe-apply-range gen-flonum range)) ((lower upper) (assert-valid-bounds lower upper) (generator (%random-real (- upper lower) lower))))) (define flonums gen-flonum) (register-generator-for-type! flonum? gen-real) (define gen-rational (case-lambda (() (gen-rational (fixnums) (fixnums))) ((nom-gen denom-gen) (let ((ensure-not-zero (lambda (val) (if (zero? val) (<- (gen-fixnum 1 (gen-current-fixnum-max))) val)))) (generator (let ((nom (<- nom-gen)) (denom (ensure-not-zero (<- denom-gen)))) (/ nom denom))))))) (define rationals gen-rational) (define gen-series (case-lambda (() (gen-series (gen-current-fixnum-min) (gen-current-fixnum-max) add1)) ((range step) (safe-apply-range gen-series range step)) ((lower upper step) (assert-valid-bounds lower upper) (let ((next lower)) (generator (let ((actual next)) (set! next (if (>= actual upper) lower (step actual))) (min actual upper))))))) (: gen-bool (-> (procedure () boolean))) (define (gen-bool) (generator (zero? (pseudo-random-integer 2)))) (: booleans (-> (procedure () boolean))) (define booleans gen-bool) (define char-set->vector (compose list->vector char-set->list)) (define (boundaries->char-vector lower upper) (define (maybe-apply v p t) (if (p v) (t v) v)) (let ((lo (max 0 (maybe-apply lower char? char->integer))) (hi (max 0 (min 255 (maybe-apply upper char? char->integer))))) (unless (<= lo hi) (error "lower bound must be <= upper bound" lower upper)) (let ((size (add1 (- hi lo)))) (do ((char lo (add1 char)) (i 0 (add1 i)) (vec (make-vector size))) ((> char hi) vec) (vector-set! vec i (integer->char char)))))) (define gen-char (let ((%char-gen (lambda (char-vec) (let ((index-gen (gen-fixnum 0 (sub1 (vector-length char-vec))))) (generator (vector-ref char-vec (<- index-gen))))))) (case-lambda (() (gen-char char-set:graphic)) ((charset-or-range) (cond ((char-set? charset-or-range) (%char-gen (char-set->vector charset-or-range))) ((range? charset-or-range) (gen-char (range-start charset-or-range) (range-end charset-or-range))) (else (error "Invalid argument. Must be either range or charset" charset-or-range)))) ((lower upper) (unless (and (char? lower) (char? upper)) (error "expected two characters but got " lower " and " upper)) (unless (char<=? lower upper) (error "lower bound must be <= upper bound" lower upper)) (%char-gen (boundaries->char-vector lower upper)))))) (define chars gen-char) (register-generator-for-type! char? gen-char) (define (gen-sample candidates) (let* ((candidates (list->vector candidates)) (index-gen (gen-fixnum 0 (sub1 (vector-length candidates))))) (generator (vector-ref candidates (<- index-gen))))) ;; combinators (define gen-current-default-size (make-parameter (gen-uint8))) (define-syntax with-size (syntax-rules () ((_ size-spec body0 ...) (parameterize ((gen-current-default-size (size-spec->gen size-spec))) body0 ...)))) (define (gen-values-of . gens) (generator (apply values (map <- gens)))) (define (gen-sample-of . gens) (let* ((l (length gens)) (gens (list->vector gens)) (index-gen (gen-fixnum 0 (sub1 l)))) (generator (<- (vector-ref gens (<- index-gen)))))) (define (gen-pair-of car-gen cdr-gen) (generator (cons (<- car-gen) (<- cdr-gen)))) (define (gen-tuple-of . gens) (generator (map <- gens))) (define (size-spec->gen spec) (cond ((generator? spec) spec) ((range? spec) (gen-fixnum (range-start spec) (range-end spec))) ((fixnum? spec) (gen-constant spec)) (else (error "Invalid size specification" spec)))) (define gen-list-of (case-lambda ((gen) (gen-list-of gen (gen-current-default-size))) ((gen size-spec) (let ((size-gen (size-spec->gen size-spec))) (generator (<- (<- size-gen) gen)))))) (define gen-alist-of (case-lambda ((key-gen value-gen) (gen-list-of (gen-pair-of key-gen value-gen) (gen-current-default-size))) ((key-gen value-gen size-spec) (gen-list-of (gen-pair-of key-gen value-gen) size-spec)))) (define gen-string-of (case-lambda ((gen) (gen-string-of gen (gen-current-default-size))) ((gen size-spec) (let ((size-gen (size-spec->gen size-spec))) (generator (list->string (<- (<- size-gen) gen))))))) (define gen-string gen-string-of) (define gen-symbol-of (case-lambda (() (gen-symbol-of (gen-char char-set:letter+digit))) ((char-gen) (gen-transform string->symbol (gen-string-of char-gen))))) (define gen-symbol gen-symbol-of) (define gen-keyword-of (case-lambda (() (gen-keyword-of (gen-char char-set:letter+digit))) ((char-gen) (gen-transform string->keyword (gen-string-of char-gen))))) (define gen-keyword gen-keyword-of) #;(define-syntax define-procedure-generator (ir-macro-transformer (lambda (exp inj cmp) (let ((name (cadr exp)) (max-arity (caddr exp))) `(define ,name (case-lambda (() (,name (<- (gen-fixnum 0 ,max-arity)) (gen-bool))) ((arity return) (unless (and (fixnum? arity) (<= arity ,max-arity)) (error "Arity must be a fixnum between 0 and " ,max-arity)) (case arity ,@(map (lambda (i) `((,i) (generator (lambda ,(list-tabulate i (constantly '_)) (<- return))))) (iota (+ max-arity 1))))))))))) #;(define-procedure-generator gen-procedure 20) (define gen-vector-of (case-lambda ((gen) (gen-vector-of gen (gen-current-default-size))) ((gen size-spec) (let ((size-gen (size-spec->gen size-spec))) (generator (let ((size (<- size-gen))) (do ((i 0 (add1 i)) (vec (make-vector size))) ((>= i size) vec) (vector-set! vec i (gen))))))))) (define gen-hash-table-of (case-lambda ((key-gen value-gen) (gen-hash-table-of key-gen value-gen (gen-current-default-size) eq?)) ((key-gen value-gen size-spec) (gen-hash-table-of key-gen value-gen size-spec eq?)) ((key-gen value-gen size-spec equal?) (let ((size-gen (size-spec->gen size-spec))) (generator (let ((size (<- size-gen))) (do ((i 0 (add1 i)) (ht (make-hash-table equal?))) ((>= i size) ht) (hash-table-set! ht (<- key-gen) (<- value-gen))))))))) (define (gen-record ctor . slot-gens) (generator (apply ctor (map <- slot-gens)))) (define (gen-transform transformer gen) (generator (transformer (<- gen)))) )

true

cd04e2e67f0444a12bff3d0d0585c385797b060f

bdeb8973603dd2ce97faaf59164f45fd322234c8

/exercise-2-2-list-replicate.scm

b131f3ff702d3681ffa342f9ccb42d198e42914f

[]

no_license

emilbaekdahl/pp-exercises

782e080c5ab0a96210cec765699f0071a4ab558b

ce9e93d03357f2aec46f648b33d18205529f775d

refs/heads/master

2020-07-28T00:50:05.001308

2019-11-13T21:44:15

2019-11-13T21:46:00

209,260,169

0

null

UTF-8

Scheme

false

594

scm

exercise-2-2-list-replicate.scm

; Exercise 2.2: A list replication function. ; Create a new, eventually cylcing, list of length `n` from `lst` . ; ; Examples ; >>> (replicate-to-length '(1 2 3) 4) ; >>> '(1 2 3 1) (define (replicate-to-length lst n) (replicate-to-length-helper lst n 0)) (define (replicate-to-length-helper lst n current) (if (= n 0) '() (cons (list-ref lst current) (replicate-to-length-helper lst (- n 1) (modulo (+ current 1) (length lst))))))

false

702c637f43eac0118c1fc31d954df791d9c478b5

951b7005abfe3026bf5b3bd755501443bddaae61

/generic/complex-package.scm

6f560d5e66a424b5e13cc9b0dbf44dfdb0c4d654

[]

no_license

WingT/scheme-sicp

d8fd5a71afb1d8f78183a5f6e4096a6d4b6a6c61

a255f3e43b46f89976d8ca2ed871057cbcbb8eb9

refs/heads/master

2020-05-21T20:12:17.221412

2016-09-24T14:56:49

63,522,759

2

0

null

UTF-8

Scheme

false

2,987

scm

complex-package.scm

(define (install-rectangular-package) ;;internal procedures (define (real-part z) (car z)) (define (imag-part z) (cdr z)) (define (make-from-real-imag x y) (cons x y)) (define (magnitude z) (sqrt (+ (square (real-part z)) (square (imag-part z))))) (define (angle z) (atan (imag-part z) (real-part z))) (define (make-from-mag-ang r a) (cons (* r (cos a)) (* r (sin a)))) ;;interface to the rest of the system (define (tag x) (attach-tag 'rectangular x)) (put 'real-part '(rectangular) real-part) (put 'imag-part '(rectangular) imag-part) (put 'magnitude '(rectangular) magnitude) (put 'angle '(rectangular) angle) (put 'make-from-real-imag 'rectangular (lambda (x y) (tag (make-from-real-imag x y)))) (put 'make-from-mag-ang 'rectangular (lambda (r a) (tag (make-from-mag-ang r a)))) (put 'equ? '(rectangular rectangular) (lambda (x y) (and (= (real-part x) (real-part y)) (= (imag-part x) (imag-part y))))) (put '=zero? '(rectangular) (lambda (x) (and (= (real-part x) 0) (= (imag-part x) 0)))) 'done) (install-rectangular-package) (define (install-polar-package) ;;internal procedures (define (real-part z) (* (magnitude z) (cos (angle z)))) (define (imag-part z) (* (magnitude z) (sin (angle z)))) (define (make-from-real-imag x y) (cons (sqrt (+ (square x) (square y))) (atan y x))) (define (magnitude z) (car z)) (define (angle z) (cdr z)) (define (make-from-mag-ang r a) (cons r a)) ;;interface to the rest of the system (define (tag x) (attach-tag 'polar x)) (put 'real-part '(polar) real-part) (put 'imag-part '(polar) imag-part) (put 'magnitude '(polar) magnitude) (put 'angle '(polar) angle) (put 'make-from-real-imag 'polar (lambda (x y) (tag (make-from-real-imag x y)))) (put 'make-from-mag-ang 'polar (lambda (r a) (tag (make-from-mag-ang r a)))) (put 'equ? '(polar polar) (lambda (x y) (and (= (magnitude x) (magnitude y)) (= (angle x) (angle y))))) (put '=zero? '(polar) (lambda (x) (= (magnitude x) 0))) 'done) (install-polar-package) (define (real-part z) (apply-generic 'real-part z)) (define (imag-part z) (apply-generic 'imag-part z)) (define (magnitude z) (apply-generic 'magnitude z)) (define (angle z) (apply-generic 'angle z)) (define (equ? x y) (apply-generic 'equ? x y)) (define (=zero? x) (apply-generic '=zero? x)) (define (make-from-mag-ang r a) ((get 'make-from-mag-ang 'polar) r a)) (define (make-from-real-imag x y) ((get 'make-from-real-imag 'rectangular) x y)) (put-coercion 'polar 'rectangular (lambda (x) (make-complex-from-real-imag (real-part x) (imag-part x)))) (put-coercion 'rectangular 'polar (lambda (x) (make-complex-from-mag-ang (magnitude x) (angle x))))

false

ce24bb972509cb54960c360689ed5cb64b9a2983

37245ece3c767e9434a93a01c2137106e2d58b2a

/tests/srfi-188-tests.sch

7dda00872e35c2841a2369d814d4b063ae807a0e

[ "MIT" ]

permissive

mnieper/unsyntax

7ef93a1fff30f20a2c3341156c719f6313341216

144772eeef4a812dd79515b67010d33ad2e7e890

refs/heads/master

2023-07-22T19:13:48.602312

2021-09-01T11:15:54

296,947,908

12

0

null

UTF-8

Scheme

false

3,420

sch

srfi-188-tests.sch

;; Copyright © Marc Nieper-Wißkirchen (2020). ;; This file is part of unsyntax. ;; Permission is hereby granted, free of charge, to any person ;; obtaining a copy of this software and associated documentation files ;; (the "Software"), to deal in the Software without restriction, ;; including without limitation the rights to use, copy, modify, merge, ;; publish, distribute, sublicense, and/or sell copies of the Software, ;; and to permit persons to whom the Software is furnished to do so, ;; subject to the following conditions: ;; The above copyright notice and this permission notice (including the ;; next paragraph) shall be included in all copies or substantial ;; portions of the Software. ;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ;; SOFTWARE. (import (scheme base) (srfi 64) (srfi 188) (srfi 211 identifier-syntax)) (test-begin "Splicing binding constructs for syntactic keywords") (test-equal 1 (let ((x #t)) (splicing-let-syntax () (define x 1) #f) x)) (test-equal 2 (let ((x #t)) (splicing-let-syntax () (define x 2)) x)) (test-equal 3 (let ((x #t)) (splicing-let-syntax ((f (syntax-rules () ((f) x)))) (define x 3) (f)))) (test-equal 4 (let ((x #t)) (splicing-letrec-syntax () (define x 4) #f) x)) (test-equal 5 (let ((x #t)) (splicing-letrec-syntax () (define x 5)) x)) (test-equal 6 (let ((x #t)) (splicing-letrec-syntax ((f (syntax-rules () ((f) x)))) (define x 6) (f)))) (test-equal 'now (splicing-let-syntax ((given-that (syntax-rules () ((given-that test stmt1 stmt2 ...) (if test (begin stmt1 stmt2 ...)))))) (let ((if #t)) (given-that if (set! if 'now)) if))) (test-equal 'outer (let ((x 'outer)) (splicing-let-syntax ((m (syntax-rules () ((m) x)))) (let ((x 'inner)) (m))))) (test-equal 7 (splicing-letrec-syntax ((my-or (syntax-rules () ((my-or) #f) ((my-or e) e) ((my-or e1 e2 ...) (let ((temp e1)) (if temp temp (my-or e2 ...))))))) (let ((x #f) (y 7) (temp 8) (let odd?) (if even?)) (my-or x (let temp) (if y) y)))) (test-equal 'let-syntax (let ((x 'let-syntax)) (let-syntax () (define x 'splicing-let-syntax) #f) x)) (test-equal 'splicing-let-syntax (let ((x 'let-syntax)) (splicing-let-syntax () (define x 'splicing-let-syntax) #f) x)) (test-equal 'inner (let ((foo 'outer)) (splicing-let-syntax ((foo (identifier-syntax 'inner))) (define x foo)) x)) (test-end)

false

c2954e51356aa2467b3c8ae9f7bd57c52ca944a4

fb9a1b8f80516373ac709e2328dd50621b18aa1a

/ch3/exercise3-43.scm

cd226de46d9b576aa498d5ceddf5f0ffa799c783

[]

no_license

da1/sicp

a7eacd10d25e5a1a034c57247755d531335ff8c7

0c408ace7af48ef3256330c8965a2b23ba948007

refs/heads/master

2021-01-20T11:57:47.202301

2014-02-16T08:57:55

null

0

null

UTF-8

Scheme

false

686

scm

exercise3-43.scm

;; 問題3.43 ;; 口座A,B,Cで残高が10,20,30 ;; 口座の残高交換をしながら複数のプロセスが走る ;; プロセスが逐次的に走ったなら，口座残高は，ある順序で10,20,30である． ;; 最初の版の口座交換プログラムだと，この条件が破られる ;; 残高の合計は保持される A: 10 -> -> 20 B: 20 -> 30 -> 20 C: 30 -> 20 -> P1: -> dif(10) -> -> B with -> A dep P2: (BCの交換) ;; 各講座の取引を直列しなければ，この条件も破れる withdrowの手続きで，subとsetの間でamountの値が変われば，合計値も変わる

false

73c8f99190f5e2904d8542d923a14782d571cf33

8a0660bd8d588f94aa429050bb8d32c9cd4290d5

/sitelib/rfc/ssh/transport.scm

d60aeba827f286203776293b2ac8da1f5493db40

[ "BSD-2-Clause" ]

permissive

david135/sagittarius-scheme

dbec76f6b227f79713169985fc16ce763c889472

2fbd9d153c82e2aa342bfddd59ed54d43c5a7506

refs/heads/master

2016-09-02T02:44:31.668025

2013-12-21T07:24:08

32,497,456

0

null

UTF-8

Scheme

false

18,163

scm

transport.scm

;;; -*- mode:scheme; coding:utf-8; -*- ;;; ;;; rfc/ssh/transport.scm - SSH2 protocol transport layer. ;;; ;;; Copyright (c) 2010-2013 Takashi Kato <[email protected]> ;;; ;;; Redistribution and use in source and binary forms, with or without ;;; modification, are permitted provided that the following conditions ;;; are met: ;;; ;;; 1. Redistributions of source code must retain the above copyright ;;; notice, this list of conditions and the following disclaimer. ;;; ;;; 2. Redistributions in binary form must reproduce the above copyright ;;; notice, this list of conditions and the following disclaimer in the ;;; documentation and/or other materials provided with the distribution. ;;; ;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED ;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR ;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ;;; #!read-macro=sagittarius/regex (library (rfc ssh transport) (export make-client-ssh-transport ;; parameter *ssh-version-string* ssh-disconnect ssh-data-ready? (rename (write-packet ssh-write-packet) (read-packet ssh-read-packet) (service-request ssh-service-request)) ;; these are actually private but i'm lazy to rename ;; so keep it and when i write the document use only above service-request write-packet read-packet ) (import (rnrs) (sagittarius) (sagittarius socket) (sagittarius control) (sagittarius object) (sagittarius regex) (srfi :13 strings) (srfi :39 parameters) (rfc ssh constants) (rfc ssh types) (rfc hmac) (util bytevector) (math) (crypto) (clos user) (binary pack) (binary data)) ;; must do until handshake but for now (define (make-client-ssh-transport server port . options) (let* ((socket (make-client-socket server port)) (transport (make <ssh-transport> :socket socket))) (version-exchange transport) (key-exchange transport) transport)) (define-constant cr #x0D) (define-constant lf #x0A) (define-constant +default-version-string+ (string-append "SSH-2.0-Sagittarius_" (sagittarius-version))) (define *ssh-version-string* (make-parameter +default-version-string+)) ;; utility (define (read-ascii-line in) (call-with-string-output-port (lambda (out) (let1 buf (make-bytevector 1) (let loop ((r (socket-recv! in buf 0 1))) (unless (zero? r) (let1 u8 (bytevector-u8-ref buf 0) (cond ((= u8 cr) (socket-recv! in buf 0 1)) ;; version string must end CR LF however ;; OpenSSH 4.3 returns only LF... ((= u8 lf)) (else (let1 ch (integer->char u8) (put-char out ch) (loop (socket-recv! in buf 0 1)))))))))))) ;; write line with CR LF (define (write-line out str) (socket-send out (string->utf8 str)) (socket-send out #vu8(#x0D #x0A))) (define (version-exchange transport) (let1 in/out (~ transport 'socket) (let loop () (let1 vs (read-ascii-line in/out) (cond ((zero? (string-length vs)) (socket-shutdown in/out SHUT_RDWR) (socket-close in/out) (error 'version-exchange "no version string")) ((#/(SSH-2.0-[\w.-]+)\s*/ vs) => (lambda (m) (set! (~ transport 'target-version) (m 1)) ;; send (write-line in/out (*ssh-version-string*)))) (else (loop))))))) ;; I don't think these are useful on SSH since payload must be ;; a message format ;; (define (ssh-socket-send socket payload . ignore) ;; (write-packet socket payload)) ;; ;; TODO we need a buffer to store the message from peer. ;; (define (ssh-socket-recv socket size . ignore) ;; (error 'ssh-socket-recv "not supported yet")) ;; FIXME ;; currently it's really bad way to read and write a packet ;; (especially read). ;; try read maximum number of packet and encrypt/decrypt if needed. ;; TODO ;; * make buffer in transport and read&decrypt per cipher block size (define-constant +max-packet-size+ 35000) (define (read-packet context) (define (verify-mac transport payload mac) (and-let* ((h (~ context 'server-mac)) (key (~ context 'server-mkey)) (c (~ context 'server-sequence)) (buf (make-bytevector (+ 4 (bytevector-length payload))))) (bytevector-u32-set! buf 0 c (endianness big)) (bytevector-copy! payload 0 buf 4 (bytevector-length payload)) (bytevector=? mac (hash HMAC buf :hash h :key key)))) ;; FIXME this is not a good implementation... (define (read&decrypt mac-length) (define (read-block in size) (let loop ((diff size) (r '())) (if (zero? diff) (bytevector-concatenate (reverse! r)) (let1 buf (socket-recv in diff) (loop (- diff (bytevector-length buf)) (cons buf r)))))) (let* ((c (~ context 'server-cipher)) (block-size (cipher-blocksize c)) (in (~ context 'socket)) (first (decrypt c (read-block in block-size))) ;; i've never seen block cipher which has block size less ;; than 8 (total-size (bytevector-u32-ref first 0 (endianness big))) (padding-size (bytevector-u8-ref first 4)) ;; hope the rest have multiple of block size... (rest-size (- (+ total-size 4) block-size)) (rest (decrypt c (read-block in rest-size))) (mac (socket-recv in mac-length)) (pt (bytevector-append first rest))) (verify-mac context pt mac) (bytevector-copy pt 5 (+ (- total-size padding-size 1) 5)))) (define (read-data in) (let* ((sizes (socket-recv in 5)) (total (bytevector-u32-ref sizes 0 (endianness big))) (pad (bytevector-u8-ref sizes 4))) (rlet1 payload (socket-recv in (- total pad 1)) ;; discards padding (socket-recv in pad)))) (let* ((mac-length (or (and-let* ((k (~ context 'client-cipher)) (h (~ context 'server-mac))) (hash-size h)) 0)) (payload (if (zero? mac-length) (read-data (~ context 'socket)) (read&decrypt mac-length)))) (set! (~ context 'server-sequence) (+ (~ context 'server-sequence) 1)) payload)) (define (write-packet context msg) (define (compute-mac transport payload) (or (and-let* ((h (~ context 'client-mac)) (key (~ context 'client-mkey)) (c (~ context 'client-sequence)) (buf (make-bytevector (+ 4 (bytevector-length payload))))) (bytevector-u32-set! buf 0 c (endianness big)) (bytevector-copy! payload 0 buf 4 (bytevector-length payload)) (hash HMAC buf :hash h :key key)) #vu8())) (define (construct-packet transport payload) (define (total-size data-len) (define (round-up l) (let* ((c (~ transport 'client-cipher)) (size (if c (- (cipher-blocksize c) 1) 7))) (bitwise-and (+ l size) (bitwise-not size)))) (round-up (+ data-len 4 1 4))) (let* ((data-len (bytevector-length payload)) (total-len (total-size data-len)) (padding (read-random-bytes (~ transport 'prng) (- total-len 4 1 data-len))) (content (call-with-bytevector-output-port (lambda (out) (put-u32 out (- total-len 4) (endianness big)) (put-u8 out (bytevector-length padding)) (put-bytevector out payload) (put-bytevector out padding)))) (mac (compute-mac transport content))) (values payload content mac))) (define (encrypt-packet payload) (let1 c (~ context 'client-cipher) (if c (encrypt c payload) payload))) (let-values (((payload content mac) (construct-packet context msg))) (set! (~ context 'client-sequence) (+ (~ context 'client-sequence) 1)) (let1 out (~ context 'socket) (socket-send out (encrypt-packet content)) (socket-send out mac)) payload)) ;; default 1000 usec ;; there is very high possibility that this returns #f if ;; timeout is too less or 0. that's because cryptographic ;; operation takes some time so that it is very expensive. (define (ssh-data-ready? transport :optional (timeout 1000)) (let1 reads (socket-read-select timeout (~ transport 'socket)) (not (null? reads)))) ;; for my laziness (define-ssh-message <DH-H> () ((V-C :string) (V-S :string) (I-C :string) (I-S :string) (K-S :string) (e :mpint) (f :mpint) (K :mpint))) (define-ssh-message <GEX-H> () ((V-C :string) (V-S :string) (I-C :string) (I-S :string) (K-S :string) (min :uint32) (n :uint32) (max :uint32) (p :mpint) (g :mpint) (e :mpint) (f :mpint) (K :mpint))) (define (kex-digester transport) (cond ((#/sha(\d+)/ (~ transport 'kex)) => (lambda (m) (case (string->number (m 1)) ((1) SHA-1) ((256) SHA-256)))) (else (error 'kex-digester "Hash algorighm not supported" (~ transport 'kex))))) (define (verify-signature transport m K-S H) ;; K-S is either RSA or DSA certificate structure ;; so parse it and get the key for verify (define (parse-k-s) (let* ((in (open-bytevector-input-port K-S)) (size (get-unpack in "!L")) (name (utf8->string (get-bytevector-n in size)))) (set-port-position! in 0) (case (string->symbol name) ((ssh-dss) (let1 c (read-message <ssh-dss-certificate> in) (values DSA (generate-public-key DSA (~ c 'p) (~ c 'q) (~ c 'g) (~ c 'y)) '(:der-encode #f)))) ((ssh-rsa) (let1 c (read-message <ssh-rsa-certificate> in) (values RSA (generate-public-key RSA (~ c 'n) (~ c 'e)) (list :verify pkcs1-emsa-v1.5-verify)))) (else (error 'verify-signature "unknown method" name))))) (define (parse-h) (read-message <ssh-signature> (open-bytevector-input-port H))) (let*-values (((type key verify-options) (parse-k-s)) ((sig) (parse-h)) ((vc) (cipher type key)) ((h) (hash (kex-digester transport) (ssh-message->bytevector m)))) (unless (~ transport 'session-id) (set! (~ transport 'session-id) h)) (apply verify vc h (~ sig 'signature) verify-options) h)) (define (compute-keys! transport k H) (define d (kex-digester transport)) (define (digest salt) (hash d (bytevector-append k H salt))) ;; returns cipher and key size (in bytes) (define (cipher&keysize c) (cond ((string-prefix? "aes128" c) (values AES 16)) ((string-prefix? "aes256" c) (values AES 32)) ((string-prefix? "3des" c) (values DESede 24)) ((string-prefix? "blowfish" c) (values Blowfish 16)) (else (error 'compute-keys! "cipher not supported" c)))) (define (cipher-mode c) (cond ((string-suffix? "cbc" c) MODE_CBC) ;; TODO counter mode (else (error 'compute-keys! "mode not supported" c)))) (define client-enc (~ transport 'client-enc)) (define server-enc (~ transport 'server-enc)) (define (adjust-keysize key size) (let loop ((key key)) (let1 s (bytevector-length key) (cond ((= s size) key) ((> s size) (bytevector-copy key 0 size)) (else ;; compute and append (let1 k (digest key) (loop (bytevector-append key k)))))))) (define (make-cipher c mode key size iv) ;; TODO counter mode (cipher c (generate-secret-key c (adjust-keysize key size)) :mode mode :iv iv :padder #f)) (define sid (~ transport 'session-id)) (let ((client-iv (digest (bytevector-append #vu8(#x41) sid))) ;; "A" (server-iv (digest (bytevector-append #vu8(#x42) sid))) ;; "B" (client-key (digest (bytevector-append #vu8(#x43) sid))) ;; "C" (server-key (digest (bytevector-append #vu8(#x44) sid))) ;; "D" (client-mkey (digest (bytevector-append #vu8(#x45) sid))) ;; "E" (server-mkey (digest (bytevector-append #vu8(#x46) sid))) ;; "F" (client-mode (cipher-mode client-enc)) (server-mode (cipher-mode server-enc))) (let-values (((client-cipher client-size) (cipher&keysize client-enc)) ((server-cipher server-size) (cipher&keysize server-enc))) (set! (~ transport 'client-cipher) (make-cipher client-cipher client-mode client-key client-size client-iv)) (set! (~ transport 'server-cipher) (make-cipher server-cipher server-mode server-key server-size server-iv)) (set! (~ transport 'client-mkey) (adjust-keysize client-mkey (hash-size (~ transport 'client-mac)))) (set! (~ transport 'server-mkey) (adjust-keysize server-mkey (hash-size (~ transport 'server-mac))))) transport)) (define (key-exchange transport) (define macs `((hmac-sha1 . ,SHA-1))) (define (fill-slot transport-slot req res kex-slot) (let ((cnl (~ req kex-slot 'names)) (snl (~ res kex-slot 'names))) (let loop ((lis cnl)) (cond ((null? lis) (error 'key-exchange "algorithm not supported")) ((member (car lis) snl) => (lambda (l) (rlet1 v (string->symbol (car l)) (when transport-slot (set! (~ transport transport-slot) (cond ((assq v macs) => cdr) (else (car l)))))))) (else (loop (cdr lis))))))) (define (generate-e&x transport gex?) (define (gen-x r) (bytevector->integer (read-random-bytes (~ transport 'prng) (div (bitwise-length r) 8)))) (define (group14? transport) (#/group14/ (~ transport 'kex))) (if gex? ;; TODO min n max range (let1 gex-req (make <ssh-msg-kex-dh-gex-request>) (write-packet transport (ssh-message->bytevector gex-req)) (let* ((reply (read-packet transport)) (gex-group (read-message <ssh-msg-kex-dh-gex-group> (open-bytevector-input-port reply))) (p (~ gex-group 'p)) (g (~ gex-group 'g))) (let1 x (gen-x (div (- p 1) 2)) (values p g x (mod-expt g x p))))) ;; basically p's length is less than or equal to q's so shouldn't ;; matter, i think (let-values (((p g) (if (group14? transport) (values +dh-group14-p+ +dh-group14-g+) (values +dh-group1-p+ +dh-group1-g+)))) (let1 x (gen-x p) (values p g x (mod-expt g x p)))))) ;; send init and receive reply ;; both DH and GEX have the same init/reply structure so ;; for laziness (define (send/receive transport init-class reply-class p e x make-verify-message) (let1 dh-init (make init-class :e e) (write-packet transport (ssh-message->bytevector dh-init)) (let* ((reply (read-packet transport)) (dh-reply (read-message reply-class (open-bytevector-input-port reply))) (K-S (~ dh-reply 'K-S)) (H (~ dh-reply 'H)) (f (~ dh-reply 'f)) (K (mod-expt f x p))) ;; verify signature (let1 h (verify-signature transport (make-verify-message K-S H f K) K-S H) ;; send newkeys (write-packet transport (make-bytevector 1 +ssh-msg-newkeys+)) ;; receive newkeys (read-packet transport) ;; compute keys (compute-keys! transport (call-with-bytevector-output-port (lambda (out) (write-message :mpint K out #f))) h))))) (define (do-dh transport client-packet packet) ;; exchange key! (let-values (((p g x e) (generate-e&x transport #f))) (send/receive transport <ssh-msg-kexdh-init> <ssh-msg-kexdh-reply> p e x (lambda (K-S H f K) (make <DH-H> :V-C (string->utf8 (*ssh-version-string*)) :V-S (string->utf8 (~ transport 'target-version)) :I-C client-packet :I-S packet :K-S K-S :e e :f f :K K))))) (define (do-gex transport client-packet packet) (let-values (((p g x e) (generate-e&x transport #t))) (send/receive transport <ssh-msg-kex-dh-gex-init> <ssh-msg-kex-dh-gex-reply> p e x (lambda (K-S H f K) (make <GEX-H> :V-C (string->utf8 (*ssh-version-string*)) :V-S (string->utf8 (~ transport 'target-version)) :I-C client-packet :I-S packet :K-S K-S ;; TODO get size :min 1024 :n 1024 :max 2048 :p p :g g :e e :f f :K K))))) (let1 client-kex (make <ssh-msg-keyinit> :cookie (read-random-bytes (~ transport 'prng) 16)) (let* ((client-packet (write-packet transport (ssh-message->bytevector client-kex))) (packet (read-packet transport)) (server-kex (read-message <ssh-msg-keyinit> (open-bytevector-input-port packet)))) ;; ok do key exchange ;; first decide the algorithms (fill-slot 'kex client-kex server-kex 'kex-algorithms) (fill-slot 'client-enc client-kex server-kex 'encryption-algorithms-client-to-server) (fill-slot 'server-enc client-kex server-kex 'encryption-algorithms-server-to-client) (fill-slot 'client-mac client-kex server-kex 'mac-algorithms-client-to-server) (fill-slot 'server-mac client-kex server-kex 'mac-algorithms-server-to-client) ;; dispatch (cond ((#/group-exchange/ (~ transport 'kex)) (do-gex transport client-packet packet)) ((#/group\d+/ (~ transport 'kex)) (do-dh transport client-packet packet)) (else (error 'key-exchange "unknown KEX")))))) (define (ssh-disconnect transport :key (code +ssh-disconnect-by-application+) (description "finish")) (write-packet transport (ssh-message->bytevector (make <ssh-msg-disconnect> :code code :description description)))) (define (service-request transport name) (write-packet transport (ssh-message->bytevector (make <ssh-msg-service-request> :service-name (string->utf8 name)))) (read-message <ssh-msg-service-accept> (open-bytevector-input-port (read-packet transport)))) )

false

b4f51cdf6ba871191a51ea175ccab417e403b1cb

3888492b9b0c8a8f6c49670822e3c92a99ac3454

/guix/tests/bl.scm

3694e8f3b4158d4435a434add53afb3f6b805951

[]

no_license

avoine/conf

e8bce2824c8774eb43c0d68bb8b5282ee303627e

8a07b482fcce160ac98a14eaac191f8c84cf018f

refs/heads/master

2021-03-13T01:01:22.224750

2017-05-15T17:58:42

91,472,762

1

null

2017-05-16T15:14:12

null

UTF-8

Scheme

false

2,273

scm

bl.scm

;; (primitive-load "/home/mathieu/guix/gnu/system/bootloader.scm") (use-modules (guix store) (gnu packages bootloaders) (gnu system bootloader) (guix gexp) (guix packages) (guix build utils) (guix derivations)) (define %store (open-connection)) (define bootloader (run-with-store %store (package->derivation syslinux))) (define bootloader-path (derivation->output-path bootloader)) (build-derivations %store (list bootloader)) (define install-kikoo #~(lambda (bootloader device mount-point) (mkdir #$output) (copy-file (string-append bootloader "/share/syslinux/cmd.c32") (string-append #$output "/cmd.c32")) )) (define install-kikoo2 #~(lambda (bootloader device mount-point) (let ((extlinux (string-append bootloader "/sbin/extlinux")) (install-dir (string-append mount-point "/boot/extlinux")) (syslinux-dir (string-append bootloader "/share/syslinux"))) (mkdir-p #$output) ;; (for-each (lambda (file) ;; (copy-file file ;; (string-append #$output "/" (basename file)))) ;; (find-files syslinux-dir "\\.c32$")) ))) (define install-syslinux2 (lambda (bootloader device mount-point) (let ((extlinux (string-append bootloader "/sbin/extlinux")) (install-dir (string-append mount-point "/tmp/syslinux")) (syslinux-dir (string-append bootloader "/share/syslinux"))) (mkdir-p install-dir) (for-each (lambda (file) (format #t "copy ~a -> ~a\n" file (string-append install-dir "/" (basename file))) (copy-file file (string-append install-dir "/" (basename file)))) (filter (lambda (file) (string=? syslinux-dir (dirname file))) (find-files syslinux-dir "\\.c32$"))) ))) ;; (define kikoo-drv (run-with-store %store ;; (gexp->derivation "kikoo" ;; #~(#$install-kikoo #$syslinux "/dev/sda" "/")))) ;; (build-derivations %store (list kikoo-drv)) ;; (derivation->output-path kikoo-drv)

false

6bbd4e1415ebf1950c8e59df4f3f5cc1a0e68fdc

abc7bd420c9cc4dba4512b382baad54ba4d07aa8

/src/ws/compat/reg_record.ss

648b7d371cc38fc189f3fb573cb4b26dc9aba5a7

[ "BSD-3-Clause" ]

permissive

rrnewton/WaveScript

2f008f76bf63707761b9f7c95a68bd3e6b9c32ca

1c9eff60970aefd2177d53723383b533ce370a6e

refs/heads/master

2021-01-19T05:53:23.252626

2014-10-08T15:00:41

1,297,872

10

2

null

UTF-8

Scheme

false

974

ss

reg_record.ss

;; This defines the regiment records to be R6RS records: (define-syntax reg:define-struct (lambda (x) (define (symappend . syms) (define (coerce x) (if (string? x) x (symbol->string x))) (string->symbol (apply string-append (map coerce syms)))) (syntax-case x (fields mutable) [(_ (name fld* ...)) (let* ([tosyntax (lambda (s) (datum->syntax #'name s))] [thename (syntax->datum #'name)] [syms (syntax->datum #'(fld* ...))] [accessors (map (lambda (s) (symappend thename "-" s)) syms)] [mutators (map (lambda (s) (symappend "set-" thename "-" s "!")) syms)]) (let* ([acc* (map tosyntax accessors)] [mut* (map tosyntax mutators)] [mutflds (map (lambda (fld acc mut) #`(mutable #,fld #,acc #,mut)) #'(fld* ...) acc* mut*)]) ;(printf "MUTABLE FIELDS: ~a\n" (syntax->datum mutflds)) #`(define-record-type name (fields . #,mutflds)) ))]))) (define reg:struct? record?)

true

0168bcd0516099d841263e25fdd43562263cd749

e82d67e647096e56cb6bf1daef08552429284737

/symbolic-algebra/polynomial-operations.scm

800a5bf3196aec1f88f09847bff0d3eb4d45a6f5

[]

no_license

ashishmax31/sicp-exercises

97dfe101dd5c91208763dcc4eaac2c17977d1dc1

097f76a5637ccb1fba055839d389541a1a103e0f

refs/heads/master

2020-03-28T11:16:28.197294

2019-06-30T20:25:18

148,195,859

6

0

null

UTF-8

Scheme

false

7,683

scm

polynomial-operations.scm

#lang racket/load (load "utils.scm") (load "dense-termlist.scm") (load "sparse-termlist.scm") (load "rational-numbers.scm") (define (install-polynomial-package) (define (tag contents) (attach-tag 'polynomial contents)) (define (same-variable? a b) (eq? a b)) (define (make-polynomial variable terms) (cons variable terms)) (define (variable poly) (car poly)) (define (term-list poly) (cdr poly)) (define (empty-termlist) '()) (define (empty-termlist? term-list) (null? term-list)) (define (first-term term-list) (cons (car term-list) (- (length term-list) 1))) (define (rest-terms term-list) (cdr term-list)) (define (empty-polynomial? poly) (null? (term-list poly))) (define (get-term-type term) (if (number? (car term)) 'dense 'sparse )) (define (coeff item) ((get 'coeff (get-term-type item)) item)) (define (order item) ((get 'order (get-term-type item)) item)) (define (adjoin-term term term-list) ((get 'adjoin-term (get-term-type term)) term term-list)) (define (make-term order coefficient type length) (cons ((get 'make-term type) order coefficient) length)) (define (empty-poly? poly) (equal? (length poly) 1)) (define (add-polynomial p1 p2) (if (same-variable? (variable p1) (variable p2)) (make-polynomial (variable p1) (add-terms (term-list p1) (term-list p2))) (error "ERROR: polynomials should be of the same variable!"))) (define (sub-polynomial p1 p2) (if (same-variable? (variable p1) (variable p2)) (make-polynomial (variable p1) (sub-terms (term-list p1) (term-list p2))) (error "ERROR: polynomials should be of the same variable!"))) (define (mul-polynomial p1 p2) (if (same-variable? (variable p1) (variable p2)) (make-polynomial (variable p1) (mul-terms (term-list p1) (term-list p2))) (error "ERROR: polynomials should be of the same variable!"))) (define (div-polynomial p1 p2) (if (same-variable? (variable p1) (variable p2)) (let ((result (div-terms (term-list p1) (term-list p2)))) (list (make-polynomial (variable p1) (car result)) (make-polynomial (variable p1) (cadr result)))) (error "ERROR: polynomials should be of the same variable!"))) (define (add-terms l1 l2) (cond ((empty-termlist? l1) l2) ((empty-termlist? l2) l1) (else (let ((t1 (first-term l1)) (t2 (first-term l2))) (cond ((> (order t1) (order t2)) (adjoin-term t1 (add-terms (rest-terms l1) l2))) ((< (order t1) (order t2)) (adjoin-term t2 (add-terms l1 (rest-terms l2)))) (else (adjoin-term (make-term (order t1) (add (coeff t1) (coeff t2)) (get-term-type t1) (order t1)) (add-terms (rest-terms l1) (rest-terms l2))))))))) (define (div-terms l1 l2) (if (empty-termlist? l1) (list (empty-termlist) (empty-termlist)) (let ((t1 (first-term l1)) (t2 (first-term l2))) (if (> (order t2) (order t1)) (list (empty-termlist) l1) (let ((new-c (div (coeff t1) (coeff t2))) (new-o (sub (order t1) (order t2)))) (let ((quotient-term (cons (list new-o new-c) new-o))) (let ((new-dividend (sub-terms l1 (mul-with-all-terms quotient-term l2)))) (let ((rest-of-results (list (cons (car quotient-term) (car (div-terms new-dividend l2))) (cadr (div-terms new-dividend l2))))) rest-of-results)))))))) (define (sub-terms l1 l2) (add-terms l1 (negate l2))) (define (negate term-list) (if (number? (car term-list)) (map (lambda (term) (mul -1 term)) term-list) (map (lambda (term) (list (car term) (mul -1 (cadr term)))) term-list))) (define (mul-terms l1 l2) (if (empty-termlist? l1) (empty-termlist) (add-terms (mul-with-all-terms (first-term l1) l2) (mul-terms (rest-terms l1) l2)))) (define (mul-with-all-terms t1 l2) (if (empty-termlist? l2) (empty-termlist) (adjoin-term (make-term (+ (order t1) (order (first-term l2))) (mul (coeff t1) (coeff (first-term l2))) (get-term-type t1) (+ (order t1) (order (first-term l2)))) (mul-with-all-terms t1 (rest-terms l2))))) (define (gcd-poly a b) (if (empty-poly? b) a (gcd-poly b (remainder-poly a b)))) (define (remainder-poly a b) (cadr (div-polynomial a b))) (put 'make 'polynomial (lambda (variable terms) (tag (make-polynomial variable terms)))) (put 'add '(polynomial polynomial) (lambda (p1 p2) (tag (add-polynomial p1 p2)))) (put 'mul '(polynomial polynomial) (lambda (p1 p2) (tag (mul-polynomial p1 p2)))) (put 'sub '(polynomial polynomial) (lambda (p1 p2) (tag (sub-polynomial p1 p2)))) (put 'div '(polynomial polynomial) (lambda (p1 p2) (let ((result (div-polynomial p1 p2))) (list (tag (car result)) (tag (cadr result)))))) (put 'gcd '(polynomial polynomial) (lambda (p1 p2) (tag (gcd-poly p1 p2)))) (put 'zero? '(polynomial) empty-polynomial?) (display "Intalled polynomial package...") (newline) ) (define (install-number-arithmetic) (define (number-zero? item) (zero? item)) (put 'add '(number number) +) (put 'mul '(number number) *) (put 'sub '(number number) -) (put 'div '(number number) /) (put 'zero? '(number) number-zero?) (put 'gcd '(number number) gcd) (display "Intalled scheme numbers package...") (newline) ) (install-number-arithmetic) (install-polynomial-package) (install-dense-termlist) (install-sparse-termlist) (install-rational-numbers) (define (add z1 z2) (apply-generic 'add z1 z2)) (define (div z1 z2) (apply-generic 'div z1 z2)) (define (sub z1 z2) (apply-generic 'sub z1 z2)) (define (greatest-commom-divisor a b) (apply-generic 'gcd a b)) (define (mul z1 z2) (apply-generic 'mul z1 z2)) (define (numer r) (apply-generic 'numer r)) (define (denom r) (apply-generic 'denom r)) (define (make-poly var terms) ((get 'make 'polynomial) var terms)) (define (make-rational x y) ((get 'make 'rational ) x y)) (define (=zero? item) (apply-generic 'zero? item)) (define poly (make-poly 'x '((2 1) (1 2) (0 1)))) (define nested (make-poly 'y (list '(2 1) (list 1 poly) '(0 2)))) (define p (make-poly 'x '(4 3 2 1))) (define p10 (make-poly 'x '((5 1) (0 -1)))) (define p20 (make-poly 'x '((2 1) (0 -1)))) (define p1 (make-poly 'x '((1 1) (0 1)))) (define p2 (make-poly 'x '((3 1) (0 -1)))) (define p3 (make-poly 'x '((1 1)))) (define p4 (make-poly 'x '((2 1) (0 -1)))) (define r1 (make-rational p1 p2)) (define r2 (make-rational p3 p4))

false

8487dee7acbe458a4c8bcc2dde9a85f7b6e97a8e

1a64a1cff5ce40644dc27c2d951cd0ce6fcb6442

/src/io/pdb-util.scm

ef78bb57b367ed1673a548ba0ad197340e037a53

[]

no_license

skchoe/2007.rviz-objects

bd56135b6d02387e024713a9f4a8a7e46c6e354b

03c7e05e85682d43ab72713bdd811ad1bbb9f6a8

refs/heads/master

2021-01-15T23:01:58.789250

2014-05-26T17:35:32

null

0

null

UTF-8

Scheme

false

2,369

scm

pdb-util.scm

(module pdb-util mzscheme (require (lib "match.ss") (lib "list.ss") (lib "string.ss") (lib "etc.ss")) (provide (all-defined)) (define list-copy-N (lambda (lst-src pos) (let* ([size-src (length lst-src)] [size-dst (- size-src pos)]) (let loop ([cnt 0] [nlst '()]) (if (equal? cnt size-dst) nlst (let ([elt (list-ref lst-src (+ pos cnt))]) (if (empty? nlst) (loop (add1 cnt) (list elt)) (loop (add1 cnt) (append nlst (list elt)))))))))) (define string-trim-front (lambda (str) (let* ([lst (string->list str)]) (let loop ([cnt 0] [nlst '()]) ;(printf "in loop (~s:\t ~s)\n" cnt (length nlst)) (if (equal? 0 (length lst)) nlst (let* ([c (list-ref lst cnt)]) (if (or (char-whitespace? c) (char-blank? c)) (loop (add1 cnt) nlst) (list->string (list-copy-N lst cnt))))))))) (define string-trim-rear (lambda (str) (let* ([rstr (string-reverse str)] [nstr (string-trim-front rstr)]) (string-reverse nstr)))) (define string-reverse (lambda (str) (list->string (reverse (string->list str))))) (define string-trim (lambda (str) (string-trim-front (string-trim-rear str)))) (define string-deblank (lambda (str) (let* ([lst (string->list str)] [size (length lst)]) ;(printf "input size = ~s\n" size) (let loop ([cnt 0] [nlst '()]) ;(printf "in loop (~s:\t ~s)\n" cnt (length nlst)) (if (eq? cnt size) (list->string nlst) (let* ([c (list-ref lst cnt)]) (unless (or (char-whitespace? c) (char-blank? c)) ;(printf "~s\n" c) (if (empty? nlst) (set! nlst (list c)) (set! nlst (append nlst (list c))))) (loop (add1 cnt) nlst))))))) ; (define ex-str " ssd sdl ") ; (printf "\n [~s]\n" (string-deblank ex-str)) ; (printf "~s\n" (string-trim ex-str)) (define string-size (lambda (str) (length (string->list str)))) ; file id is a part of file name before .extension: (.pdb .ext) (define file-name->file-id (lambda (filename) (let* ([len (string-size filename)]) (if (> len 4) (substring filename 0 (- len 4)) "default")))) )

false

fd6cca20b10b94a697295444bc8a5bd3b8e10f52

ef9a581cee5913872323b67248607ef4d6493865

/compiler/Eta-Reduction.scm

dfc8a65354f21649a5f96c46e2c7c17f504d2be5

[]

no_license

egisatoshi/scheme-compiler

c1ef8392c2a841913669a2eb8edaa825b9e99b96

01e6efbbc491c2f21c4a6009398977ded4009c20

refs/heads/master

2018-12-31T22:48:30.526683

2012-08-23T03:49:08

5,518,662

10

1

null

UTF-8

Scheme

false

2,505

scm

Eta-Reduction.scm

;;; ;;; Eta Reduction ;;; (define-module Eta-Reduction (use srfi-1) (use srfi-11) (use util.match) (require "./Basic-Utility") (require "./Empty-Fix-Elimination") (require "./Propagation") (require "./Substitution") (import Basic-Utility) (import Assoc) (import Empty-Fix-Elimination) (import Propagation) (import Substitution) (export eta-reduct-count Eta-Reduct )) (select-module Eta-Reduction) (define eta-reduct-count 0) (define can-eta-reduct? (lambda (bounder) (match bounder ((_ v ('Apply _ args)) (equal? v args)) (else #f)))) (define eta-reduct (lambda (exp) (match exp (('Fix B A) (let-values (((tfs ffs) (partition can-eta-reduct? B))) (let* ((assoc (map (match-lambda ((f _ ('Apply g _)) `(,f ,g))) tfs)) (new-B (map (match-lambda ((f V B) (let ((new-B (eta-reduct (Substitute B (map car assoc) (map cadr assoc))))) `(,f ,V ,new-B)))) ffs)) (new-A (eta-reduct (Substitute A (map car assoc) (map cadr assoc))))) (set! eta-reduct-count (+ eta-reduct-count (length tfs))) `(Fix ,new-B ,new-A)))) (('Fix2 B A) ;; do same thing with Fix (let-values (((tfs ffs) (partition can-eta-reduct? B))) (let* ((assoc (map (match-lambda ((f _ ('Apply g _)) `(,f ,g))) tfs)) (new-B (map (match-lambda ((f V B) (let ((new-B (eta-reduct (Substitute B (map car assoc) (map cadr assoc))))) `(,f ,V ,new-B)))) ffs)) (new-A (eta-reduct (Substitute A (map car assoc) (map cadr assoc))))) (set! eta-reduct-count (+ eta-reduct-count (length tfs))) `(Fix2 ,new-B ,new-A)))) (else (Propagate eta-reduct exp))))) (define Eta-Reduct (lambda (program) (format (standard-error-port) "Eta-Reduction start...\n") (let ((new-program (Eliminate-Empty-Fix (eta-reduct program)))) (format (standard-error-port) "Eta-Reduction finished.\n") (format (standard-error-port) "Eta-Reduct ~s functions.\n" eta-reduct-count) new-program))) (provide "Eta-Reduction")

false

3032df8f23e882948499e24a31cdc216c63e1cf9

defeada37d39bca09ef76f66f38683754c0a6aa0

/System.Xml/mono/xml/xsl/tokenizer.sls

b605b3e0645483a06d1779a113e5377a438bb042

[]

no_license

futsuki/ironscheme-port

2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5

4e7a81b0fbeac9a47440464988e53fb118286c54

refs/heads/master

2016-09-06T17:13:11.462593

2015-09-26T18:20:40

42,757,369

0

null

UTF-8

Scheme

false

616

sls

tokenizer.sls

(library (mono xml xsl tokenizer) (export new is? tokenizer? token advance? value) (import (ironscheme-clr-port)) (define-syntax new (lambda (e) (syntax-case e () ((_ a ...) #'(clr-new Mono.Xml.Xsl.Tokenizer a ...))))) (define (is? a) (clr-is Mono.Xml.Xsl.Tokenizer a)) (define (tokenizer? a) (clr-is Mono.Xml.Xsl.Tokenizer a)) (define-method-port token Mono.Xml.Xsl.Tokenizer token (System.Int32)) (define-method-port advance? Mono.Xml.Xsl.Tokenizer advance (System.Boolean)) (define-method-port value Mono.Xml.Xsl.Tokenizer value (System.Object)))

true

60f83edfb78cb1f0cd474f78d84c712700038504

b43e36967e36167adcb4cc94f2f8adfb7281dbf1

/scheme/swl1.3/tests/error-help/test31.ss

8180657609dba63fae2e282dd8399d643ad87690

[ "SWL", "TCL" ]

permissive

ktosiu/snippets

79c58416117fa646ae06a8fd590193c9dd89f414

08e0655361695ed90e1b901d75f184c52bb72f35

refs/heads/master

2021-01-17T08:13:34.067768

2016-01-29T15:42:14

53,054,819

1

0

null

2016-03-03T14:06:53

null

UTF-8

Scheme

false

81

ss

test31.ss

; Test error "parenthesized list terminated by close bracket" (define nil '(])

false

acb1587ef857622e70d246038dabebee736d7ca2

b63601b5d27a014d9258eb736eefa6b17c4ecc31

/LLLdocs/src/cartesian.scm

559c9160d5bd8930b28d518f2db6252973a48f47

[]

no_license

hitokey/wasCm

953d3c9e6a768b940cac0b765e0c2177fe2d0646

32c7f0f25964200441f52852763ce31f725ef2e7

refs/heads/master

2023-08-17T00:56:06.969797

2021-02-10T02:20:43

266,668,959

1

0

null

2020-06-23T22:28:59

2020-05-25T02:53:02

TeX

UTF-8

Scheme

false

233

scm

cartesian.scm

(define f (cons 2 3)) (define g (cons 4 5)) (define (add x y) (let ( (numerator (+ (* (car x) (cdr y)) (* (car y) (cdr x)) )) (denominator (* (cdr x) (cdr y)) )) (cons numerator denominator)))

false

fa5d07b996e113e976ea6f83e57a04424ed88718

5609fb7205b8aeb4f18767440b2b893d1be6695c

/examples/chicken/library-examples/web-server.scm

1b194d3751ba4fb87813778782ae8e881af949d0

[]

no_license

kyleburton/sandbox

d2a5e59df14f13581ece884738107da571cb2232

ae7d1ec0c8dbce8806f4019a13dcd3501d4af667

refs/heads/master

2023-07-25T20:16:28.474155

2023-06-22T17:32:49

188,580

13

5

null

2023-06-22T17:32:51

2009-04-29T16:34:21

Clojure

UTF-8

Scheme

false

1,393

scm

web-server.scm

#!/usr/bin/env csi -q ;; See: http://wiki.call-cc.org/eggref/4/spiffy (use (prefix spiffy sp:) srfi-18 ;; threading srfi-19) ;; time (sp:server-port 8123) (sp:root-path "./www") (define (datestamp) (string-join (list (date->string (current-date) "~4") (sprintf "~a" (current-milliseconds))) ".")) (define (handle-404 path) (printf "in handle-404, current-request is: ~a\n" (sp:current-request)) (printf "in handle-404, current-response is: ~a\n" (sp:current-response)) (let [(msg (sprintf #<<END 404: Not Found at ~a The path requested is: ~a END (datestamp) path))] (print msg) ;; NB: send-status is a wrapped version of send-response for common ;; status codes, which wraps your the message with default html ;; (send-status 404 "Not Found" msg) (sp:send-response #:code 404 #:reason "Not Found" #:body msg #:headers `((content-type "text/plain") (content-length ,(string-length msg)))))) (sp:handle-not-found handle-404) ;;(define server (start-server)) (define server #f) (define (start-server) (set! server (make-thread (lambda () (sp:start-server)))) (thread-start! server)) (define (stop-server) (thread-terminate! server)) (start-server) (printf "server: ~a\n" server) (printf "to exit / stop type (exit) and press enter\n") ;; (exit)

false

98555902c3ab5bc7daf715cedf02acd8ad562667

b60cb8e39ec090137bef8c31ec9958a8b1c3e8a6

/test/R5RS/ad/prioq.scm

18313345865b4851d75542b7e60cda95f060368c

[]

no_license

acieroid/scala-am

eff387480d3baaa2f3238a378a6b330212a81042

13ef3befbfc664b77f31f56847c30d60f4ee7dfe

refs/heads/master

2021-01-17T02:21:41.692568

2021-01-15T07:51:20

28,140,080

32

16

null

2020-04-14T08:53:20

2014-12-17T14:14:02

Scheme

UTF-8

Scheme

false

1,667

scm

prioq.scm

(define true #t) (define false #f) (define (make-item priority element) (cons priority element)) (define (get-priority item) (car item)) (define (get-element item) (cdr item)) (define (create-priority-queue) (let ((front (cons 'boe '()))) (define (content) (cdr front)) (define (insert-after! cell item) (let ((new-cell (cons item '()))) (set-cdr! new-cell (cdr cell)) (set-cdr! cell new-cell))) (define (find-prev-cell priority) (define (find-iter rest prev) (cond ((null? rest) prev) ((> (get-priority (car rest)) priority) (find-iter (cdr rest) rest)) (else prev))) (find-iter (content) front)) (define (empty?) (null? (content))) (define (enqueue priority element) (insert-after! (find-prev-cell priority) (make-item priority element)) true) (define (dequeue) (if (null? (content)) false (let ((temp (car (content)))) (set-cdr! front (cdr (content))) (get-element temp)))) (define (serve) (if (null? (content)) false (get-element (car (content))))) (define (dispatch m) (cond ((eq? m 'empty?) empty?) ((eq? m 'enqueue) enqueue) ((eq? m 'dequeue) dequeue) ((eq? m 'serve) serve) (else (error "unknown request -- create-priority-queue" m)))) dispatch)) (define pq (create-priority-queue)) ((pq 'enqueue) 66 'Patrick) ((pq 'enqueue) -106 'Octo) ((pq 'enqueue) 0 'Sandy) ((pq 'enqueue) 89 'Spongebob) ((pq 'dequeue)) (equal? ((pq 'dequeue)) 'Patrick)

false

cf8ad118c8b7dc5b98e7294f77ef8b8deb62796a

bca049faabfdb0be05c5a83ab6f4b3c193869d00

/sakefile.scm

ab50315bf35b2f94966064d3382daa01aa3a94af

[ "Zlib" ]

permissive

alvatar/sphere-math

a789080796acde5ebdd95786fc87a12b8d2cc0a7

e1f5c020537d604386ded859bed6939e3a4bd1be

refs/heads/master

2016-09-11T15:18:20.686684

2016-03-15T18:37:49

976,530

2

1

null

2016-03-15T18:37:50

2010-10-10T15:53:08

Scheme

UTF-8

Scheme

false

607

scm

sakefile.scm

(define modules '(arithmetics bit-logic matrix)) (define-task compile () (for-each (lambda (m) (sake#compile-module m cond-expand-features: '(debug) version: '(debug)) (sake#compile-module m cond-expand-features: '(optimize))) modules)) (define-task post-compile () (for-each (lambda (m) (sake#make-module-available m versions: '(() (debug)))) modules)) (define-task install () (sake#install-sphere-to-system)) (define-task test () (sake#test-all)) (define-task clean () (sake#default-clean)) (define-task all (compile post-compile) 'all)

false

e2104927768f2fa4ca7b911fb91a615f33419b17

f08220a13ec5095557a3132d563a152e718c412f

/logrotate/skel/usr/share/guile/2.0/language/brainfuck/spec.scm

f7cd90109a83b285ae06be74baf4f19235597e62

[ "Apache-2.0" ]

permissive

sroettger/35c3ctf_chals

f9808c060da8bf2731e98b559babd4bf698244ac

3d64486e6adddb3a3f3d2c041242b88b50abdb8d

refs/heads/master

2020-04-16T07:02:50.739155

2020-01-15T13:50:29

165,371,623

15

5

Apache-2.0

2020-01-18T11:19:05

2019-01-12T09:47:33

Python

UTF-8

Scheme

false

1,677

scm

spec.scm

;;; Brainfuck for GNU Guile. ;; Copyright (C) 2009, 2010 Free Software Foundation, Inc. ;; This library is free software; you can redistribute it and/or ;; modify it under the terms of the GNU Lesser General Public ;; License as published by the Free Software Foundation; either ;; version 3 of the License, or (at your option) any later version. ;; ;; This library is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;; Lesser General Public License for more details. ;; ;; You should have received a copy of the GNU Lesser General Public ;; License along with this library; if not, write to the Free Software ;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA ;; 02110-1301 USA ;;; Code: (define-module (language brainfuck spec) #:use-module (language brainfuck compile-tree-il) #:use-module (language brainfuck compile-scheme) #:use-module (language brainfuck parse) #:use-module (system base language) #:export (brainfuck)) ; The new language is integrated into Guile via this (define-language) ; specification in the special module (language [lang] spec). ; Provided is a parser-routine in #:reader, a output routine in #:printer ; and one or more compiler routines (as target-language - routine pairs) ; in #:compilers. This is the basic set of fields needed to specify a new ; language. (define-language brainfuck #:title "Brainfuck" #:reader (lambda (port env) (read-brainfuck port)) #:compilers `((tree-il . ,compile-tree-il) (scheme . ,compile-scheme)) #:printer write )

false

0c78c01a126ef66504608985c39178807fb00091

382770f6aec95f307497cc958d4a5f24439988e6

/projecteuler/071/071.scm

5e3b57b95a1c6519d6fc952ca691fa44288de95e

[ "Unlicense" ]

permissive

include-yy/awesome-scheme

602a16bed2a1c94acbd4ade90729aecb04a8b656

ebdf3786e54c5654166f841ba0248b3bc72a7c80

refs/heads/master

2023-07-12T19:04:48.879227

2021-08-24T04:31:46

227,835,211

1

0

null

UTF-8

Scheme

false

920

scm

071.scm

(define find-3/7 (lambda (n) (let ([nearest (quotient (* n 3) 7)]) (let f ([p nearest]) (cond ((or (= p 0) (= p 1)) (cons 1 n)) ((= (gcd p n) 1) (cons p n)) (else (f (- p 1)))))))) (define from-to (lambda (start end) (let f ([current start] [better (find-3/7 3)]) (cond ((= current 7) (f (+ current 1) better)) ((> current end) better) (else (let* ([now (find-3/7 current)] [bet (/ (car better) (cdr better))] [now-bet (/ (car now) (cdr now))]) (if (> (- 3/7 bet) (- 3/7 now-bet)) (f (+ current 1) now) (f (+ current 1) better)))))))) (from-to 3 1000000) #| (time (from-to 3 ...)) 17 collections 0.312500000s elapsed cpu time, including 0.000000000s collecting 0.308445912s elapsed real time, including 0.000519036s collecting 72005744 bytes allocated, including 71598000 bytes reclaimed (428570 . 999997) |#

false

37d531bf9edc1a27ffac1e3b3521a202bae6de51

559934d76e760d2ac18121e9871f55199035c3e2

/chapter-1/pascal-triangle.scm

665f009c91dcd6c429e8434e9d2ecdd473886e3c

[ "MIT" ]

permissive

floyza/sicp-exersices

6ea930c83cabbecc509abf1e014f7419231481d6

ee82444b82f2b2fc130728e5ec9d35bdf73c24de

refs/heads/master

2023-06-16T11:51:43.794164

2021-07-14T16:47:44

2021-07-14T16:48:46

383,636,376

0

null

UTF-8

Scheme

false

168

scm

pascal-triangle.scm

;;; Exercise 1.12 (define (pascal row col) (if (or (= col 0) (= col row)) 1 (+ (pascal (1- row) (1- col)) (pascal (1- row) col)))) (pascal 4 1)

false

8926b9116c70e693657dff068ae988860ff0e9c6

6e359a216e1e435de5d39bc64e75998945940a8c

/commonfunc.scm

b010601a6561e9fb52a098fd6b9ec557d96bf2f6

[]

no_license

GuoDangLang/SICP

03a774dd4470624165010f65c27acc35d844a93d

f81b7281fa779a9d8ef03997214e47397af1a016

refs/heads/master

2021-01-19T04:48:22.891605

2016-09-24T15:26:57

69,106,376

0

null

UTF-8

Scheme

false

1,003

scm

commonfunc.scm

(define (cube x) (* x x x)) (define (square x) (* x x)) (define (average x y) (/ (+ x y) 2)) (define (power n) (define (power-iter times temp) (if (= times n) temp (power-iter (+ 1 times) (lambda (x) (* (temp x) x))))) (power-iter 1 (lambda (x) x))) (define (accumulate op initial sequence) (if (null? sequence) initial (op (car sequence) (accumulate op initial (cdr sequence))))) (define nil (list)) (define (enumerate-interval low high) (if (> low high) nil (cons low (enumerate-interval (+ 1 low) high)))) (define (enumerate-tree tree) (cond ((null? tree) nil) ((not (pair? tree)) (list tree)) (else (append (enumerate-tree (car tree)) (enumerate-tree (cdr tree)))))) (define (filterr predicate sequence) (cond ((null? sequence) nil) ((predicate (car sequence)) (cons (car sequence) (filterr predicate (cdr sequence)))) (else (filterr predicate (cdr sequence))))) (define (flatmap proc seq) (accumulate append nil (map proc seq)))

false

ca403d708ac05d2b53a7429492fbc7f6c093fba3

edffd423fdbef93bc8d44cdd7ae285a3558ef6de

/tests/dice-of-doom-test.scm

a94e497d61e2ef0543f0f1ac4d2692d660566536

[ "MIT" ]

permissive

massimo-nocentini/on-scheme

7983c219f5a9f82c2bda20f71c83ef4a2366dd4a

ebf590978c9ec8f34c9d4be9ce99ff406d72de44

refs/heads/master

2021-01-17T12:53:18.806547

2019-01-30T08:52:59

58,215,388

0

null

UTF-8

Scheme

false

2,898

scm

dice-of-doom-test.scm

(import scheme (chicken base) (chicken port) (chicken random)) (import srfi-1 srfi-13) (import test) (import commons streams dice-of-doom) (set-pseudo-random-seed! "gkfifgousrwbtrm") (test-group "initial" (test "\n A-1 B-1 \n B-3 A-3 " (to-string (gen-board 2 '(A B) 4))) ; 'A and 'B play on 2x2 board starting with at most 4 dices on each cell. (test #((B 2) (B 2) (B 4) (B 1)) (board-cells (gen-board 2 '(A B) 4))) ; 'A and 'B play on 2x2 board starting with at most 4 dices on each cell. (test '(2 1 3) (stream:->list (neighbors 0 (gen-board 2 '(A B) 4)))) (test '(3 0) (stream:->list (neighbors 1 (gen-board 2 '(A B) 4)))) (test '(0 3) (stream:->list (neighbors 2 (gen-board 2 '(A B) 4)))) (test '(1 0 2) (stream:->list (neighbors 3 (gen-board 2 '(A B) 4)))) (test #((A 3) (A 1) (B 3) (A 2)) (board-cells (board-attack (make-board #((A 3) (A 3) (B 3) (B 1)) 2) 'A 1 3 3))) (test #((A 2) (B 3) (A 3) (B 1)) (board-cells (add-new-dice (make-board #((A 1) (B 3) (A 2) (B 1)) 2) 'A 2))) (test '(A "\n A-1 B-1 \n A-2 B-1 " (((cell 2 attacks 3) (A "\n A-1 B-1 \n A-1 A-1 " ((pass (B "\n A-1 B-1 \n A-1 A-1 " ()))))))) ((map/tree (lambda (sexp) (cond ((board? sexp) (to-string sexp)) (else sexp)))) (game-tree (make-board #((A 1) (B 1) (A 2) (B 1)) 2) (apply circular-list '(A B)) 0 #t))) (test '(A) (winners (make-board #((A 1) (B 1) (A 1) (A 1)) 2))) (test "\n B-3 A-2 A-3 B-3 A-4 \n B-4 A-3 A-4 B-2 B-3 \n B-2 A-3 B-3 B-2 B-3 \n B-4 A-4 B-3 A-3 A-1 \n A-1 B-3 A-3 B-1 A-4 " (with-output-to-string (τ (display (gen-board 5 '(A B) 4))))) (test "\n \n \n \n \nCurrent player: A\nBoard:A-1 A-3 B-3 A-1 A-1 B-2 B-3 B-1 B-1 A-1 A-2 B-3 A-2 A-2 A-1 B-2 \n \n \n \n \nCurrent player: A\nBoard:A-1 A-1 B-3 A-1 A-1 A-2 B-3 B-1 B-1 A-1 A-2 B-3 A-2 A-2 A-1 B-2 \n \n \n \n \nCurrent player: A\nBoard:A-1 A-1 B-3 A-1 A-1 A-2 B-3 B-1 A-1 A-1 A-2 B-3 A-1 A-2 A-1 B-2 \n \n \n \n \nCurrent player: B\nBoard:A-2 A-2 B-3 A-1 A-1 A-2 B-3 B-1 A-1 A-1 A-2 B-3 A-1 A-2 A-1 B-2 \n \n \n \n \nCurrent player: B\nBoard:A-2 B-2 B-1 A-1 A-1 A-2 B-3 B-1 A-1 A-1 A-2 B-3 A-1 A-2 A-1 B-2 \nThe winner is A" (with-output-to-string (τ (let ((board (gen-board 4 '(A B) 3)) (players (apply circular-list '(A B)))) ((computer-vs-computer 4) (game-tree board players 0 #t)))))) ) (newline) (let ((board (gen-board 5 '(A B) 3)) (players (apply circular-list '(A B)))) ((computer-vs-computer 4) (game-tree board players 0 #t))) (newline) ;------------------------------------------------------------------------ (test-exit)

false

7ad999a6f24207888624873628c311d0c8912eee

86421b0c61e7771ff4d88058cbeaf89a3ec7c01d

/exercises/3.38-3.49.scm

b74afce486cc8cc67d9f1d5541f0e94d1cc5fb8c

[]

no_license

manhtai/sicp

1b354c89795dff516264687c473daadc9e867c56

7730c6bbf537341d8781ede7d8f6b35384d5a802

refs/heads/master

2021-01-18T14:11:28.706888

2015-04-25T03:51:10

40,075,797

0

null

UTF-8

Scheme

false

649

scm

3.38-3.49.scm

;; EXERCISE 3.38 ;: 1: (set! balance (+ balance 10)) ;: 2: (set! balance (- balance 20)) ;: 3: (set! balance (- balance (/ balance 2))) ;; 1,2 = 2,1, so we have ;; 1,2,3 ;; 1,3,2 ;; 2,3,1 ;; 3,1,2 ;; ========================================================================== ;; I leave it here to later ;; ========================================================================== (define x 10) (parallel-execute (lambda () (set! x (* x x))) (lambda () (set! x (+ x 1)))) x (define x 10) (define s (make-serializer)) (parallel-execute (s (lambda () (set! x (* x x)))) (s (lambda () (set! x (+ x 1))))) x

false

586fb6a6add9e0c4b4b5e2f5ba5866340b923687

e76da0bc738f15fbdc7ba8a92265a866592e8d96

/random-coloring-data.scm

91aad787b5d107106a2efe5fe974a0709af17e87

[]

no_license

pujun-ai/aima

42bba66982dc9043640d821cfb3d1117fbe28986

df78e161f22ddb677dbf2fa819e5a4869be22f50

refs/heads/master

2022-07-21T08:14:01.824495

2014-12-26T04:58:58

null

0

null

UTF-8

Scheme

false

428

scm

random-coloring-data.scm

#!/usr/bin/env chicken-scheme (use debug matchable posix srfi-13) (with-output-to-file "random-coloring-data.csv" (lambda () (format #t "index,n,time~%") (for-each (lambda (file) (match (string-split (with-input-from-file file read-line) ",") ((index n time) (format #t "~a,~a,~a~%" index n time)))) (find-files "random-coloring"))))

false

8d26cdac7ba45eb8c755ec677e9dc5526e6ea775

ebf028b3a35ae1544bba1a1f9aa635135486ee6c

/templates/hello-world.scm

150b4e112ea02f02c624e0cab9cfb446040e66c1

[ "BSD-2-Clause", "BSD-3-Clause" ]

permissive

tabe/lunula

b4b666151874271211744cce1346e58e3a56fa79

b7699a850b9c9a64c1d3a52d50ce20050bd17475

refs/heads/master

2021-01-01T20:04:43.571993

2010-05-06T15:39:31

334,916

2

0

null

UTF-8

Scheme

false

17

scm

hello-world.scm

(__ hello-world)

false

9f856a6380cbd6f3f10e8b6198d30493cb8938c8

09e309c8c7dd86d201f965a12f4f174fd2bf8cf5

/scheme/http-server.scm

fc1658cc8e1021e8b1c86b52930de1caf879dc74

[]

no_license

googol-lab/lang

f21076846b2364ee08875530ab7a6680de61f55c

38cae455f85464a7f918d1a5a481a577ed5549fe

refs/heads/master

2020-03-29T13:32:29.159544

2010-05-24T03:09:54

null

0

null

UTF-8

Scheme

false

3,728

scm

http-server.scm

;; -*- coding: utf-8 -*- (use gauche.net) (use util.match) (use rfc.822) (use rfc.uri) (use text.tree) (use text.html-lite) (use www.cgi) (use util.list) (use srfi-27) (define (run-server) (let1 server-sock (make-server-socket 'inet 8080 :reuse-addr? #t) (guard (e [else (socket-close server-sock) (raise e)]) (let loop ((client (socket-accept server-sock))) (guard (e [else (socket-close client) (raise e)]) (handle-request (get-request (socket-input-port client)) (socket-output-port client)) (socket-close client)) (loop (socket-accept server-sock)))))) (define (get-request iport) (rxmatch-case (read-line iport) [test eof-object? 'bad-request] [#/^(GET|HEAD)\s+(\S+)\s+HTTP\/\d+\.\d+$/ (_ meth abs-path) (list* meth abs-path (rfc822-header->list iport))] [#/^[A-Z]+/ () 'not-implemented] [else 'bad-request])) (define (handle-request request oport) (match request ['bad-request (display "HTTP/1.1 400 Bad Request\r\n\r\n" oport)] ['not-implemented (display "HTTP/1.1 501 Not Implemented\r\n\r\n" oport)] [(meth abs-path . headers) (receive (auth path q frag) (uri-decompose-hierarchical abs-path) (let1 content (render-content path (cgi-parse-parameters :query-string (or q ""))) (display "HTTP/1.1 200 OK\r\n" oport) (display "Content-Type: text/html; charset=utf-8\r\n" oport) (display #`"Content-Length: ,(string-size content)\r\n" oport) (display "\r\n" oport) (when (equal? meth "GET") (display content oport))))])) (define *dungeon* '(["あなたは森の北端にいる。道は南に続いている" (s . 1)] ["あなたは鬱蒼として森の中の道にいる。\n道は南北に伸びている。東に降りてゆく小径がある。" (n . 0) (s . 2) (e . 3)] ["足下がぬかるんでいる。道は直角に折れ，北と西に伸びている。西に続く道の先が明るくなっている。" (n . 1) (w . 4)] ["あなたは沼のほとりにいる。空気の動きが止まり，暑さを感じる。西に上ってゆく小径がある。" (w . 1)] ["突然目の前が開けた。あなたは森の中の広場にいる。丈の短い，柔らかそうな草が一面に広場を覆っている。道が東に伸びている。" (e . 2)])) (random-source-randomize! default-random-source) (define *conts* (make-hash-table 'eqv?)) (define *max-id* (expt 2 64)) (define (push-cont! cont) (let1 cid (random-integer *max-id*) (cond [(hash-table-get *conts* cid #f) (push-cont! cont)] [else (hash-table-put! *conts* cid cont) cid]))) (define (a/cont cont . args) (let1 cid (push-cont! cont) (apply html:a :href #`"?c=,cid" args))) (define (get-cont params) (hash-table-get *conts* (cgi-get-parameter "c" params :convert string->number) #f)) (define (get-direction dir) (assoc-ref '((n . "北") (e . "東") (w . "西") (s . "南")) dir)) (define (render-content path params) (cond [(get-cont params) => (cut <> params)] [else (run-application params)])) (define (run-application params) (let loop ((location (list-ref *dungeon* 0)) (history '())) (define (render-selector selector) (html:li (a/cont (lambda (params) (loop (list-ref *dungeon* (cdr selector)) (cons location history))) (get-direction (car selector)) "へ進む"))) (tree->string (html:html (html:head (html:title "simple httpd")) (html:body (html:p (html-escape-string (car location))) (html:ul (map render-selector (cdr location))) (html:hr) (map (lambda (p) (html:p (html-escape-string (car p)))) history)))))) (define (main args) (run-server) 0)

false

6fe0ee35f03ce5eee38d700d7640d7b0a6fa8b44

c74dcb1facbd920d762017345171f47f8e41d0c5

/chapter_3/3.54.scm

2e3ddd5e220c1723d81d4ec7c6985255f0ad1bc0

[]

no_license

akash-akya/sicp-exercises

5125c1118c7f0e4400cb823508797fb67c745592

c28f73719740c2c495b7bc38ee8b790219482b67

refs/heads/master

2021-06-15T19:12:47.679967

2019-08-03T14:03:20

136,158,517

0

null

UTF-8

Scheme

false

751

scm

3.54.scm

#lang sicp (#%require "utils.scm") (#%require "stream-utils.scm") ;; Exercise 3.54: Define a procedure mul-streams, analogous to ;; add-streams, that produces the elementwise product of its two input ;; streams. Use this together with the stream of integers to complete ;; the following definition of the stream whose n th element (counting ;; from 0) is n + 1 factorial: ;; (define factorials ;; (cons-stream 1 (mul-streams ⟨??⟩ ⟨??⟩))) (define ones (cons-stream 1 ones)) (define integers (cons-stream 1 (add-streams ones integers))) (define (mul-streams a b) (stream-map * a b)) (define factorials (cons-stream 1 (mul-streams factorials integers))) ;; test (define (test) (test-equal (stream-ref factorials 5) 120)) (test)

false

f40916f8e095a3c3d24f2b56cc436e16d40993dd

0f9909b1ea2b247aa9dec923d58e4d0975b618e6

/tests/simple.scm

f8ff107d4be552165d7b2a980aca6a74059eba84

[]

no_license

suranap/sausage

9898ad418e2bdbb7e7a1ac798b52f17c589a4cb4

9a03ff3c52cd69278ea75733491e95362cc8765d

refs/heads/master

2016-09-10T19:31:11.990203

2013-05-01T14:48:50

9,792,997

1

0

null

UTF-8

Scheme

false

448

scm

simple.scm

(define (fib n) (if (< n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))) (define (fact n) (if (< n 2) 1 (* n (fact (- n 1))))) (define (deforest f g lst) (map f (map g lst))) (define polyvariant (let ((f (lambda (x) x)) (g (lambda (h y z) (h y) (h x)))) (g f 1 2) (g f 3 4))) (define map (lambda (f l) (reverse! (let loop ((l l)) (if (null? l) '() (cons (f (car l)) (loop (cdr l))))))))

false

59f415afb9daaf228115c7e4e0185206341e40f2

86421b0c61e7771ff4d88058cbeaf89a3ec7c01d

/exercises/2.17-2.52.scm

0a8ab2a071e1f99d515f20158c8c22e788e07dce

[]

no_license

manhtai/sicp

1b354c89795dff516264687c473daadc9e867c56

7730c6bbf537341d8781ede7d8f6b35384d5a802

refs/heads/master

2021-01-18T14:11:28.706888

2015-04-25T03:51:10

40,075,797

0

null

UTF-8

Scheme

false

27,340

scm

2.17-2.52.scm

;; EXERCISE 2.17 (define (last-pair l) (if (null? (cdr l)) (car l) (last-pair (cdr l)))) (last-pair (list 23 72 149 34)) ; 34 ;; EXERCISE 2.18 (define (reverse l) (if (null? (cdr l)) l (append (reverse (cdr l)) (list (car l))))) (reverse (list 1 4 9 16 25)) ;; EXERCISE 2.19 (define us-coins (list 50 25 10 5 1)) (define uk-coins (list 100 50 20 10 5 2 1 0.5)) (define (cc amount coin-values) (cond ((= amount 0) 1) ((or (< amount 0) (no-more? coin-values)) 0) (else (+ (cc amount (except-first-denomination coin-values)) (cc (- amount (first-denomination coin-values)) coin-values))))) (define (first-denomination l) (car l)) (define (except-first-denomination l) (cdr l)) (define (no-more? l) (null? l)) (cc 100 us-coins) ; 292 ;; EXERCISE 2.20 (define (same-parity first . last) (let ((sign (modulo first 2))) (define (same last) (if (null? (cdr last)) last (append (list (if (= (modulo (car last) 2) sign) (car last) nil)) (same (cdr last))))) (append (list first) (same last)))) ;; We can do this better when we learn about `filter`, but that's another story (same-parity 1 2 3 4 5 6 7) (same-parity 2 3 4 5 6 7) ;; EXERCISE 2.21 (define (square-list items) (if (null? items) nil (cons (square (car items)) (square-list (cdr items))))) (square-list (list 1 2 3 4)) (define (square-list items) (map square items)) (square-list (list 1 2 3 4)) ;; map is more elegant despite everything is the same inside ;) ;; EXERCISE 2.22 (define (square-list items) (define (iter things answer) (if (null? things) answer (iter (cdr things) (cons (square (car things)) answer)))) (iter items nil)) ;; Order is reversed because 'car' extract from left to right and ;; 'cons' append in that same order to answer, hence the result is ;; reversed (square-list (list 1 2 3 4)) ;; Interchange thing (define (square-list items) (define (iter things answer) (if (null? things) answer (iter (cdr things) (cons answer (square (car things)))))) (iter items nil)) (square-list (list 1 2 3 4)) ;; This doesn't work because answer is a list, 'cons' a list to a ;; number will make list in list, not the thing we want, a list ;; EXERCISE 2.23 (define (for-each p l) (if (null? (cdr l)) (p (car l)) (for-each p ((lambda (l) (p (car l)) (cdr l)) l)))) ;; Now we see that lambda body can have more than 2 combinations ;; and it's only count the last to be the return? (I'm not very sure) (for-each (lambda (x) (newline) (display x)) (list 57 321 88)) ;; EXERCISE 2.24 ;; (list 1 (list 2 (list 3 4))) ;; . ;; 1 . ;; 2 . ;; 3 4 ;; EXERCISE 2.25 (define l1 '( 1 3 (5 7) 9)) (define l2 '((7))) (define l3 '( 1 ( 2 ( 3 ( 4 ( 5 ( 6 7))))))) (car (cdr (car (cdr (cdr l1))))) ; or shortcut (car (cdaddr l1)) (car (car l2)) ; or shortcut (caar l2) (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr l3)))))))))))) ; or short cut (cadadr (cadadr (cadadr l3))) ;; I must confess: the shortcuts I look in the solutions :D ;; I must miss things on the book ;; EXERCISE 2.26 (define x '(1 2 3)) (define y '(4 5 6)) (append x y) ; append to list: (1 2 3 4 5 6) (cons x y) ; cons this list to begining of another list: ((1 2 3) 4 5 6) (list x y) ; cons 2 lists together: ((1 2 3) (4 5 6)) ;; EXERCISE 2.27 (define (reverse l) (if (null? (cdr l)) l (append (reverse (cdr l)) (list (car l))))) (define (deep-reverse x) (cond ((not (pair? x)) x) ((null? (cdr x)) (deep-reverse x)) ; If you use (deep-reverse (car x)) (else (list (deep-reverse (cadr x)) ; then here you use (car x) here, respectly (deep-reverse (car x)))))) (define x (list (list 1 2) (list 3 4))) x (reverse x) (deep-reverse x) ;; EXERCISE 2.28 (define (fringe x) (cond ((not (pair? x)) (list x)) ((null? (cdr x)) (fringe (car x))) (else (append (fringe (car x)) (fringe (cdr x)))))) (define x (list (list 1 2) (list 3 4))) (fringe x) ; (1 2 3 4) (fringe (list x x)) ; (1 2 3 4 1 2 3 4) ;; EXERCISE 2.29 (define (make-mobile left right) (list left right)) (define (make-branch length structure) (list length structure)) ;; part a (define (left-branch m) (car m)) (define (right-branch m) (cadr m)) (define (branch-length b) (car b)) (define (branch-structure b) (cadr b)) ;; 0-------1---+(7) ;; | | ;; | +(9) ;; | ;; 2---+(3) ;; | ;; +(4) (define b7 (make-branch 3 7)) (define b9 (make-branch 1 9)) (define m1 (make-mobile b7 b9)) (define b1 (make-branch 8 m1)) (define b3 (make-branch 2 3)) (define b4 (make-branch 1 4)) (define m2 (make-mobile b3 b4)) (define b2 (make-branch 3 m2)) (define m0 (make-mobile b1 b2)) ;; part b (define (total-weight m) (define (weight b) (if (pair? (branch-structure b)) (total-weight (branch-structure b)) (branch-structure b))) (+ (weight (left-branch m)) (weight (right-branch m)))) (total-weight m1) ; 9+7 = 16 (total-weight m2) ; 3+4 = 7 (total-weight m0) ; 7+9+3+4 = 23 ;; part c (define (balance? m) (let ((lb (left-branch m)) (rb (right-branch m))) (define (torque b) (let ((bs (branch-structure b))) (* (branch-length b) (if (pair? bs) (total-weight bs) bs)))) (and (= (torque lb) (torque rb)) (if (pair? (branch-structure lb)) (balance? (branch-structure lb)) #t) (if (pair? (branch-structure rb)) (balance? (branch-structure rb)) #t)))) (balance? m0) ; #f ;; a---(1) ;; | ;;(3) (define b13 (make-branch 3 1)) (define b23 (make-branch 1 3)) (define ma (make-mobile b13 b23)) (balance? ma) ; #t ;; x-----y-----y1(2) ;; | | ;; z(35) | ;; y2(5) (define y1 (make-branch 5 2)) (define y2 (make-branch 2 5)) (define my (make-mobile y1 y2)) (define y (make-branch 5 my)) (define z (make-branch 1 35)) (define x (make-mobile z y)) (total-weight x) ; 42 (balance? x) ; #t ;; part d (define (make-mobile left right) (cons left right)) (define (make-branch length structure) (cons length structure)) ;; I guess I need to change only this (define (left-branch m) (car m)) (define (right-branch m) (cdr m)) (define (branch-length b) (car b)) (define (branch-structure b) (cdr b)) ;; Verify that! (define y1 (make-branch 5 2)) (define y2 (make-branch 2 5)) (define my (make-mobile y1 y2)) (define y (make-branch 5 my)) (define z (make-branch 1 35)) (define x (make-mobile z y)) (total-weight x) ; 42 (balance? x) ; #t ;; INDEED! ;; EXERCISE 2.30 ;; Mapping over trees (define (scale-tree tree factor) (cond ((null? tree) nil) ((not (pair? tree)) (* tree factor)) (else (cons (scale-tree (car tree) factor) (scale-tree (cdr tree) factor))))) (scale-tree (list 1 (list 2 (list 3 4) 5) (list 6 7)) 10) ;; Using map (define (scale-tree tree factor) (map (lambda (sub-tree) (if (pair? sub-tree) (scale-tree sub-tree factor) (* sub-tree factor))) tree)) ;; Square over tree using map (define (square x) (* x x)) (define (square-tree tree) (map (lambda (sub-tree) (if (pair? sub-tree) (square-tree sub-tree) (square sub-tree))) tree)) (square-tree (list 1 (list 2 (list 3 4) 5) (list 6 7))) ;; Directly (define (square-tree tree) (cond ((null? tree) nil) ((not (pair? tree)) (square tree)) (else (cons (square-tree (car tree)) (square-tree (cdr tree)))))) (square-tree (list 1 (list 2 (list 3 4) 5) (list 6 7))) ;; EXERCISE 2.31 (define (tree-map p tree) (map (lambda (sub-tree) (if (pair? sub-tree) (tree-map p sub-tree) (p sub-tree))) tree)) ;; Bookmarked! (define (square-tree tree) (tree-map square tree)) (square-tree (list 1 (list 2 (list 3 4) 5) (list 6 7))) ;; EXERCISE 2.32 (define (subsets s) (if (null? s) (list nil) (let ((rest (subsets (cdr s)))) (append rest (map (lambda (x) (cons (car s) x)) rest))))) ;; It works because assume we had the subsets of (cdr s) then all we need ;; include to this subsets for making the set of all subsets of s ;; are lists include (car s) and the subsets of (cdr s), and the procedure ;; (lambda (x) (cons (car s) x)) take each element in rest as an argument ;; and return the lists we need. (subsets '(1 2 3)) ;; ========================================================================= ;; Sequence operations (define (filter predicate sequence) (cond ((null? sequence) nil) ((predicate (car sequence)) (cons (car sequence) (filter predicate (cdr sequence)))) (else (filter predicate (cdr sequence))))) (filter odd? (list 1 2 3 4 5)) (define (accumulate op initial sequence) (if (null? sequence) initial (op (car sequence) (accumulate op initial (cdr sequence))))) (accumulate + 0 (list 1 2 3 4 5)) (accumulate * 1 (list 1 2 3 4 5)) (accumulate cons nil (list 1 2 3 4 5)) (define (enumerate-interval low high) (if (> low high) nil (cons low (enumerate-interval (+ low 1) high)))) (enumerate-interval 2 7) (define (enumerate-tree tree) (cond ((null? tree) nil) ((not (pair? tree)) (list tree)) (else (append (enumerate-tree (car tree)) (enumerate-tree (cdr tree)))))) (enumerate-tree (list 1 (list 2 (list 3 4)) 5)) ;; EXERCISE 2.33 ;; some more basis list-manipulation (define (new-map p sequence) (accumulate (lambda (x y) (cons (p x) y)) nil sequence)) ;; Re-define map, awesome! (new-map square '(1 2 3 4 5)) ; '(1 4 9 16 25) (define (append seq1 seq2) (accumulate cons seq2 seq1)) ;; Re-define append, good! (append '(1 2 3) '(4 5 6)) ; '(1 2 3 4 5 6) (define (length sequence) (accumulate (lambda (x y) (+ 1 y)) 0 sequence)) ;; Re-define length, fine! (length '(1 2 3 4 5 6)) ; 6 ;; EXERCISE 2.34 (define (horner-eval x coefficient-sequence) (accumulate (lambda (this-coeff higher-terms) (+ this-coeff (* x higher-terms))) 0 coefficient-sequence)) (horner-eval 2 (list 1 3 0 5 0 1)) ; 79 ;; EXERCISE 2.35 ;; Old count-leaves (define (count-leaves x) (cond ((null? x) 0) ((not (pair? x)) 1) (else (+ (count-leaves (car x)) (count-leaves (cdr x)))))) (define x (cons (list 1 2) (list 3 4))) (count-leaves x) ; 4 (count-leaves (list x x)) ; 8 ;; New count-leaves (define (count-leaves t) (accumulate (lambda (x y) (+ x y)) 0 (map (lambda (x) (if (pair? x) (count-leaves x) 1)) t))) ;; The `map` function change t to a sequence of 1 as equivalent to one leaf, ;; the remaining job is to sum all together by `lambda` ;; Yes, map over tree it is ;) (count-leaves x) ; 4 (count-leaves (list x x)) ; 8 ;; EXERCISE 2.36 (define (accumulate-n op init seqs) (if (null? (car seqs)) nil (cons (accumulate op init (map car seqs)) (accumulate-n op init (map cdr seqs))))) (define s '((1 2 3) (4 5 6) (7 8 9) (10 11 12))) (accumulate-n + 0 s) ; (22 26 30) ;; EXERCISE 2.37 ;; Test map with default implementation (map + (list 1 2 3) (list 40 50 60) (list 700 800 900)) ; (741 852 963) (map (lambda (x y) (+ x (* 2 y))) (list 1 2 3) (list 4 5 6)) ; (9 12 15) ;; Matrix algebra, yeah ;)) (define (dot-product v w) (accumulate + 0 (map * v w))) (define (matrix-*-vector m v) (map (lambda (x) (dot-product v x)) m)) (define (transpose mat) (accumulate-n cons '() mat)) (define (matrix-*-matrix n m) (let ((cols (transpose n))) (map (lambda (v) (matrix-*-vector cols v)) m))) (define m '((1 2 3 4) (4 5 6 6) (6 7 8 9))) (define n '((1 0 0 0) (0 1 0 0) (0 0 1 0))) (define i '((1 0 0) (0 1 0) (0 0 1))) (define k '(1 1 1 1)) (define v '(1 1 1)) (define w '(7 8 9)) (dot-product v w) ; 24 (matrix-*-vector m k) ; '(10 21 30) (transpose m) ; '((1 4 6) (2 5 7) (3 6 8) (4 6 9)) (matrix-*-matrix m i) ; m ;; EXERCISE 2.38 (define fold-right accumulate) (define (fold-left op initial sequence) (define (iter result rest) (if (null? rest) result (iter (op result (car rest)) (cdr rest)))) (iter initial sequence)) (fold-right / 1 (list 1 2 3)) ;; (/ 1 (/ 2 (/ 3 1))) ;; 3/2 (fold-left / 1 (list 1 2 3)) ;; (/ (/ (/ 1 1) 2) 3) ;; 1/6 (fold-right list nil (list 1 2 3)) ;; (list 1 (list 2 (list 3 nil))) (fold-left list nil (list 1 2 3)) ;; (list (list (list 1 nil) 2) 3) ;; If (op x y) = (op y x) than fold-right and fold-left are the same ;; EXERCISE 2.39 (define (reverse sequence) (fold-right (lambda (x y) (append y (list x))) nil sequence)) (reverse '(1 2 3 4 5)) (define (reverse sequence) (fold-left (lambda (x y) (append (list y) x)) nil sequence)) (reverse '(1 2 3 4 5)) ;; ========================================================================= (define (flatmap proc seq) (accumulate append nil (map proc seq))) (define (prime-sum? pair) (prime? (+ (car pair) (cadr pair)))) (define (make-pair-sum pair) (list (car pair) (cadr pair) (+ (car pair) (cadr pair)))) (define (prime-sum-pairs n) (map make-pair-sum (filter prime-sum? (flatmap (lambda (i) (map (lambda (j) (list i j)) (enumerate-interval 1 (- i 1)))) (enumerate-interval 1 n))))) (prime-sum-pairs 5) (define (permutations s) (if (null? s) ; empty set? (list nil) ; sequence containing empty set (flatmap (lambda (x) (map (lambda (p) (cons x p)) (permutations (remove x s)))) s))) (define (remove item sequence) (filter (lambda (x) (not (= x item))) sequence)) ;; EXERCISE 2.40 (define (unique-pairs n) (flatmap (lambda (i) (map (lambda (j) (list i j)) (enumerate-interval 1 (- i 1)))) (enumerate-interval 1 n))) (unique-pairs 3) (define (prime-sum-pairs n) (map make-pair-sum (filter prime-sum? (unique-pairs n)))) (prime-sum-pairs 5) ;; EXERCISE 2.41 (define (s-sum? s t) (= s (+ (car t) (cadr t) (caddr t)))) (define (make-t-sum t) (list (car t) (cadr t) (caddr t) (+ (car t) (cadr t) (caddr t)))) (define (unique-t n) (flatmap (lambda (k) (map (lambda (ij) (cons k ij)) (unique-pairs (- k 1)))) (enumerate-interval 1 n))) (define (find-s-sum n s) (map make-t-sum (filter (lambda (x) (s-sum? s x)) (unique-t n)))) (find-s-sum 6 12) ; '((5 4 3 12) (6 4 2 12) (6 5 1 12)) ;; EXERCISE 2.42 (define (queens board-size) (define (queen-cols k) (if (= k 0) (list empty-board) (filter (lambda (positions) (safe? k positions)) (flatmap (lambda (rest-of-queens) (map (lambda (new-row) (adjoin-position new-row k rest-of-queens)) (enumerate-interval 1 board-size))) (queen-cols (- k 1)))))) (queen-cols board-size)) ;; First step: Do we want to add (row column) to the rest? (define (safe-rc? r c rest) (= 0 (accumulate + 0 (map (lambda (x) (if (or (= c (cadr x)) ; not in same row (= r (car x)) ; not in same colume (= 1 (abs (/ (- c (cadr x)) (- r (car x)))))) ; not in same diagonal 1 0)) rest)))) ;; Second step: If we want, then add it! (define (adjoin-position r c positions) (if (safe-rc? r c positions) (append positions (list (list r c))) nil)) ;; Empty board for the zero step (define empty-board nil) ;; Last step: Are we safe? (define (safe? k rest) (= (- k 1) (accumulate + 0 (map (lambda (x) (if (= k (cadr x)) 0 1)) rest)))) ;; If we're safe, then we're done! (queens 4) ; 2 cases (queens 8) ; Try for yourself! ;; EXERCISE 2.43 ;; Louis's version of queens (define (queens board-size) (define (queen-cols k) (if (= k 0) (list empty-board) (filter (lambda (positions) (safe? k positions)) (flatmap (lambda (new-row) ; exchange this (map (lambda (rest-of-queens) ; with this (adjoin-position new-row k rest-of-queens)) (queen-cols (- k 1)))) ; exchange this (enumerate-interval 1 board-size))))) ; with this (queen-cols board-size)) ;; This version list new n positions in column k joining the first k-1 columns ;; N TIMES WITH EACH ROW FROM 1 TO BOARD-SIZE. There are n (k-1 columns) then ;; the running time is O(n^n). ;; Exercise 2.42 version list new n positions in column k joining the first k-1 colums ;; just ONCE. There are n (k-1 colums) then the running time is O(n^2) ;; So I guess the time in the worse version is propotion to n^n/n^2. I mean n^(n-2).T ;; With n = 8 we have time 8^6 = 262144.T compare with T in the better version. ;; => Algorithms matter! ;; (But were're learning SICP, not Algorithms, by the way) ;; ========================================================================= ;; A Picture Language ;; Test sicp-racket package (open-canvas) (draw wave) (close-canvas) ;; Start learning! (define wave2 (beside wave (flip-vert wave))) (define wave4 (below wave2 wave2)) (define (right-split painter n) (if (= n 0) painter (let ((smaller (right-split painter (- n 1)))) (beside painter (below smaller smaller))))) (clear-canvas) (draw (right-split wave 3)) (define (corner-split painter n) (if (= n 0) painter (let ((up (up-split painter (- n 1))) (right (right-split painter (- n 1)))) (let ((top-left (beside up up)) (bottom-right (below right right)) (corner (corner-split painter (- n 1)))) (beside (below painter top-left) (below bottom-right corner)))))) (clear-canvas) (draw (corner-split wave 3)) (define (square-limit painter n) (let ((quarter (corner-split painter n))) (let ((half (beside (flip-horiz quarter) quarter))) (below (flip-vert half) half)))) ;; EXERCISE 2.44 (define (up-split painter n) (if (= n 0) painter (let ((smaller (up-split painter (- n 1)))) (below painter (beside smaller smaller))))) ;; For later testing (clear-canvas) (draw (up-split wave 3)) ;; EXERCISE 2.45 (define (split dir-a dir-b) (lambda (p n) (if (= n 0) p (let ((smaller ((split dir-a dir-b) p (- n 1)))) (dir-a p (dir-b smaller smaller)))))) (define right-split (split beside below)) (define up-split (split below beside)) ;; For later testing (clear-canvas) (draw (right-split wave 3)) (clear-canvas) (draw (up-split wave 3)) (close-canvas) ;; EXERCISE 2.46 (define (make-vect a b) (cons a b)) (define xcor-vect car) (define ycor-vect cdr) (define (add-vect v1 v2) (make-vect (+ (xcor-vect v1) (xcor-vect v2)) (+ (ycor-vect v1) (ycor-vect v2)))) (define (sub-vect v1 v2) (make-vect (- (xcor-vect v1) (xcor-vect v2)) (- (ycor-vect v1) (ycor-vect v2)))) (define (scale-vect s v) ; vec after s (make-vect (* s (xcor-vect v)) (* s (ycor-vect v)))) ;; EXERCISE 2.47 ;; Book code (define (frame-coord-map frame) (lambda (v) (add-vect (origin-frame frame) (add-vect (scale-vect (xcor-vect v) (edge1-frame frame)) (scale-vect (ycor-vect v) (edge2-frame frame)))))) ;; Implement 1 (define (make-frame origin edge1 edge2) (list origin edge1 edge2)) (define origin-frame car) (define edge1-frame cadr) (define edge2-frame caddr) ;; ;; Implement 2 ;; (define (make-frame origin edge1 edge2) (cons origin (cons edge1 edge2))) ;; (define origin-frame car) ;; (define edge1-frame cadr) ;; (define edge2-frame cddr) ;; EXERCISE 2.48 (define (make-segment v1 v2) (list v1 v2)) (define start-segment car) (define end-segment cadr) ;; EXERCISE 2.49 (define (segments->painter segment-list) (lambda (frame) (for-each (lambda (segment) (line ; we use line here instead of draw-line to draw it in canvas ((frame-coord-map frame) (start-segment segment)) ((frame-coord-map frame) (end-segment segment)))) segment-list))) ;; part a: outline (define outline (segments->painter (list (make-segment (make-vect 0.0 0.0) (make-vect 0.0 1.0)) (make-segment (make-vect 0.0 1.0) (make-vect 1.0 1.0)) (make-segment (make-vect 1.0 1.0) (make-vect 1.0 0.0)) (make-segment (make-vect 1.0 0.0) (make-vect 0.0 0.0))))) (open-canvas) (draw outline) ;; part b: X (define X (segments->painter (list (make-segment (make-vect 0.0 0.0) (make-vect 1.0 1.0)) (make-segment (make-vect 0.0 1.0) (make-vect 1.0 0.0))))) (clear-canvas) (draw X) ;; part c: diamond (define diamond (segments->painter (list (make-segment (make-vect 0.5 0.0) (make-vect 1.0 0.5)) (make-segment (make-vect 1.0 0.5) (make-vect 0.5 1.0)) (make-segment (make-vect 0.5 1.0) (make-vect 0.0 0.5)) (make-segment (make-vect 0.0 0.5) (make-vect 0.5 0.0))))) (clear-canvas) (draw diamond) ;; part d: wave (clear-canvas) (draw wave) ;; EXERCISE 2.50 ;; Book code (define (transform-painter painter origin corner1 corner2) (lambda (frame) (let ((m (frame-coord-map frame))) (let ((new-origin (m origin))) (painter (make-frame new-origin (sub-vect (m corner1) new-origin) (sub-vect (m corner2) new-origin))))))) (define (flip-vert painter) (transform-painter painter (make-vect 0.0 1.0) ; new origin (make-vect 1.0 1.0) ; new end of edge1 (make-vect 0.0 0.0))) ; new end of edge2 ;; Test that! (clear-canvas) (draw (flip-vert wave)) (define (shrink-to-upper-right painter) (transform-painter painter (make-vect 0.5 0.5) (make-vect 1.0 0.5) (make-vect 0.5 1.0))) (define (rotate90 painter) (transform-painter painter (make-vect 1.0 0.0) (make-vect 1.0 1.0) (make-vect 0.0 0.0))) (define (squash-inwards painter) (transform-painter painter (make-vect 0.0 0.0) (make-vect 0.65 0.35) (make-vect 0.35 0.65))) (define (beside painter1 painter2) (let ((split-point (make-vect 0.5 0.0))) (let ((paint-left (transform-painter painter1 (make-vect 0.0 0.0) split-point (make-vect 0.0 1.0))) (paint-right (transform-painter painter2 split-point (make-vect 1.0 0.0) (make-vect 0.5 1.0)))) (lambda (frame) (paint-left frame) (paint-right frame))))) (clear-canvas) (draw (beside wave diamond)) ;; Our code ;; flip-horiz (define (flip-horiz painter) (transform-painter painter (make-vect 1.0 0.0) ; new origin (make-vect 0.0 0.0) ; new end of edge1 (make-vect 1.0 1.0))) ; new end of edge2 (clear-canvas) (draw (flip-horiz wave)) ;; rotate 180 (define (rotate180 painter) (transform-painter painter (make-vect 1.0 1.0) (make-vect 0.0 1.0) (make-vect 1.0 0.0))) (clear-canvas) (draw (rotate180 wave)) ;; rotate 270 (define (rotate270 painter) (transform-painter painter (make-vect 0.0 1.0) (make-vect 0.0 0.0) (make-vect 1.0 1.0))) (clear-canvas) (draw (rotate270 wave)) ;; EXERCISE 2.51 ;; Way 1 (define (below p1 p2) (let ((split-point (make-vect 0.0 0.5))) (let ((paint-top (transform-painter p1 split-point (make-vect 1.0 0.5) (make-vect 0.0 1.0))) (paint-bottom (transform-painter p2 (make-vect 0.0 0.0) (make-vect 1.0 0.0) split-point))) (lambda (frame) (paint-top frame) (paint-bottom frame))))) (clear-canvas) (draw (below wave wave2)) ;; Way 2 (define (below p1 p2) (rotate180 (rotate90 (beside (rotate90 p2) (rotate90 p1))))) (clear-canvas) (draw (below wave wave2)) ;; EXERCISE 2.52 ;; part a: smile Geogre (define smile-geogre (segments->painter (append (list (make-segment (make-vect 0.40 0.80) (make-vect 0.50 0.70)) (make-segment (make-vect 0.50 0.70) (make-vect 0.60 0.80)) (make-segment (make-vect 0.35 0.85) (make-vect 0.40 0.90)) (make-segment (make-vect 0.40 0.90) (make-vect 0.45 0.85)) (make-segment (make-vect 0.65 0.85) (make-vect 0.60 0.90)) (make-segment (make-vect 0.60 0.90) (make-vect 0.55 0.85))) geogre))) (clear-canvas) (draw smile-geogre) ;; part b and c original book code (define (corner-split painter n) (if (= n 0) painter (let ((up (up-split painter (- n 1))) (right (right-split painter (- n 1)))) (let ((top-left (beside up up)) (bottom-right (below right right)) (corner (corner-split painter (- n 1)))) (beside (below painter top-left) (below bottom-right corner)))))) (clear-canvas) (draw (corner-split smile-geogre 3)) (define (square-limit painter n) (let ((quarter (corner-split painter n))) (let ((half (beside (flip-horiz quarter) quarter))) (below (flip-vert half) half)))) (clear-canvas) (draw (square-limit smile-geogre 3)) ;; part b: (define (corner-split2 painter n) (if (= n 0) painter (let ((right (right-split painter (- n 1))) (up (up-split painter (- n 1))) (corner (corner-split2 painter (- n 1)))) (beside (below painter up) (below right corner))))) (clear-canvas) (draw (corner-split2 smile-geogre 3)) ;; part c: (define (square-limit2 painter n) (let ((combine4 (square-of-four flip-vert rotate180 identity flip-horiz))) (combine4 (corner-split painter n)))) (clear-canvas) (draw (square-limit2 smile-geogre 3)) (clear-canvas) (draw (square-limit smile-geogre 3)) (close-canvas)

false

6b1a9424a9471aa7687967578d1e62a0083bbbf3

41bcee828232d33f629d5fcfacd2bd93aa6ab1eb

/hiss.meta

0239276d10d26f4be5e54fabe0cf436ff4151950

[]

no_license

ThomasHintz/chicken-scheme-shell

4458b407dc58c1ecefa7aedd0604cd04a99492c9

6f0b418939f79de9ef64d4ff0598ded9672286df

refs/heads/master

2020-12-30T11:14:54.247011

2016-01-13T19:49:20

1,810,708

5

0

null

UTF-8

Scheme

false

132

meta

hiss.meta

;;; hiss.meta -*- scheme -*- ((egg "hiss.egg") (synopsis "hiss is a chicken scheme shell.") (license "BSD") (depends readline))

false

2957b44c0c259c9791f4bcff96f3375f64ededbf

68c4bab1f5d5228078d603066b6c6cea87fdbc7a

/lab/frozen/just-born/rifle/src/mzscheme/struct/struct.ss

0a5977c65dc1e4284d2695c737228712404f9c04

[]

no_license

felipelalli/micaroni

afab919dab304e21ba916aa6310dca102b1a04a5

741b628754b7c7085d3e68009a621242c2a1534e

refs/heads/master

2023-08-03T06:25:15.405861

2023-07-25T14:44:56

537,536

2

1

null

UTF-8

Scheme

false

1,037

ss

struct.ss

(load "../little-error-control/little-error-control.ss") ; (new-struct 'nome-do-tipo) (define-syntax new-struct (syntax-rules () ((new-struct type-name) (make-little-object type-name (make-hash-table))))) ; (set-value! struct 'field value) (define-syntax set-value! (syntax-rules () ((set struct field value) (hash-table-put! (car (cdr struct)) field value)))) ; (get-value struct 'field value) (define-syntax get-value (syntax-rules () ((set struct field) (hash-table-get (car (cdr struct)) field (make-error 'field-not-found (string-append "the field '" (symbol->string field) "' isn't found!")))))) (define print-field (lambda (key value) (display key) (display ":") (display value) (display "\n"))) (define-syntax struct-debug (syntax-rules () ((struct-debug s) (hash-table-for-each (car (cdr s)) print-field))))

true

49e06485432a7bf60fcb7a82b459a729d4c5431e

4bd59493b25febc53ac9e62c259383fba410ec0e

/Scripts/Task/harshad-or-niven-series/scheme/harshad-or-niven-series.ss

7b6d2d48beb42813298a0484ba2158764a601f77

[]

no_license

stefanos1316/Rosetta-Code-Research

160a64ea4be0b5dcce79b961793acb60c3e9696b

de36e40041021ba47eabd84ecd1796cf01607514

refs/heads/master

2021-03-24T10:18:49.444120

2017-08-28T11:21:42

88,520,573

5

1

null

UTF-8

Scheme

false

776

ss

harshad-or-niven-series.ss

#!/usr/local/bin/gosh ;; Show the first 20 niven numbers and the ;; first one greater than 1000. (define (main args) (display (iota-filtered 20 1 niven?))(newline) (display (iota-filtered 1 1001 niven?))(newline)) ;; Return a list of length n ;; for numbers starting at start ;; that satisfy the predicate fn. (define (iota-filtered n start fn) (let loop ((num start)(lst (list))) (if (= (length lst) n) lst (loop (+ 1 num) (if (fn num) (append lst (list num)) lst))))) ;; Is a number a niven number? (define (niven? n) (and (> n 0) (= 0 (remainder n (sum-of-digits n))))) ;; Get the sum of the digits of a number. (define (sum-of-digits n) (apply + (map string->number (map string (string->list (number->string n))))))

false

25587e44fd0f8a4f2105889f7c40dccb0ec8d079

ff40f278d948cfea9911ee5db3c5cbb3cb41b09e

/tests/drag.scm

76019625510626bc2b037792e9af8ed493fd4593

[]

no_license

mario-goulart/spock

a1da32448b4ff2bf04c2ac4f63d67659f548ad0c

b88f08f8bc689babc433ad8288559ce5c28c52d5

refs/heads/master

2020-05-29T13:49:25.874909

2013-05-30T12:48:49

12,936,406

4

0

null

UTF-8

Scheme

false

1,216

scm

drag.scm

;;;; drag.scm (define (box) (%inline "document.getElementById" "box")) (define (info) (%inline "document.getElementById" "info")) (define down #f) (define (mouse-position event) (values (- (+ (.clientX event) document.body.scrollLeft) document.body.clientLeft) (- (+ (.clientY event) document.body.scrollTop) document.body.clientTop))) (define (mouse-move event) (let ((event (if (void? event) window.event event))) (when down (call-with-values (cut mouse-position event) (lambda (x y) (move-element (box) x y) (show-position x y)))))) (define (move-element elt x y) (set! (.style.left elt) x) (set! (.style.top elt) y)) (define (move-element-by elt x y) (call-with-values (cut element-position elt) (lambda (x1 y1) (move-element elt (+ x1 x) (+ y1 y))))) (define (element-position elt) (values (.offsetLeft elt) (.offsetTop elt))) (define (show-position x y) (set! (.innerHTML (info)) (jstring (string-append (number->string x) "/" (number->string y))))) (set! document.onmousemove (callback mouse-move)) (set! document.onmousedown (callback (lambda () (set! down #t)))) (set! document.onmouseup (callback (lambda () (set! down #f))))

false

fb165ef3299e0e24696b62e2c96eca511968fc72

203ad0bd8ae7276ddb4c12041b1644538957c386

/lib/minikanren/nominal-disequality.sls

58c99149da1141b95f99a02928b619c9d2530a3f

[]

no_license

lkuper/relational-research

b432a6a9b76723a603406998dcbe9f0aceace97c

7ab9955b08d2791fe63a08708415ae3f100f6df5

refs/heads/master

2021-01-25T10:07:27.074811

2010-05-15T04:13:07

2,870,499

1

0

null

UTF-8

Scheme

false

14,652

sls

nominal-disequality.sls

(library (minikanren nominal-disequality) (export run run* run+ conde exist fresh hash =/= == ==-check (rename (make-tie tie))) (import (rnrs)) (define-syntax lambdaf@ (syntax-rules () ((_ () e) (lambda () e)))) (define-syntax lambdag@ (syntax-rules () ((_ (p) e) (lambda (p) e)))) (define-record-type sus (fields pi (immutable v %sus-v))) (define sus-v (lambda (s) (or (%sus-v s) s))) (define-record-type var (parent sus) (fields n)) (define-record-type nom (fields n)) (define-record-type tie (fields a t)) ; v means var, x means sus, a means nom ; s :: ((v . t) ...) ; h* :: ((a . v) ...) ; c* :: ((s . h*) ...) (define-record-type p (fields s h* c*)) (define p/s (lambda (p s) (make-p s (p-h* p) (p-c* p)))) (define p/h* (lambda (p h*) (make-p (p-s p) h* (p-c* p)))) (define p/c* (lambda (p c*) (make-p (p-s p) (p-h* p) c*))) (define empty-p (make-p '() '() '())) (define c-s (lambda (c) (car c))) (define c-h* (lambda (c) (cdr c))) (define make-c (lambda (s h*) `(,s . ,h*))) (define-syntax case-inf (syntax-rules () ((_ e (() e0) ((f^) e1) ((a^) e2) ((a f) e3)) (let ((a-inf e)) (cond ((not a-inf) e0) ((procedure? a-inf) (let ((f^ a-inf)) e1)) ((and (pair? a-inf) (procedure? (cdr a-inf))) (let ((a (car a-inf)) (f (cdr a-inf))) e3)) (else (let ((a^ a-inf)) e2))))))) (define-syntax run (syntax-rules () ((_ n (q) g g* ...) ((cond ((not n) take*) ((number? n) (take n)) (else take+)) (lambdaf@ () ((exist (q) g g* ... (reify q)) empty-p)))))) (define taker (lambda (f st) (case-inf (f) (() '()) ((f) (taker f st)) ((a) `(,(car a) . ,(st (lambdaf@ () #f)))) ((a f) `(,(car a) . ,(st f)))))) (define (take n) (lambda (f) (if (zero? n) '() (taker f (take (- n 1)))))) (define take* (lambda (f) (taker f take*))) (define-syntax run* (syntax-rules () ((_ (x) g ...) (run #f (x) g ...)))) (define take+ (lambda (f) (taker f (lambda (f) (lambda () (take+ f)))))) (define-syntax run+ (syntax-rules () ((_ (x) g ...) (run #t (x) g ...)))) (define apply-pi (lambda (pi t) (let rec ((t t)) (cond ((nom? t) (api pi t)) ((and (var? t) (null? pi)) t) ; for reification ((sus? t) (make-sus (compose-pis pi (sus-pi t)) (sus-v t))) ((tie? t) (make-tie (api pi (tie-a t)) (rec (tie-t t)))) ((pair? t) `(,(rec (car t)) . ,(rec (cdr t)))) (else t))))) (define api (lambda (pi a) (fold-right (lambda (swap a) (cond ((eq? a (car swap)) (cdr swap)) ((eq? a (cdr swap)) (car swap)) (else a))) a pi))) (define disagreement-set (lambda (pi1 pi2) (let* ((i (lambda (a a*) (if (or (memq a a*) (eq? (api pi1 a) (api pi2 a))) a* `(,a . ,a*)))) (c (lambda (pi a*) (fold-left (lambda (a* swap) (i (car swap) (i (cdr swap) a*))) a* pi)))) (c pi1 (c pi2 '()))))) (define compose-pis append) (define invert-pi reverse) (define s-extension (lambda (s^ s) (if (eq? s^ s) '() `(,(car s^) . ,(s-extension (cdr s^) s))))) (define h*-extension (lambda (h*^ h*) (cond ((null? h*^) '()) ((member (car h*^) h*) (h*-extension (cdr h*^) h*)) (else `(,(car h*^) . ,(h*-extension (cdr h*^) h*)))))) (define h*-union (lambda (h*1 h*2) `(,@(h*-extension h*1 h*2) ,@h*2))) (define == (lambda (u v) (lambdag@ (p) (let ((p (nominal-unify u v p))) (and p (let ((c* (verify-c* p))) (and c* (p/c* p c*)))))))) (define nominal-unify (lambda (u v p) (let ((p (unify u v p))) (and p (let ((h* (verify-h* (p-h* p) (p-s p)))) (and h* (p/h* p h*))))))) (define ==-check ==) (define =/= (lambda (u v) (lambdag@ (p) (cond ((nominal-unify u v p) => (lambda (!p) (let ((!s (s-extension (p-s !p) (p-s p))) (!h* (h*-extension (p-h* !p) (p-h* p)))) (and (or (pair? !s) (pair? !h*)) (p/c* p `(,(make-c !s !h*) . ,(p-c* p))))))) (else p))))) (define hash (lambda (a t) (lambdag@ (p) (let ((h* (do-hash a t (p-s p) (p-h* p)))) (and h* (p/h* p h*)))))) (define do-hash (lambda (a t s h*) (let rec ((t t) (h* h*)) (let ((t (walk t s))) (cond ((eq? a t) #f) ((sus? t) (let ((a (apply-pi (invert-pi (sus-pi t)) a))) (ext-h* a (sus-v t) h*))) ((and (tie? t) (not (eq? a (tie-a t)))) (rec (tie-t t) h*)) ((pair? t) (let ((h* (rec (car t) h*))) (and h* (rec (cdr t) h*)))) (else h*)))))) (define verify-h* (lambda (h* s) (let rec ((h* h*) (ac '())) (if (null? h*) ac (let ((ac (do-hash (caar h*) (cdar h*) s ac))) (and ac (rec (cdr h*) ac))))))) (define verify-c* (lambda (p) (let rec ((c* (p-c* p))) (cond ((null? c*) '()) ((unify-c (car c*) p) => (lambda (p^) (let ((!s^ (s-extension (p-s p^) (p-s p))) (!h*^ (verify-h* (h*-union (h*-extension (p-h* p^) (p-h* p)) (c-h* (car c*))) (p-s p)))) (and !h*^ (or (pair? !s^) (pair? !h*^)) `(,(make-c !s^ !h*^) . ,(rec (cdr c*))))))) (else (rec (cdr c*))))))) (define unify-c (lambda (c p) (let rec ((!s (c-s c)) (p p)) (if (null? !s) p (let ((p (nominal-unify (caar !s) (cdar !s) p))) (and p (rec (cdr !s) p))))))) (define walk (lambda (t s) (let rec ((t t) (pi '())) (cond ((and (sus? t) (assq (sus-v t) s)) => (lambda (p) (rec (cdr p) (compose-pis (sus-pi t) pi)))) (else (apply-pi pi t)))))) (define ext-s-check (lambda (v t p) (let ((s (p-s p))) (and (not (occurs? v t s)) (p/s p (cons `(,v . ,t) s)))))) (define tie-t* (lambda (t) (if (tie? t) (tie-t* (tie-t t)) t))) (define occurs? (lambda (v t s) (let rec ((t t)) (let ((t (walk (tie-t* t) s))) (cond ((sus? t) (eq? v (sus-v t))) ((pair? t) (or (rec (car t)) (rec (cdr t)))) (else #f)))))) (define ext-h* (lambda (a v h*) (let ((h `(,a . ,v))) (if (member h h*) h* `(,h . ,h*))))) (define unify (lambda (u v p) (let* ((s (p-s p)) (h* (p-h* p)) (u (walk u s)) (v (walk v s))) (cond ((eq? u v) p) ((and (sus? u) (sus? v) (eq? (sus-v u) (sus-v v))) (unify=sus (disagreement-set (sus-pi u) (sus-pi v)) (sus-v u) p)) ((sus? u) (ext-s-check (sus-v u) (apply-pi (invert-pi (sus-pi u)) v) p)) ((sus? v) (ext-s-check (sus-v v) (apply-pi (invert-pi (sus-pi v)) u) p)) ((and (tie? u) (tie? v)) (unify-ties (tie-a u) (tie-a v) (tie-t u) (tie-t v) p)) ((and (pair? u) (pair? v)) (let ((p (unify (car u) (car v) p))) (and p (unify (cdr u) (cdr v) p)))) ((equal? u v) p) (else #f))))) (define unify=sus (lambda (a* v p) (let rec ((a* a*) (h* (p-h* p))) (if (null? a*) (p/h* p h*) (let ((h* (do-hash (car a*) v (p-s p) h*))) (and h* (rec (cdr a*) h*))))))) (define unify-ties (lambda (au av tu tv p) (if (eq? au av) (unify tu tv p) (let ((h* (do-hash au tv (p-s p) (p-h* p)))) (and h* (unify tu (apply-pi `((,au . ,av)) tv) (p/h* p h*))))))) (define-syntax fresh (syntax-rules () ((_ (x ...) g g* ...) (lambdag@ (p) (lambdaf@ () (let ((x (make-nom 'x)) ...) ((conde (g g* ...)) p))))))) (define-syntax exist (syntax-rules () ((_ (x ...) g g* ...) (lambdag@ (p) (lambdaf@ () (let ((x (make-var '() #f 'x)) ...) ((conde (g g* ...)) p))))))) (define-syntax conde (syntax-rules () ((_ (g g+ ...) (g* g*+ ...) ...) (lambdag@ (p) (lambdaf@ () (mplus* (bind* (g p) g+ ...) (bind* (g* p) g*+ ...) ...)))))) (define-syntax bind* (syntax-rules () ((_ e) e) ((_ e g g* ...) (bind* (bind e g) g* ...)))) (define bind (lambda (a-inf g) (case-inf a-inf (() #f) ((f) (lambdaf@ () (bind (f) g))) ((a) (g a)) ((a f) (mplus (g a) (lambdaf@ () (bind (f) g))))))) (define-syntax mplus* (syntax-rules () ((_ e) e) ((_ e e* ...) (mplus e (lambdaf@ () (mplus* e* ...)))))) (define mplus (lambda (a-inf f) (case-inf a-inf (() (f)) ((f^) (lambdaf@ () (mplus (f) f^))) ((a) `(,a . ,f)) ((a f^) `(,a . ,(lambdaf@ () (mplus (f) f^))))))) ; reification needs to be replaced by something more like the "rak" reifier (define purify-c* (lambda (c* s) (define ground? (lambda (t) (cond ((sus? t) (not (sus? (walk t s)))) ((tie? t) (ground? (tie-t t))) ((pair? t) (and (ground? (car t)) (ground? (cdr t)))) (else #t)))) (filter ground? c*))) (define remove-subsumed-c* (lambda (c*) (let rec ((c* c*) (a '())) (cond ((null? c*) a) ((let* ((c (car c*)) (p (make-p (c-s c) (c-h* c) '()))) (or (subsumed-c*? p (cdr c*)) (subsumed-c*? p a))) (rec (cdr c*) a)) (else (rec (cdr c*) `(,(car c*) . ,a))))))) ; want to know whether c is unnecessary given c* ; c contains bindings and freshness constraints that should never be simultaneously all satisfied. ; if there is a c1 in c* such that ; if you assume c's contents are satisfied ; then c1's contents are also satisfied ; then c is unnecessary given c* ; because: ; c1 has some subsets of c's bindings and freshnesses ; so asserting that c1 should not be satisfied implies c should not be satisfied ; (c sat => c1 sat) => (c1 not sat => c not sat) (define subsumed-c*? (lambda (p c*) (and (pair? c*) (or (let ((p^ (unify-c (car c*) p))) (and p^ (eq? (p-s p^) (p-s p)) (null? (h*-extension (p-h* p^) (p-h* p))))) (subsumed-c*? p (cdr c*)))))) (define strip-c* (lambda (c*) (fold-right (lambda (c c*) (let ((s (c-s c)) (h* (c-h* c))) (cond ((and (null? s) (null? h*)) c*) ((null? s) `((hash . ,h*) . ,c*)) ((null? h*) `(,s . ,c*)) (else `((,s (hash . ,h*)) . ,c*))))) '() c*))) (define rwalk (lambda (t s) (let rec ((t t) (pi '())) (cond ((and (sus? t) (assq (sus-v t) s)) => (lambda (p) (rec (cdr p) (compose-pis (sus-pi t) pi)))) ((and (nom? t) (assq t s)) => (lambda (p) (rec (cdr p) pi))) (else (apply-pi pi t)))))) (define walk* (lambda (w s) (let ((t (rwalk w s))) (cond ((tie? t) `(tie ,(rwalk (tie-a t) s) ,(walk* (tie-t t) s))) ((and (sus? t) (not (null? (sus-pi t)))) `(sus ,(walk* (sus-pi t) s) ,(rwalk (sus-v t) s))) ((pair? t) `(,(walk* (car t) s) . ,(walk* (cdr t) s))) (else t))))) (define reify-var (lambda (n) (string->symbol (string-append "_." (number->string n))))) (define reify-nom (lambda (n) (string->symbol (string-append "a." (number->string n))))) (define reifying-s (lambda (t) (define make-counter (lambda () (let ((n 0)) (lambda () (let ((r n)) (set! n (+ n 1)) r))))) (let ((vc (make-counter)) (nc (make-counter))) (let rec ((t t) (s '())) (cond ((and (sus? t) (not (assq (sus-v t) s))) `((,(sus-v t) . ,(reify-var (vc))) . ,s)) ((and (nom? t) (not (assq t s))) `((,t . ,(reify-nom (nc))) . ,s)) ((tie? t) (rec (tie-t t) (rec (tie-a t) s))) ((pair? t) (rec (cdr t) (rec (car t) s))) (else s)))))) (define reify (lambda (v) (lambda (p) (let ((v (walk* v (p-s p)))) (let ((r (reifying-s v))) (let ((v (walk* v r)) (h* (reify-h* (p-h* p) r)) (c* (strip-c* (walk* (remove-subsumed-c* ; INCORRECT TYPES ; walk* takes a term ; but a c* is not a term ; because it contains vars (purify-c* (walk* (p-c* p) (p-s p)) r)) r)))) `(,(if (or (pair? h*) (pair? c*)) `(,v ,@(if (pair? h*) `((hash . ,h*)) '()) ,@(if (pair? c*) `((=/= . ,c*)) '())) v)))))))) (define reify-h* (lambda (h* s) (define ins (lambda (n v r) (let ((rn (rwalk n s)) (rv (rwalk v s))) (if (and (symbol? rn) (symbol? rv)) (let rec ((r r)) (if (null? r) `((,rn . (,rv))) (if (eq? rn (caar r)) `((,rn . (,rv . ,(cdar r))) . ,(cdr r)) `(,(car r) . ,(rec (cdr r)))))) r)))) (let rec ((h* h*) (r '())) (if (null? h*) (map (lambda (h) `(,(car h) . ,(list-sort (lambda (a b) (string<? (symbol->string a) (symbol->string b))) (cdr h)))) r) (rec (cdr h*) (ins (caar h*) (cdar h*) r))))))) (import (minikanren nominal-disequality))

true

fd930fd8cf8a12949aa00b3eb7cc23ade81854aa

4fbab02ed782fce4900fed01bd2f8b3d4c6088fe

/BinarySearch/scheme/main.scm

68126c96d200af901989106910d7c23da50b81b0

[]

no_license

MiyamonY/algorithm

7b3d9b71f291161a44cc77997c78d0677fd6722f

0fb871a0f85858438f7731f3316034151f56b310

refs/heads/master

2022-01-22T18:41:17.915818

2022-01-04T06:15:24

31,007,483

0

null

UTF-8

Scheme

false

1,949

scm

main.scm

;;; File: main.scm ;; Author: ymiyamoto ;; ;; Created on Sun Oct 13 22:14:33 2019 ;; (define-syntax read-number (syntax-rules () ((_ nums) (define-values nums (apply values (map string->number (string-split (read-line) #\space))))))) (define-syntax read-numbers (syntax-rules () ((_ as) (define as (map string->number (string-split (read-line) #\space)))) ((_ as n) (define as (map (lambda (_) (map string->number (string-split (read-line) #\space))) (iota n)))))) (define-syntax prlist (syntax-rules () ((_ lis) (print (string-join (map number->string lis) " "))))) (define-syntax 1+ (syntax-rules () ((_ x) (+ x 1)))) (define-syntax 1- (syntax-rules () ((_ x) (- x 1)))) (define MOD 1000000007) (define (binary-search vec pred) (let loop ((left -1) (right (vector-length vec))) (let1 mid (div (+ left right) 2) (cond ((>= left (1- right)) right) ((pred (vector-ref vec mid)) (loop left mid)) (else (loop mid right)))))) (define (main args) (use gauche.test) (test-start "binary search") (test-section "vector is null") (test "vec is null" 0 (lambda () (binary-search #() (lambda (x) (< 0 x))))) (test-section "vector is single") (test "value is above" 1 (lambda () (binary-search #(2) (lambda (x) (< 3 x))))) (test "value is below" 0 (lambda () (binary-search #(2) (lambda (x) (< 0 x))))) (test "value is equal" 0 (lambda () (binary-search #(2) (lambda (x) (<= 0 2))))) (test-section "vector is multiple") (test "value is below" 0 (lambda () (binary-search #(2 4 6) (lambda (x) (< 0 x))))) (test "value is above" 3 (lambda () (binary-search #(2 4 6) (lambda (x) (< 6 x))))) (test "value is mid1" 0 (lambda () (binary-search #(2 4 6) (lambda (x) (<= 2 x))))) (test "value is mid2" 1 (lambda () (binary-search #(2 4 6) (lambda (x) (<= 3 x))))) (test "value is mid2" 1 (lambda () (binary-search #(2 4 6) (lambda (x) (<= 4 x))))) (test-end))

true

4943ada82aa2049e0b49474002ec972c11f4fc1f

d074b9a2169d667227f0642c76d332c6d517f1ba

/sicp/ch_3/exercise.3.31.scm

56ba8709342ae12a6fa4a360d5a2c3255be9b57c

[]

no_license

zenspider/schemers

4d0390553dda5f46bd486d146ad5eac0ba74cbb4

2939ca553ac79013a4c3aaaec812c1bad3933b16

refs/heads/master

2020-12-02T18:27:37.261206

2019-07-14T15:27:42

26,163,837

7

0

null

UTF-8

Scheme

false

572

scm

exercise.3.31.scm

#lang racket/base ;;; Exercise 3.31 ;; The internal procedure `accept-action-procedure!' ;; defined in `make-wire' specifies that when a new action procedure ;; is added to a wire, the procedure is immediately run. Explain why ;; this initialization is necessary. In particular, trace through the ;; half-adder example in the paragraphs above and say how the ;; system's response would differ if we had defined ;; `accept-action-procedure!' as ;; ;; (define (accept-action-procedure! proc) ;; (set! action-procedures (cons proc action-procedures))) ;; no

false

5447e52d4c2f2061506fb769ca1f9bc68d9b0965

5a68949704e96b638ca3afe335edcfb65790ca20

/derived-syntax/let.scm

644d14db4248d8b796bd5f0699b98577a1a8bc4b

[]

no_license

terryc321/lisp

2194f011f577d6b941a0f59d3c9152d24db167b2

36ca95c957eb598facc5fb4f94a79ff63757c9e5

refs/heads/master

2021-01-19T04:43:29.122838

2017-05-24T11:53:06

84,439,281

2

0

null

UTF-8

Scheme

false

1,352

scm

let.scm

;; klet ;; let in core syntax ;; apply cps conversion to get klet ;; define the macro initially as a function ;; then run the function over the let form we want to convert ;; assume not nested let otherwise we need an expression walker ;; ;;"LOADED let.scm -- nothing defined yet tho. " (let ((a 1) (b 2) (c 3)) (list a b c)) ((lambda (a b c) (list a b c)) 1 2 3) ;; in defining let-rewrite we would want to use let also , interesting. ;; has to have atleast 3 parts ;; LET keyword , ARGs , BODY (define (klet-rewrite exp) (let ((args (cadr exp)) (body (cddr exp))) `((lambda ,(map car args) ,@body) ,@(map (lambda (x) `(begin ,@(cdr x))) args)))) ;; ------ here what it looks like without fancy quasiquote ;; ------ we can simulate let expression by naming another function ;; ----- calling that instead which gives us new bindings (define (klet-rewrite exp) (let ((args (cadr exp)) (body (cddr exp))) (klet-rewrite2 args body))) (define (klet-rewrite2 args body) (append (list (append (list (quote lambda)) (list (map car args)) body)) (map (lambda (x) (cons (quote begin) (cdr x))) args))) ;; ------- (klet-rewrite '(klet ((a 1) (b 2) (c 3)) (list a b c))) (klet-rewrite '(klet ((a 1 2 3) (b 4 5 6) (c 7 8 9)) (list a b c) (list 10 11 12)))

false

5c76538d2c625a35eaaad5a663e0cd5cab4d92bc

d63c4c79d0bf83ae646d0ac023ee0528a0f4a879

/cs133/assn7/a7q2.scm

78cf2e909b672f51facd9582ad4cbecfa5ed17b9

[]

no_license

stratigoster/UW

4dc31f08f7f1c9a958301105dcad481c39c5361f

7a4bff4f1476607c43278c488f70d01077b1566b

refs/heads/master

2021-07-07T04:52:01.543221

2011-08-15T05:08:48

10,858,995

1

null

UTF-8

Scheme

false

2,459

scm

a7q2.scm

;; Contract- ;; combine: (X Y -> Z) (listof X) (listof Y) -> (listof Z) ;; Purpose- ;; to consume a function and 2 lists of equal length, and produces a list of that ;; length. The ith item of the list produced by combine is the result of applying ;; the function to the ith items on each of the lists. ;; Examples- ;; 1. (combine * empty empty) => empty ;; 2. (combine + '(1 2 3) '(1 2 3)) => '(2 4 6) ;; 3. (combine * '(1 2 3) '(2 4 6)) => '(2 8 18) (define (combine myfn list1 list2) (cond [(empty? list1) empty] [else (cons (myfn (first list1) (first list2)) (combine myfn (rest list1) (rest list2)))])) ;; testing combine (equal? (combine * empty empty) empty) (equal? (combine + '(1 2 3) '(4 5 6)) '(5 7 9)) (equal? (combine * '(1 2 3) '(4 5 6)) '(4 10 18)) (equal? (combine (lambda (x y) (* x (+ y 5))) '(1 2 3) '(3 4 5)) '(8 18 30)) ;; -------------------------------------------------------------------------------- ;; Data Definition ;; a phone-record is a structure: (make-phone-record s n) ;; where s is a symbol and n is a number (define-struct phone-record (name number)) ;; Contract- ;; zip: los lon -> list-of-phone-records ;; Purpose- ;; combines a list of names and a list of phone numbers into a list of phone records. ;; A phone-record is constructed with (make-phone-record s n) where s is a symbol ;; and n is a number. Assumption: the lists are of equal length. ;; Examples- ;; 1. (zip empty empty) => empty ;; 2. (zip (list 'Joe) (list 999)) => (list (make-phone-record 'Joe 999)) ;; 3. (zip (list 'Jim 'Jack 'Bill 'Marie 'Kate) (list 999 888 777 666 555)) => ;; (list ;; (make-phone-record 'Jim 999) (make-phone-record 'Jack 888) ;; (make-phone-record 'Bill 777) (make-phone-record 'Marie 666) ;; (make-phone-record 'Kate 555)) (define (zip list1 list2) (combine make-phone-record list1 list2)) ;; testing zip ;; 1. (equal? (zip empty empty) empty) ;; 2. (equal? (zip (list 'Joe) (list 999)) (list (make-phone-record 'Joe 999))) ;; 3. (equal? (zip (list 'Jim 'Jack 'Bill 'Marie 'Kate) (list 999 888 777 666 555)) (list (make-phone-record 'Jim 999) (make-phone-record 'Jack 888) (make-phone-record 'Bill 777) (make-phone-record 'Marie 666) (make-phone-record 'Kate 555)))

false

18c268aced56be4c4f0a1c545680f31be6f3f935

f64f5a8f22d6eae00d4d50d899fdecb65a8539dc

/seth/xml/sxml-serializer.sld

9c8ca5b6724a435201bf14526bd41d0b55e989c5

[ "BSD-3-Clause" ]

permissive

sethalves/snow2-client

79907fe07c218d21c4d60f1787a22e8bfea062f9

b70c3ca5522a666a71a4c8992f771d5faaceccd6

refs/heads/master

2021-05-16T02:08:21.326561

2019-03-18T02:44:11

11,485,062

16

3

BSD-3-Clause

2018-08-14T16:37:09

2013-07-17T19:13:22

Scheme

UTF-8

Scheme

false

31,465

sld

sxml-serializer.sld

;; sxml-serializer -- Serialize SXML to XML and HTML4 ;; Uses public domain code from sxml-tools by Dmitry Lizorkin ;; Chicken port Copyright (C) 2010 Jim Ursetto. All Rights Reserved. ;; License: BSD. ;; Changes over stock: ;; Add allow-prefix-redeclarations? option. Allows user to provide multiple namespace ;; URIs that map to the same prefix in ns-prefixes. Has no effect in attributes. ;; Currently, does not permit redeclarations in *NAMESPACES* except via original-prefix ;; (which is the same as using ns-prefixes). ;; Add fake namespace prefix *default*. Namespace URIs associated with this prefix ;; are assigned the default namespace xmlns="..." and elements with ;; no namespace reset the default to xmlns="". (define-library (seth xml sxml-serializer) (export serialize-sxml conventional-ns-prefixes allow-prefix-redeclarations? ;; These currently offer little benefit over plain serialize-sxml. ;; sxml->xml ;; sxml->xml/noindent ;; sxml->html ;; sxml->html/noindent ) (import (scheme base) (scheme char) (scheme write) (scheme cxr) (scheme file) (only (srfi 1) filter) (only (srfi 13) string-concatenate)) (include "serializer.scm") (begin (define uri-error error) (define sxml->xml srl:sxml->xml) (define sxml->xml/noindent srl:sxml->xml-noindent) (define sxml->html srl:sxml->html) (define sxml->html/noindent srl:sxml->html-noindent) (define display-sxml srl:display-sxml) (define sxml->string srl:sxml->string) ;; (define srl:apply-string-append string-concatenate) ;; override srl:conventional-ns-prefixes so that sxml->xml etc. use the extended list (define srl:conventional-ns-prefixes '((admin . "http://webns.net/mvcb/") (atom . "http://www.w3.org/2005/Atom") (cc . "http://web.resource.org/cc/") (content . "http://purl.org/rss/1.0/modules/content/") (dc . "http://purl.org/dc/elements/1.1/") (feedburner . "http://rssnamespace.org/feedburner/ext/1.0") (fo . "http://www.w3.org/1999/XSL/Format") (geo . "http://www.w3.org/2003/01/geo/wgs84_pos#") (georss . "http://www.georss.org/georss") (itunes . "http://www.itunes.com/dtds/podcast-1.0.dtd") (media . "http://search.yahoo.com/mrss/") (rdf . "http://www.w3.org/1999/02/22-rdf-syntax-ns#") (rng . "http://relaxng.org/ns/structure/1.0") (rss . "http://purl.org/rss/1.0/") (slash . "http://purl.org/rss/1.0/modules/slash/") (sy . "http://purl.org/rss/1.0/modules/syndication/") (taxo . "http://purl.org/rss/1.0/modules/taxonomy/") (thr . "http://purl.org/syndication/thread/1.0") (wiki . "http://purl.org/rss/1.0/modules/wiki/") (wfw . "http://wellformedweb.org/CommentAPI/") (xhtml . "http://www.w3.org/1999/xhtml") (xlink . "http://www.w3.org/1999/xlink") (xqx . "http://www.w3.org/2005/XQueryX") (xsd . "http://www.w3.org/2001/XMLSchema") (xsi . "http://www.w3.org/2001/XMLSchema-instance") (xsl . "http://www.w3.org/1999/XSL/Transform"))) (define conventional-ns-prefixes srl:conventional-ns-prefixes) (define allow-prefix-redeclarations? (make-parameter #t)) ; use #f for stock compatibility ;; serialize-sxml: replacement for srl:parameterizable using keyword args ;; instead of (k . v) pairs. ;; Currently disallows xml-declaration emission because the interface is silly and ;; it doesn't provide an "encoding" option, and because if there is a (*PI* xml ...) ;; in the document it will either emit two, or omit only one. (define (serialize-sxml~ sxml-obj output cdata-section-elements indent method ns-prefixes allow-prefix-redeclarations) (let ((omit-xml-declaration #t) ;; Force omission of xml-declaration (standalone 'omit) (version "1.0") ;; Don't prefix "" URIs. Could go in conventional-ns-prefixes instead, ;; but overriding ns-prefixes would kill that behavior. (ns-prefixes (append ns-prefixes '((*default* . "")))) ) (parameterize ((allow-prefix-redeclarations? allow-prefix-redeclarations)) ; redundant? (if output (srl:display-sxml sxml-obj output cdata-section-elements indent method ns-prefixes omit-xml-declaration standalone version) (srl:sxml->string sxml-obj cdata-section-elements indent method ns-prefixes omit-xml-declaration standalone version) )))) (define (serialize-sxml sxml-obj . args) (let loop ((key/values args) (output #f) (cdata-section-elements '()) (indent " ") (method 'xml) (ns-prefixes conventional-ns-prefixes) (allow-prefix-redeclarations (allow-prefix-redeclarations?))) (cond ((null? key/values) (serialize-sxml~ sxml-obj output cdata-section-elements indent method ns-prefixes allow-prefix-redeclarations)) ((null? (cdr key/values)) (uri-error "malformed arguments to serialize-sxml")) ((not (memq (car key/values) '(output cdata-section-elements indent method ns-prefixes allow-prefix-redeclarations))) (uri-error "unknown argument keyword to serialize-sxml" (car key/values))) (else (let ((key (car key/values)) (value (cadr key/values))) (loop (cddr key/values) (if (eq? key 'output) value output) (if (eq? key 'cdata-section-elements) value cdata-section-elements) (if (eq? key 'indent) value indent) (if (eq? key 'method) value method) (if (eq? key 'ns-prefixes) value ns-prefixes) (if (eq? key 'allow-prefix-redeclarations) value allow-prefix-redeclarations))))))) ;;; changes (define (srl:qname->string prefix-string local-part) (if (and prefix-string (not (string=? prefix-string "*default*"))) (string-append prefix-string ":" local-part) local-part)) (define (srl:namespace-decl->str-lst prefix-string namespace-uri) (if (string=? prefix-string "*default*") (list " xmlns" "=\"" (srl:string->att-value namespace-uri) "\"") (list " xmlns:" prefix-string "=\"" (srl:string->att-value namespace-uri) "\""))) ;; Similar to data-structures#alist-update!, but is non-destructive. ;; Returns a new list with (key . val) consed onto the front; ;; if KEY already exists in the alist, that pair is omitted from the ;; returned list. Currently traverses the entire list and removes all matching keys. (define (alist-update key val alist . maybe-cmp) (let ((cmp (if (pair? maybe-cmp) (car maybe-cmp) eqv?))) (cons (cons key val) (let loop ((alist alist) (res '())) (cond ((null? alist) (reverse res)) ((cmp key (caar alist)) (loop (cdr alist) res)) (else (loop (cdr alist) (cons (car alist) res)))))))) ;; Changes: When declaring a namespace prefix, remove any existing matching prefixes ;; from the declaration list, so new URIs shadow old ones with the same prefix. ;; Changes are marked with [+]. (define (srl:construct-start-end-tags elem method ns-prefix-assig namespace-assoc declared-ns-prefixes) (let ((ns-assoc-here (srl:namespace-assoc-for-elem elem)) (empty? (srl:empty-elem? elem))) (let ((ns-prefix-assig (append (srl:extract-original-prefix-binding ns-assoc-here) ns-prefix-assig)) (namespace-assoc (append ns-assoc-here namespace-assoc))) (call-with-values (lambda () (srl:name->qname-components ; element name (car elem) ns-prefix-assig namespace-assoc declared-ns-prefixes #f)) (lambda (elem-prefix elem-uri elem-local elem-decl-required?) (let loop ((attrs (reverse ((srl:select-kids (lambda (node) ; not SXML 3.0 aux-list (and (pair? node) (not (eq? (car node) at-symbol))))) ((srl:select-kids (lambda (node) (and (pair? node) (eq? (car node) at-symbol)))) elem)))) (start-tag (if (or (not empty?) (and (eq? method 'html) (not elem-prefix) (srl:member-ci elem-local ; ATTENTION: should probably move this list ; to a global const '("area" "base" "basefont" "br" "col" "frame" "hr" "img" "input" "isindex" "link" "meta" "param")))) '(">") '(" />"))) (ns-prefix-assig ns-prefix-assig) (namespace-assoc namespace-assoc) (declared-ns-prefixes ; As if element namespace already declared (if elem-decl-required? (alist-update elem-prefix elem-uri ;; [+] declared-ns-prefixes string=?) declared-ns-prefixes))) (if (null? attrs) ; attributes scanned (let ((elem-name (srl:qname->string elem-prefix elem-local))) (values (cons "<" (cons elem-name (if elem-decl-required? (cons (srl:namespace-decl->str-lst elem-prefix elem-uri) start-tag) start-tag))) (if empty? #f (list "</" elem-name ">")) ns-prefix-assig namespace-assoc declared-ns-prefixes)) (call-with-values (lambda () (srl:name->qname-components (caar attrs) ; attribute name ns-prefix-assig namespace-assoc declared-ns-prefixes #t)) (lambda (attr-prefix attr-uri attr-local attr-decl-required?) (let ((start-tag (cons (srl:attribute->str-lst attr-prefix attr-local ; TODO: optimize for HTML output method (if (null? (cdar attrs)) ; no attribute value attr-local (cadar attrs)) method) start-tag))) (loop (cdr attrs) (if attr-decl-required? (cons (srl:namespace-decl->str-lst attr-prefix attr-uri) start-tag) start-tag) ns-prefix-assig namespace-assoc (if attr-decl-required? ;; alist-update not required if attributes cannot redeclare any prefixes, ;; but to be on the safe side... (alist-update attr-prefix attr-uri declared-ns-prefixes string=?) declared-ns-prefixes)))))))))))) ;; Changes: check (allow-prefix-redeclarations) parameter before denying XML prefix ;; redeclarations. Requires declared-ns-prefixes to contain unique keys (prefixes). ;; - Also have empty namespace signal a declaration of "" is required if a non-empty ;; *default* namespace is defined. Empty namespace declaration is considered ;; to be ("*default*" . "") so it overwrites any previous default declaration. ;; - Also disallow prefix redeclarations in attributes, avoiding multiple declarations ;; of the same namespace prefix in one tag. An unintended consequence is that you ;; can't then redeclare a prefix declared in ANY parent; to fix this we'd have ;; to track namespaces assigned per-attribute. (define (srl:name->qname-components name ns-prefix-assig namespace-assoc declared-ns-prefixes attribute?) (let ((use-ns-id-or-generate-prefix (lambda (ns-id) (if (and ns-id ; try to use namespace-id as a prefix (not (assq (string->symbol ns-id) ns-prefix-assig)) (not (assoc ns-id declared-ns-prefixes)) ;; FIXME: maybe remove ) ns-id ; Otherwise - generate unique prefix ; Returns a prefix-string not presented in ns-prefix-assig and ; declared-ns-prefixes (let loop ((i 1)) (let ((candidate (string-append "prfx" (number->string i)))) (if (or (assoc candidate declared-ns-prefixes) (assq (string->symbol candidate) ns-prefix-assig)) (loop (+ i 1)) candidate)))))) (n-parts (srl:split-name name))) (cond ((and attribute? (not (car n-parts))) ; no namespace-id => no namespace (values #f #f (cdr n-parts) ; name as a string #f)) ((and (car n-parts) (string-ci=? (car n-parts) "xml")) ; reserved XML namespace (values (car n-parts) "http://www.w3.org/XML/1998/namespace" (cdr n-parts) #f)) (else (call-with-values (lambda () (let ((nid (or (car n-parts) "*default*"))) (cond ((assq (string->symbol nid) ; suppose a namespace-id namespace-assoc) => (lambda (lst) (values (cadr lst) nid))) (else ; first part of a name is a namespace URI (values (or (car n-parts) "") #f))))) (lambda (namespace-uri ns-id) (cond ((srl:assoc-cdr-string= namespace-uri declared-ns-prefixes) => (lambda (pair) ; Prefix for that namespace URI already declared (values (car pair) namespace-uri (cdr n-parts) #f))) (else ; namespace undeclared (values (cond ((srl:assoc-cdr-string= namespace-uri ns-prefix-assig) => (lambda (pair) ; A candidate namespace prefix is supplied from the user (let ((candidate (symbol->string (car pair)))) (if (and (or attribute? (not (allow-prefix-redeclarations?))) (assoc candidate declared-ns-prefixes)) ;; The prefix already bound to a different namespace ;; Avoid XML prefix re-declaration (use-ns-id-or-generate-prefix ns-id) candidate)))) (else (if (and ns-id (allow-prefix-redeclarations?)) ns-id (use-ns-id-or-generate-prefix ns-id)))) namespace-uri (cdr n-parts) #t ; in any case, prefix declaration is required ))))))))) ;; Changes: (car node) is only treated as a tag when it is a symbol. ;; For indentation purposes we also treat a list starting with a ;; text node as a text node (to avoid ("foo") having extraneous ;; whitespace added around it). (define (srl:display-node-out-recursive node port method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation space-preserve? cdata-section-elements text-node-handler) (cond ((not (pair? node)) ; text node (display (text-node-handler (srl:atomic->string node)) port)) ((not (symbol? (car node))) ;; ** change (for-each (lambda (kid) (srl:display-node-out-recursive kid port method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation space-preserve? cdata-section-elements text-node-handler)) node)) (else (case (car node) ; node name ((*COMMENT*) (for-each (lambda (x) (display x port)) (srl:comment->str-lst node))) ((*PI*) (for-each (lambda (x) (display x port)) (srl:processing-instruction->str-lst node method))) ((&) (display (srl:shtml-entity->char-data node) port)) ((*DECL*) ; recovering for non-SXML nodes #f) (else ; otherwise - an element node (call-with-values (lambda () (srl:construct-start-end-tags node method ns-prefix-assig namespace-assoc declared-ns-prefixes)) (lambda (start-tag end-tag ns-prefix-assig namespace-assoc declared-ns-prefixes) (begin (srl:display-fragments-2nesting start-tag port) (if end-tag ; there exists content (let ((space-preserve? (srl:update-space-specifier node space-preserve?)) (text-node-handler (cond ((memq (car node) cdata-section-elements) srl:string->cdata-section) ((and (eq? method 'html) (srl:member-ci (symbol->string (car node)) '("script" "style"))) ; No escaping for strings inside these HTML elements (lambda (str) str)) (else srl:string->char-data))) (content ((srl:select-kids (lambda (node) ; TODO: support SXML entities (not (and (pair? node) (memq (car node) '(@ @@ *ENTITY*)))))) node))) (call-with-values (lambda () (cond ((or (not indentation) (and (eq? method 'html) (srl:member-ci (symbol->string (car node)) '("pre" "script" "style" "textarea")))) ; No indent - on this level and subsequent levels (values #f #f)) ((or space-preserve? (srl:mem-pred ; at least a single text node (lambda (node) (or (not (pair? node)) (not (symbol? (car node))))) ;; ** change content)) ; No indent on this level, possible indent on nested levels (values #f indentation)) (else (values (cons srl:newline indentation) (cons (car indentation) indentation))))) (lambda (indent-here indent4recursive) (begin (for-each ; display content (if indent-here (lambda (kid) (begin (for-each (lambda (x) (display x port)) indent-here) (srl:display-node-out-recursive kid port method ns-prefix-assig namespace-assoc declared-ns-prefixes indent4recursive space-preserve? cdata-section-elements text-node-handler))) (lambda (kid) (srl:display-node-out-recursive kid port method ns-prefix-assig namespace-assoc declared-ns-prefixes indent4recursive space-preserve? cdata-section-elements text-node-handler))) content) (if indent-here (begin (display srl:newline port) (for-each (lambda (x) (display x port)) (cdr indentation)))) (for-each (lambda (x) (display x port)) end-tag)))))))))))))) ;; Changes: (car node) is only treated as a tag when it is a symbol. ;; For indentation purposes we also treat a list starting with a ;; text node as a text node (to avoid ("foo") having extraneous ;; whitespace added around it). ;; This is almost a cut and paste of srl:display-node-out-recursive. (define (srl:node->nested-str-lst-recursive node method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation space-preserve? cdata-section-elements text-node-handler) (cond ((not (pair? node)) ; text node (text-node-handler (srl:atomic->string node))) ((not (symbol? (car node))) ;; ** change (map (lambda (kid) (srl:node->nested-str-lst-recursive kid method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation space-preserve? cdata-section-elements text-node-handler)) node)) (else (case (car node) ; node name ((*COMMENT*) (srl:comment->str-lst node)) ((*PI*) (srl:processing-instruction->str-lst node method)) ((&) (srl:shtml-entity->char-data node)) ((*DECL*) ; recovering for non-SXML nodes '()) (else ; otherwise - an element node (call-with-values (lambda () (srl:construct-start-end-tags node method ns-prefix-assig namespace-assoc declared-ns-prefixes)) (lambda (start-tag end-tag ns-prefix-assig namespace-assoc declared-ns-prefixes) (if (not end-tag) ; empty element => recursion stops start-tag (let ((space-preserve? (srl:update-space-specifier node space-preserve?)) (text-node-handler (cond ((memq (car node) cdata-section-elements) srl:string->cdata-section) ((and (eq? method 'html) (srl:member-ci (symbol->string (car node)) '("script" "style"))) ; No escaping for strings inside these HTML elements (lambda (str) str)) (else srl:string->char-data))) (content ((srl:select-kids (lambda (node) ; TODO: support SXML entities (not (and (pair? node) (memq (car node) '(@ @@ *ENTITY*)))))) node))) (call-with-values (lambda () (cond ((or (not indentation) (and (eq? method 'html) (srl:member-ci (symbol->string (car node)) '("pre" "script" "style" "textarea")))) ; No indent - on this level and subsequent levels (values #f #f)) ((or space-preserve? (srl:mem-pred ; at least a single text node (lambda (node) (or (not (pair? node)) (not (symbol? (car node))))) ;; ** change content)) ; No indent on this level, possible indent on nested levels (values #f indentation)) (else (values (cons srl:newline indentation) (cons (car indentation) indentation))))) (lambda (indent-here indent4recursive) (if indent-here (append start-tag (map (lambda (kid) (list indent-here (srl:node->nested-str-lst-recursive kid method ns-prefix-assig namespace-assoc declared-ns-prefixes indent4recursive space-preserve? cdata-section-elements text-node-handler))) content) (cons srl:newline (cons (cdr indentation) end-tag))) (append start-tag (map (lambda (kid) (srl:node->nested-str-lst-recursive kid method ns-prefix-assig namespace-assoc declared-ns-prefixes indent4recursive space-preserve? cdata-section-elements text-node-handler)) content) end-tag))))))))))))) ;; Changes: Declare the empty ("") namespace URI upfront so we do ;; not get a spurious xmlns="" on the first unprefixed elt. ;; WARNING: *default* must be added to ns-prefixes, but this is done ;; only in serialize-sxml and theoretically there are other ;; entry points to this procedure (though not in practice, ;; as the module hides them). ;; Therefore, srl:top->nested-str-lst and srl:display-top-out ;; should probably take a declared-ns-prefixes argument so that ;; *default* is only automatically declared when it's ;; already in ns-prefixes. (define (srl:top->nested-str-lst doc cdata-section-elements indent method ns-prefix-assig omit-xml-declaration? standalone version) (let* ((namespace-assoc (srl:ns-assoc-for-top doc)) (declared-ns-prefixes '(("*default*" . ""))) ;; [+] (ns-prefix-assig (append (srl:extract-original-prefix-binding namespace-assoc) ns-prefix-assig)) (serialized-content (map (if indent ; => output each member from the newline (let ((indentation (list indent))) ; for nested elements (lambda (kid) (list srl:newline (srl:node->nested-str-lst-recursive kid method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation #f cdata-section-elements srl:string->char-data)))) (lambda (kid) (srl:node->nested-str-lst-recursive kid method ns-prefix-assig namespace-assoc declared-ns-prefixes indent #f cdata-section-elements srl:string->char-data))) ((srl:select-kids ; document node content (lambda (node) ; TODO: support SXML entities (not (and (pair? node) (memq (car node) '(@ @@ *ENTITY*)))))) doc)))) (if (or (eq? method 'html) omit-xml-declaration?) (if (and indent (not (null? serialized-content))) ; Remove the starting newline ; ATTENTION: beware of `Gambit cadar bug': ; http://mailman.iro.umontreal.ca/pipermail/gambit-list/ ; 2005-July/000315.html (cons (cadar serialized-content) (cdr serialized-content)) serialized-content) (list (srl:make-xml-decl version standalone) serialized-content)))) (define (srl:display-top-out doc port cdata-section-elements indent method ns-prefix-assig omit-xml-declaration? standalone version) (let ((no-xml-decl? ; no XML declaration was displayed? (if (not (or (eq? method 'html) omit-xml-declaration?)) (begin (for-each ; display xml declaration (lambda (x) (display x port)) (srl:make-xml-decl version standalone)) #f) #t)) (content ; document node content ((srl:select-kids (lambda (node) ; TODO: support SXML entities (not (and (pair? node) (memq (car node) '(@ @@ *ENTITY*)))))) doc)) (namespace-assoc (srl:ns-assoc-for-top doc)) (declared-ns-prefixes '(("*default*" . "")))) ; [+] (let ((ns-prefix-assig (append (srl:extract-original-prefix-binding namespace-assoc) ns-prefix-assig))) (cond ((null? content) ; generally a rare practical situation #t) ; nothing more to do ((and indent no-xml-decl?) ; We'll not display newline before (car content) (let ((indentation (list indent))) ; for nested elements (for-each (lambda (kid put-newline?) (begin (if put-newline? (display srl:newline port)) (srl:display-node-out-recursive kid port method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation #f cdata-section-elements srl:string->char-data))) content ; After sequence normalization, content does not contain #f (cons #f (cdr content))))) (else (for-each (if indent ; => output each member from the newline (let ((indentation (list indent))) ; for nested elements (lambda (kid) (begin (display srl:newline port) (srl:display-node-out-recursive kid port method ns-prefix-assig namespace-assoc declared-ns-prefixes indentation #f cdata-section-elements srl:string->char-data)))) (lambda (kid) (srl:display-node-out-recursive kid port method ns-prefix-assig namespace-assoc declared-ns-prefixes indent #f cdata-section-elements srl:string->char-data))) content)))))) ;; Changes: accept nulls, chars, and symbols as SXML nodes. For some ;; reason numbers and bools were already accepted, which makes me think ;; this was an oversight. (define (srl:atomic->string obj) (cond ((or (pair? obj) ; non-atomic type (string? obj)) obj) ((null? obj) "") ((char? obj) (string obj)) ((symbol? obj) (symbol->string obj)) ((number? obj) (number->string obj)) ((boolean? obj) (if obj "true" "false")) (else ; unexpected type ; ATTENTION: should probably raise an error here obj))) ))

false

71de64d0e4265f5441c9d768efad5fe0cad2d42b

000dbfe5d1df2f18e29a76ea7e2a9556cff5e866

/sitelib/rfc/http2/hpack-code-table.scm

dead4347ca9657cd3b7ebb37847e770fe62d9447

[ "BSD-3-Clause", "LicenseRef-scancode-other-permissive", "MIT", "BSD-2-Clause" ]

permissive

ktakashi/sagittarius-scheme

0a6d23a9004e8775792ebe27a395366457daba81

285e84f7c48b65d6594ff4fbbe47a1b499c9fec0

refs/heads/master

2023-09-01T23:45:52.702741

2023-08-31T10:36:08

41,153,733

48

7

NOASSERTION

2022-07-13T18:04:42

2015-08-21T12:07:54

Scheme

UTF-8

Scheme

false

12,099

scm

hpack-code-table.scm

#( #(0 (1 1 1 1 1 1 1 1 1 1 0 0 0)) #(1 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0)) #(2 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0)) #(3 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1)) #(4 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0)) #(5 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1)) #(6 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(7 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(8 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(9 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(10 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0)) #(11 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1)) #(12 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(13 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) #(14 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(15 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(16 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(17 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0)) #(18 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1)) #(19 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0)) #(20 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1)) #(21 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0)) #(22 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0)) #(23 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1)) #(24 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0)) #(25 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1)) #(26 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0)) #(27 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1)) #(28 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0)) #(29 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1)) #(30 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0)) #(31 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1)) #(32 (0 1 0 1 0 0)) #(33 (1 1 1 1 1 1 1 0 0 0)) #(34 (1 1 1 1 1 1 1 0 0 1)) #(35 (1 1 1 1 1 1 1 1 1 0 1 0)) #(36 (1 1 1 1 1 1 1 1 1 1 0 0 1)) #(37 (0 1 0 1 0 1)) #(38 (1 1 1 1 1 0 0 0)) #(39 (1 1 1 1 1 1 1 1 0 1 0)) #(40 (1 1 1 1 1 1 1 0 1 0)) #(41 (1 1 1 1 1 1 1 0 1 1)) #(42 (1 1 1 1 1 0 0 1)) #(43 (1 1 1 1 1 1 1 1 0 1 1)) #(44 (1 1 1 1 1 0 1 0)) #(45 (0 1 0 1 1 0)) #(46 (0 1 0 1 1 1)) #(47 (0 1 1 0 0 0)) #(48 (0 0 0 0 0)) #(49 (0 0 0 0 1)) #(50 (0 0 0 1 0)) #(51 (0 1 1 0 0 1)) #(52 (0 1 1 0 1 0)) #(53 (0 1 1 0 1 1)) #(54 (0 1 1 1 0 0)) #(55 (0 1 1 1 0 1)) #(56 (0 1 1 1 1 0)) #(57 (0 1 1 1 1 1)) #(58 (1 0 1 1 1 0 0)) #(59 (1 1 1 1 1 0 1 1)) #(60 (1 1 1 1 1 1 1 1 1 1 1 1 1 0 0)) #(61 (1 0 0 0 0 0)) #(62 (1 1 1 1 1 1 1 1 1 0 1 1)) #(63 (1 1 1 1 1 1 1 1 0 0)) #(64 (1 1 1 1 1 1 1 1 1 1 0 1 0)) #(65 (1 0 0 0 0 1)) #(66 (1 0 1 1 1 0 1)) #(67 (1 0 1 1 1 1 0)) #(68 (1 0 1 1 1 1 1)) #(69 (1 1 0 0 0 0 0)) #(70 (1 1 0 0 0 0 1)) #(71 (1 1 0 0 0 1 0)) #(72 (1 1 0 0 0 1 1)) #(73 (1 1 0 0 1 0 0)) #(74 (1 1 0 0 1 0 1)) #(75 (1 1 0 0 1 1 0)) #(76 (1 1 0 0 1 1 1)) #(77 (1 1 0 1 0 0 0)) #(78 (1 1 0 1 0 0 1)) #(79 (1 1 0 1 0 1 0)) #(80 (1 1 0 1 0 1 1)) #(81 (1 1 0 1 1 0 0)) #(82 (1 1 0 1 1 0 1)) #(83 (1 1 0 1 1 1 0)) #(84 (1 1 0 1 1 1 1)) #(85 (1 1 1 0 0 0 0)) #(86 (1 1 1 0 0 0 1)) #(87 (1 1 1 0 0 1 0)) #(88 (1 1 1 1 1 1 0 0)) #(89 (1 1 1 0 0 1 1)) #(90 (1 1 1 1 1 1 0 1)) #(91 (1 1 1 1 1 1 1 1 1 1 0 1 1)) #(92 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0)) #(93 (1 1 1 1 1 1 1 1 1 1 1 0 0)) #(94 (1 1 1 1 1 1 1 1 1 1 1 1 0 0)) #(95 (1 0 0 0 1 0)) #(96 (1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) #(97 (0 0 0 1 1)) #(98 (1 0 0 0 1 1)) #(99 (0 0 1 0 0)) #(100 (1 0 0 1 0 0)) #(101 (0 0 1 0 1)) #(102 (1 0 0 1 0 1)) #(103 (1 0 0 1 1 0)) #(104 (1 0 0 1 1 1)) #(105 (0 0 1 1 0)) #(106 (1 1 1 0 1 0 0)) #(107 (1 1 1 0 1 0 1)) #(108 (1 0 1 0 0 0)) #(109 (1 0 1 0 0 1)) #(110 (1 0 1 0 1 0)) #(111 (0 0 1 1 1)) #(112 (1 0 1 0 1 1)) #(113 (1 1 1 0 1 1 0)) #(114 (1 0 1 1 0 0)) #(115 (0 1 0 0 0)) #(116 (0 1 0 0 1)) #(117 (1 0 1 1 0 1)) #(118 (1 1 1 0 1 1 1)) #(119 (1 1 1 1 0 0 0)) #(120 (1 1 1 1 0 0 1)) #(121 (1 1 1 1 0 1 0)) #(122 (1 1 1 1 0 1 1)) #(123 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 0)) #(124 (1 1 1 1 1 1 1 1 1 0 0)) #(125 (1 1 1 1 1 1 1 1 1 1 1 1 0 1)) #(126 (1 1 1 1 1 1 1 1 1 1 1 0 1)) #(127 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0)) #(128 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(129 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 0)) #(130 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(131 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(132 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1 1)) #(133 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 0)) #(134 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1)) #(135 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0 1)) #(136 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1 0)) #(137 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 0)) #(138 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 1)) #(139 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 0)) #(140 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1)) #(141 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0)) #(142 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(143 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1)) #(144 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(145 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(146 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1 1)) #(147 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0)) #(148 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0)) #(149 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1)) #(150 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0)) #(151 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1)) #(152 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0)) #(153 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 0)) #(154 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0 0)) #(155 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1)) #(156 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0 1)) #(157 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(158 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(159 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1)) #(160 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 0)) #(161 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1)) #(162 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1)) #(163 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1 1)) #(164 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 0)) #(165 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(166 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1)) #(167 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0)) #(168 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(169 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1)) #(170 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0)) #(171 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0)) #(172 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1)) #(173 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1)) #(174 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(175 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(176 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0)) #(177 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1)) #(178 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0)) #(179 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0)) #(180 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(181 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1)) #(182 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0)) #(183 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1)) #(184 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(185 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0)) #(186 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1)) #(187 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0)) #(188 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0)) #(189 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1)) #(190 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(191 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1)) #(192 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0)) #(193 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1)) #(194 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(195 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1)) #(196 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(197 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0)) #(198 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(199 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(200 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0)) #(201 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1)) #(202 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0)) #(203 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0)) #(204 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1)) #(205 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1)) #(206 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1)) #(207 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(208 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0)) #(209 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1)) #(210 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(211 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0)) #(212 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1)) #(213 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(214 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0)) #(215 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0)) #(216 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0)) #(217 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1)) #(218 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(219 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1)) #(220 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1)) #(221 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1)) #(222 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 0)) #(223 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 1)) #(224 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(225 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1)) #(226 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(227 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(228 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1)) #(229 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(230 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(231 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1)) #(232 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(233 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(234 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0)) #(235 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1)) #(236 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0)) #(237 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1)) #(238 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(239 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0)) #(240 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(241 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0)) #(242 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(243 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(244 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1)) #(245 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 0)) #(246 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 0 1)) #(247 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0)) #(248 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 1)) #(249 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0)) #(250 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 0)) #(251 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 0 1)) #(252 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0)) #(253 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1)) #(254 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0)) #(255 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0)) #(256 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)) )

false

f5a94768ad7f9e240ff565a2b611207796cb8a44

defeada37d39bca09ef76f66f38683754c0a6aa0

/System/system/diagnostics/trace-switch.sls

809c0ed60e53596fc5d8c221b14e5851899eca34

[]

no_license

futsuki/ironscheme-port

2dbac82c0bda4f4ff509208f7f00a5211d1f7cd5

4e7a81b0fbeac9a47440464988e53fb118286c54

refs/heads/master

2016-09-06T17:13:11.462593

2015-09-26T18:20:40

42,757,369

0

null

UTF-8

Scheme

false

1,277

sls

trace-switch.sls

(library (system diagnostics trace-switch) (export new is? trace-switch? level-get level-set! level-update! trace-error? trace-warning? trace-info? trace-verbose?) (import (ironscheme-clr-port)) (define-syntax new (lambda (e) (syntax-case e () ((_ a ...) #'(clr-new System.Diagnostics.TraceSwitch a ...))))) (define (is? a) (clr-is System.Diagnostics.TraceSwitch a)) (define (trace-switch? a) (clr-is System.Diagnostics.TraceSwitch a)) (define-field-port level-get level-set! level-update! (property:) System.Diagnostics.TraceSwitch Level System.Diagnostics.TraceLevel) (define-field-port trace-error? #f #f (property:) System.Diagnostics.TraceSwitch TraceError System.Boolean) (define-field-port trace-warning? #f #f (property:) System.Diagnostics.TraceSwitch TraceWarning System.Boolean) (define-field-port trace-info? #f #f (property:) System.Diagnostics.TraceSwitch TraceInfo System.Boolean) (define-field-port trace-verbose? #f #f (property:) System.Diagnostics.TraceSwitch TraceVerbose System.Boolean))

true

b35cade84cd17b7aa371dccdcece318d4f75ff5a

e1fc47ba76cfc1881a5d096dc3d59ffe10d07be6

/ch3/3.76.scm

af3ca893378070692cf3754a4ba7d6f2cbb81fe8

[]

no_license

lythesia/sicp-sol

e30918e1ebd799e479bae7e2a9bd4b4ed32ac075

169394cf3c3996d1865242a2a2773682f6f00a14

refs/heads/master

2021-01-18T14:31:34.469130

2019-10-08T03:34:36

27,224,763

2

0

null

UTF-8

Scheme

false

429

scm

3.76.scm

(load "3.75.scm") (define (smooth s) (let* ((fst (stream-car s)) (snd (stream-car (stream-cdr s))) (avg (/ (+ fst snd) 2))) (cons-stream avg (smooth (stream-cdr s))) ) ) ; another ; (define (smooth s) ; (stream-map (lambda (a b) (/ (+ a b) 2)) s (stream-cdr s)) ; ) (define smoothed-input (smooth sense-data)) (define zero-crossings (stream-map sign-change-detector (smoothed-input) (cons-stream 0 smoothed-input)))

false

8d2b4f71d9d10d1629550046f21acc25c141b533

4f30ba37cfe5ec9f5defe52a29e879cf92f183ee

/src/sasm/sasm-insel.scm

41deb64abc0f097591b431958a88f37790589480

[ "MIT" ]

permissive

rtrusso/scp

e31ecae62adb372b0886909c8108d109407bcd62

d647639ecb8e5a87c0a31a7c9d4b6a26208fbc53

refs/heads/master

2021-07-20T00:46:52.889648

2021-06-14T00:31:07

167,993,024

8

1

MIT

2021-06-14T00:31:07

2019-01-28T16:17:18

Scheme

UTF-8

Scheme

false

9,258

scm

sasm-insel.scm

;; sasm-insel.scm ;; Instruction selection module (need sasm/sasm-dataflow) (need sasm/sasm-tx) (define (sasm-temp-generator sasm-code) (let ((temp-max (sasm-temp-max sasm-code))) (lambda () (set! temp-max (+ temp-max 1)) temp-max))) ;; TODO OPTIMIZE (define (sasm-insel sasm-code) (let ((liveness (sasm-liveness-compute sasm-code)) (tempgen (sasm-temp-generator sasm-code))) (accum append '() (map (lambda (x y z) (sasm-insel-single x y z tempgen)) sasm-code (list-ref liveness 0) (list-ref liveness 1))))) (define *last-insn* '()) (define (sasm-attempt-match-insn insn) (let loop ((machine-spec *machine-instructions*)) (if (null? machine-spec) #f (let ((pattern (car machine-spec))) (set! *last-insn* insn) (let ((match (pattern-match (car pattern) insn))) (or (and match (cons match pattern)) (loop (cdr machine-spec)))))))) (define (sasm-match-insn insn) (if (sasm-directive? insn) (error "sasm-match-insn called with directive")) (or (sasm-attempt-match-insn insn) (error "Unable to match instruction -- sasm-match-insn" insn))) (define (sasm-directive? insn) (or (and (list? insn) (equal? 'info (car insn))) (pattern-match '(assign (? reg) (op side-effect)) insn) (pattern-match '(perform (op use-garbage) (? reg)) insn))) ; (and (equal? 'perform (car insn)) ; (equal? '(op use-garbage) (list-ref insn 1))))) ; Some notes on instruction-selection rewrite-rules: ; ; Normal instruction, no side effects or rewrite rule ; ; - No automatic save/restore functionality is needed ; ; If the instruction has side effects but no rewrite-rule: ; ; - if the SE register is live-out and not modified by the current ; instruction, save the register before and modify it after ; ; - what about live-in? The rewrite rule must be written carefully ; to introduce temporaries properly ; ; If the instruction has side effects and rewrite-rule: ; ; - if the SE register is live-in to the original instruction, save ; it before the rewrite-rule result and restore it after the ; rewrite-rule result (define (sasm-insel-single insn live-in live-out tempgen) (define (map-side-effects side-effects) (if (null? side-effects) '() (append (list `(assign ,(car side-effects) (op side-effect)) `(perform (op use-garbage) ,(car side-effects))) (map-side-effects (cdr side-effects))))) (define (save-live-side-effect-regs insns side-effects live-in live-out) ; (println "saving live side-effect-registers: \t\n [" insns "] \t\n[" live-in "] [" live-out "] \t\n[" side-effects "]\n\n") (cond ((null? side-effects) insns) ((and (member (car side-effects) live-in) (member (car side-effects) live-out)) (let ((temp `(temp ,(tempgen)))) (save-live-side-effect-regs (append (list `(assign ,temp ,(car side-effects))) insns (list `(assign ,(car side-effects) ,temp))) (cdr side-effects) live-in live-out))) (else (save-live-side-effect-regs insns (cdr side-effects) live-in live-out)))) (define (rewrite-insn insn-pat match rewrite-spec) (if (not rewrite-spec) (list (pattern-match-replace insn-pat match)) (let ((temps '())) (define (get-temp name) (let ((entry (assoc name temps))) (if entry `(temp ,(cdr entry)) (begin (set! temps (cons (cons name (tempgen)) temps)) `(temp ,(cdar temps)))))) (define (fix-statement stmt) (define (fix-element exp) (if (not (pair? exp)) exp (case (car exp) ((replace) (cdr (assoc (cadr exp) match))) ((replace-temp) (get-temp (cadr exp))) ((result) (fix-statement exp)) (else (if (pair? exp) (cons (fix-element (car exp)) (fix-element (cdr exp)))))))) (map fix-element stmt)) (filter (lambda (x) (not (pattern-match '(assign (? reg) (? reg)) x))) (map fix-statement rewrite-spec))))) (define (write-insns insn-pat match side-effects rewrite-spec live-in live-out) (let* ((insns (rewrite-insn insn-pat match rewrite-spec)) (filtered-se (filter-side-effects (list (pattern-match-replace insn-pat match)) (reverse-map-side-effects side-effects) live-in live-out))) (let ((se-insns (append insns (map-side-effects filtered-se)))) (save-live-side-effect-regs se-insns filtered-se live-in live-out)))) (define (filter-side-effects stmts side-effects live-in live-out) (let ((result (subtract-lists equal? side-effects (accum append '() (map sasm-liveness-statement-kills stmts))))) ; (println "filter-side-effects [" stmts "]\n\t[" result "]") result)) (define (matchrec match insn-pat side-effects rewrite-spec result live-in live-out) (cond ((null? match) (write-insns insn-pat result side-effects rewrite-spec live-in live-out)) ((and (list? (cdr (car match))) (or (equal? 'result (car (cdr (car match)))) (equal? 'label (car (cdr (car match)))) (equal? 'const (car (cdr (car match)))))) (let* ((entry (car match)) (result-exp (if (equal? 'result (car (cdr entry))) (cdr entry) (list 'foobar (cdr entry)))) (temp (tempgen)) (new-sub-insn `(assign (temp ,temp) ,@(cdr result-exp))) (new-temp `(temp ,temp)) (new-match (cons (car entry) new-temp))) ;; (println "Matching subins " new-sub-insn "; ") ;; (begin (display "matchrec-foo") ;; (newline) ;; (display "insn: ") (write insn) ;; (newline) ;; (display "match: ") (write match) ;; (newline) ;; (display "new-sub-insn: ") (write new-sub-insn) ;; (newline) ;; (display "entry: ") (write entry) ;; (newline) ;; (display "insns-pat: ") (write insn-pat) ;; (newline) ;; (display "result: ") (write result) ;; (newline) ;; (display "side-effects: ") (write side-effects) ;; (newline) ;; (display "rewrite-spec: ") (write rewrite-spec) ;; (newline) ;; (display "live-in: ") (write live-in) ;; (newline) ;; (display "live-out: ") (write live-out) ;; (newline) ;; (newline)) (append (sasm-insel-single new-sub-insn live-in (remove-duplicates equal? (cons new-temp (append live-in live-out))) tempgen) (matchrec (cdr match) insn-pat side-effects rewrite-spec (cons new-match result) (cons new-temp live-in) live-out)))) (else (matchrec (cdr match) insn-pat side-effects rewrite-spec (cons (car match) result) live-in live-out)))) (define (rewrite-simple-result-assignment insn) (if (and (equal? 'assign (car insn)) (= 3 (length insn)) (equal? 'result (car (list-ref insn 2)))) `(assign ,(list-ref insn 1) ,@(cdr (list-ref insn 2))) insn)) ; (println "Insel-Single: " insn) (cond ((sasm-directive? insn) (list insn)) ((sasm-directive? (rewrite-simple-result-assignment insn)) (list (rewrite-simple-result-assignment insn))) (else (let ((match-spec (sasm-match-insn (rewrite-simple-result-assignment insn)))) (and match-spec (matchrec (car match-spec) (list-ref match-spec 1) (list-ref match-spec 3) (list-ref match-spec 4) '() live-in live-out))))))

false

134629f18f90660c7ea4d5d56d4b61b968f5ad70

ece1c4300b543df96cd22f63f55c09143989549c

/Chapter3/Exercise3.68.scm

338f41bb7a25cf40572bbcce24e07b228dfb317c

[]

no_license

candlc/SICP

e23a38359bdb9f43d30715345fca4cb83a545267

1c6cbf5ecf6397eaeb990738a938d48c193af1bb

refs/heads/master

2022-03-04T02:55:33.594888

2019-11-04T09:11:34

null

0

null

UTF-8

Scheme

false

604

scm

Exercise3.68.scm

; Exercise 3.68: Louis Reasoner thinks that building a stream of pairs from three parts is unnecessarily complicated. Instead of separating the pair (S0,T0)(S0,T0) from the rest of the pairs in the first row, he proposes to work with the whole first row, as follows: ; (define (pairs s t) ; (interleave ; (stream-map ; (lambda (x) ; (list (stream-car s) x)) ; t) ; (pairs (stream-cdr s) ; (stream-cdr t)))) ; Does this work? Consider what happens if we evaluate (pairs integers integers) using Louis’s definition of pairs. ; infinite evaluate the interleave and pairs

false

330da303580d20ddb0f6fe9fd876efdc2fc473de

abc7bd420c9cc4dba4512b382baad54ba4d07aa8

/src/parser/cheztrace.ss

b11b7b4cf9c9c6eb5d65f883b5b18c937feb8c2c

[ "BSD-3-Clause" ]

permissive

rrnewton/WaveScript

2f008f76bf63707761b9f7c95a68bd3e6b9c32ca

1c9eff60970aefd2177d53723383b533ce370a6e

refs/heads/master

2021-01-19T05:53:23.252626

2014-10-08T15:00:41

1,297,872

10

2

null

UTF-8

Scheme

false

1,671

ss

cheztrace.ss

;; [2005.11.13 ] Having a go at implementing these in PLT: ;; DOESNT WORK YET. (module cheztrace mzscheme ; (require (lib "errortrace.ss" "errortrace") ; (lib "stacktrace.ss" "errortrace")) (require (lib "trace.ss")) (provide trace-lambda trace-define trace-let inspect break) ;; Just stubs. (define (inspect x) (void)) (define (break x) x) #; (define-syntax trace-lambda (lambda (x) (syntax-case x () [(_ params bods ...) #`(lambda params #,(annotate #'(begin bods ...) #f))]))) (define-syntax trace-lambda (lambda (x) (syntax-case x () [(_ name (params ...) bods ...) (identifier? #'name) #'(let ((name (lambda (params ...) bods ...))) (trace name) name)]))) #| (define-syntax trace-define (lambda (x) (syntax-case x () [(_ (id v ...) e) #'(begin (define (id v ...) e) (trace id))] [(_ x e) (identifier? #'x) #'(begin (define x e) (trace x))]))) (define-syntax trace-let (syntax-rules () [(_ n ([l* r*] ...) bods ...) (letrec ((n (lambda (l* ...) bods ...))) (trace n) (n r* ...))])) |# ;; [2006.03.23] For now killing these ^^^, not sure how much they worked. ;; These simply don't do anything under PLT for the moment. (define-syntax trace-define (syntax-rules () [(_ e ...) (define e ...)])) (define-syntax trace-let (syntax-rules () [(_ e ...) (let e ...)])) ) ;(require cheztrace) ;(define f (trace-lambda (x) x (if (odd? x) (error 'foo "") (add1 x)))) ;(f 40) ;(f 39) ;(trace-let loop ((n 10)) ; (if (> n 0) (loop (sub1 n))))

true

04799a2129bac8e1cb956dfdf0963d1e0f65df15

c2603f0d6c6e523342deaa1e284b7855a450a6f7

/autoload/genvise.scm

833e6384da25ea0ad71356df9a566e589a8a7fa3

[]

no_license

aharisu/vise

5d35a085e6b1070920e9a4e035339050091b2be0

6d0f54b0fe28e7d2c3b2b91cb3ef5ff847a11484

refs/heads/master

2020-06-02T10:48:42.822204

2013-02-21T09:42:59

7,975,231

1

null

2013-02-20T12:26:45

2013-02-02T11:53:18

null

UTF-8

Scheme

false

1,211

scm

genvise.scm

(add-load-path "." :relative) (use vgen.compiler) (use vgen.common) (use gauche.parseopt) (define (main args) (let1 loadpath '() (let-args (cdr args) ((out "o|output=s") (#f "s|loadpath=s" => (lambda (opt) (set! loadpath (cons opt loadpath)))) (else (opt . _) (error "Unkown option : " opt)) . args) (when (zero? (length args)) (error "no source file.")) (let ([in-port (open-input-file (x->string (car args)))] [out-port (if out (open-output-file out) (standard-output-port))]) (guard (e [(<vise-error> e) (display "*** vise ERROR: " (standard-error-port)) (display (slot-ref e 'message) (standard-error-port)) (newline (standard-error-port)) 1]) (unwind-protect (vise-compile in-port :out-port out-port :load-path (reverse! loadpath) :prologue "\" Generated automatically DO NOT EDIT\n\n") (begin (close-input-port in-port) (unless (eq? out-port (standard-output-port)) (close-output-port out-port)))) 0)))))

false

0849855b0fdfbd5b5008da4368db1ac7d063b2cf

e28e5bd06f08ba86edcdfcf5d50de37a90e1cd19

/scheme/Exceptions/eccezioni trycatch tomma.scm

c2389a1c096d2f542b69a19511f252934cb2d66e

[]

no_license

edoardo90/swKnights-plp

4384a9dedc6c3ec15181b5e201d66207b331579a

870b3f4f37c73bfe4a913b8da079a778314117c9

refs/heads/master

2021-01-18T01:43:48.024605

2016-03-19T20:37:51

null

0

null

UTF-8

Scheme

false

3,579

scm

eccezioni trycatch tomma.scm

#lang racket ;RICCARDO TOMMASINI 799120 (struct handler ( exc proc)) ; lista di liste di handler ;ogni lista rappresenta il contesto di attivazione di una eccezione (define handlers (list)) ;riceve una lista l di handler che viene aggiunta al record di tutte le eccezioni (define (h-push l) (set! handlers (append (list l) handlers))) ; pop di alto livello per la lista, restitisce un elemendo l che contiene una lista di handler (define (high-pop) (if (pair? handlers) (let ((l (car handlers))) (set! handlers (cdr handlers)) l) (error "no handlers"))) ;zucchero sintattico per definire l'uguaglianza tra una eccezione lanciata ed una eventualemnte gestita (define (handled? e h) (eq? e (handler-exc h))) ;componente inferiore del throw, permette la gestione della lista interna di handler, ed eventualmente innesca una catena ricorsiva (define (sub_throw e l) (if (pair? l) (let ((h (car l))) (set! l (cdr l)) (if (handled? e h) ((handler-proc h)) (sub_throw e l))) (throw e))) ;metodo per il lancio dell'eccezione (define (throw e) (if (pair? handlers) (let (( *handlers* (high-pop))) (sub_throw e *handlers*)) (error (string-append "uncaught exception: " e)))) ; macro che definisce il costrutto (define-syntax try (syntax-rules () ((_ body ... ((_ exc proc) ... )) (call/cc (λ(exit) (h-push (list (handler exc (λ() exit proc)) ...)) (let ((res (begin body ...))) (unless (null? handlers) (high-pop)) res)))))) ; esempio base (try (throw "e1") ((catch "e1" (display "caught e1 esempio 1\n")))) ;esempio annidato a due livelli (try (try (throw "e2") ((catch "e1" (display "caught e1\n")))) ((catch "e2" (display "caught e2 esempio 2\n")))) ; annidato a 3 livelli (try (try (try (throw "e2") ((catch "e1" (display "caught e1\n")))) ((catch "e3" (display "caught e3\n")))) ((catch "e2" (display "caught e2 esempio 3\n")))) ;esempio con più costrutti di catch (try (throw "e2") ((catch "e1" (display "presa e1 esempio 4\n")) (catch "e2" (display "presa e2 esempio 4\n")) (catch "e3" (display "presa e3 esempio 4\n")))) ;annidato con più costrutti di catch (try (try (throw "e1") ((catch "e1" (display "presa e1 interna esempio 5\n")) (catch "e2" (display "presa e2 interna esempio 5\n")) (catch "e3" (display "presa e3 interna esempio 5\n")))) ((catch "e1" (display "presa e1 esterna esempio 5\n")))) ;annidato 2 livelli con più costrutti (try (try (try (throw "e1") ((catch "e5" (display "presa e5 interna esempio 6\n")) (catch "e2" (display "presa e2 interna esempio 6\n")) (catch "e3" (display "presa e3 interna esempio 6\n")))) ((catch "e6" (display "presa e6 esterna livello 1 esempio 6\n")))) ((catch "e1" (display "presa e1 esterna livello 2 esempio 6\n")) (catch "e4" (display "presa e4 esterna livello 2 esempio 6\n")))) ;esempio eccezione non catchata ;(throw "e1") (try (throw "e") ((catch "e1" (display "presa e1 esempio 4\n")) (catch "e2" (display "presa e2 esempio 4\n")) (catch "e3" (display "presa e3 esempio 4\n"))))

true

284a210fc2da4b15101d78807d0876ac1f1f093c

7aeb920de21547a1d9c714b029bbf3a9e7df449e

/tests/unit/type-register-map-scm.t

fd3a8e0d68f0ac2cad342a585491cd8dc0f630ac

[ "BSD-2-Clause" ]

permissive

ft/chip-remote

f8ac5a2d7597d24f44ac287836be3422a32283d4

2a64df611214f7e3eb55d4ead76e270351158cdb

refs/heads/master

2023-04-30T08:38:16.483240

2023-01-05T04:01:44

117,028,633

2

1

null

UTF-8

Scheme

false

2,248

t

type-register-map-scm.t

;; -*- scheme -*- ;; Copyright (c) 2017-2018 chip-remote workers, All rights reserved. ;; ;; Terms for redistribution and use can be found in LICENCE. (use-modules (test tap) (test setup) (chip-remote item) (chip-remote register) (chip-remote register-map)) (init-test-tap!) (define *register-one* (generate-register #:contents (foo 0 4) (bar 4 4))) (define *register-two* (generate-register #:contents (baz 0 4 #:default #b0110) (boz 4 4))) (define pp (@@ (ice-9 pretty-print) pretty-print)) (with-fs-test-bundle (plan 7) (define-test "generate-register, call structure works" (pass-if-true (register-map? (generate-register-map #:table (0 (#:contents (thing 0 4) (fish 4 4))) #:table* (1 *register-one*) (2 *register-two*))))) (let ((rm (generate-register-map #:table (0 (#:contents (thing 0 4) (fish 4 4))) #:table* (1 *register-one*) (2 *register-two*)))) (define-test "register-map-ref reg1 works" (pass-if-equal? (register-map-ref rm 1) *register-one*)) (define-test "register-map-address item by name works" (pass-if-eq? (item-name (register-map-address rm 1 'bar)) 'bar)) (define-test "register-map-ref item by index works" (pass-if-eq? (item-name (register-map-ref rm 1 0)) 'foo)) (define-test "register-map-address item by name and index works" (pass-if-eq? (item-name (register-map-address rm 1 'foo 0)) 'foo)) (define-test "register-map-address by name works" (pass-if-eq? (item-name (register-map-address rm 'boz)) 'boz)) (define-test "register-map-default works" (pass-if-equal? (register-map-default rm) '((0 . 0) (1 . 0) (2 . 6))))))

false

f7d571ba1115057476d3e7ea89d2a5ea70623de8

ebf028b3a35ae1544bba1a1f9aa635135486ee6c

/sitelib/lunula/sql.scm

d504501e30763cad07e1a1a3553c52f00274d608

[ "BSD-2-Clause", "BSD-3-Clause" ]

permissive

tabe/lunula

b4b666151874271211744cce1346e58e3a56fa79

b7699a850b9c9a64c1d3a52d50ce20050bd17475

refs/heads/master

2021-01-01T20:04:43.571993

2010-05-06T15:39:31

334,916

2

0

null

UTF-8

Scheme

false

10,349

scm

sql.scm

(library (lunula sql) (export call-with-count call-with-tuple delete-query insert-query lookup-query record-name->table-name update-query) (import (rnrs) (only (srfi :1) list-index iota) (only (srfi :48) format) (only (lunula persistent-record) id-of) (only (lunula string) string-underscore)) (define (field-name->column-name s) (string-underscore (symbol->string s))) (define (record-name->table-name s) (string-underscore (symbol->string s))) (define (lookup-where names table where) (string-append "SELECT " (fold-left (lambda (x y) (string-append x ", " y)) "id, created_at, updated_at" (map field-name->column-name (vector->list names))) (if where (format " FROM ~a WHERE ~a" table where) (format " FROM ~a" table)))) (define (lookup-query/id names table id) (lookup-where names table (format "id = '~d'" id))) (define (rtd->columns rtd) (let ((names (record-type-field-names rtd))) (cons* "id" "created_at" "updated_at" (map field-name->column-name (vector->list names))))) (define-syntax ->t (syntax-rules () ((_ depth record-name0 record-name1 ...) (lambda (name) (cond ((list-index (lambda (x) (eq? x name)) '(record-name0 record-name1 ...)) => (lambda (i) (format "t~d_~d" depth i))) (else #f)))))) (define-syntax column-tuple (syntax-rules () ((_ () proc) '()) ((_ (record-name0 record-name1 ...) proc) (cons (map (lambda (c) (format "~a.~a" (proc 'record-name0) c)) (rtd->columns (record-type-descriptor record-name0))) (column-tuple (record-name1 ...) proc))))) (define-syntax lookup-query (syntax-rules () ((_ escape names table ((c v) ...)) (lookup-where names table (fold-left (lambda (x y) (let ((name (field-name->column-name (car y)))) (if x (format "~a AND ~a = '~a'" x name (escape (cadr y))) (format "~a = '~a'" name (escape (cadr y)))))) #f `((c ,v) ...)))) ((_ escape names table param) (let ((x param)) (cond ((integer? x) (lookup-query/id names table x)) ((string? x) (lookup-where names table x)) (else (raise x))))))) (define (equality escape t column-name value) (let ((left (format "~a.~a" t column-name))) (if (boolean? value) (if value (string-append left " IS NOT NULL") (string-append left " IS NULL")) (format "~a = '~a'" left (escape value))))) (define-syntax join (syntax-rules () ((_ name->t record-name (reference foreign) ...) (fold-left (lambda (s ref key) (let ((tt (record-name->table-name ref)) (ti (name->t ref))) (cond ((list? key) (case (length key) ((2) (let ((k (car key)) (m (string-upcase (symbol->string (cadr key))))) (format "~a ~a JOIN ~a ~a ON ~a.~a_id = ~a.id" s m tt ti ti (record-name->table-name k) (name->t k)))) ((1) (let ((k (car key))) (format "~a JOIN ~a ~a ON ~a.~a_id = ~a.id" s tt ti ti (record-name->table-name k) (name->t k)))) (else (assertion-violation 'join "invalid foreign key" key)))) (else (format "~a JOIN ~a ~a ON ~a.id = ~a.~a_id" s tt ti ti (name->t key) tt))))) (format "~a ~a" (record-name->table-name 'record-name) (name->t 'record-name)) '(reference ...) '(foreign ...))))) (define-syntax exists-clause (syntax-rules () ((_ escape depth (record-name (reference foreign) ...) param proc) (let* ((depth+1 (+ depth 1)) (name->t (lambda (x) (or ((->t depth+1 record-name reference ...) x) (proc x)))) (condition (where escape depth+1 param name->t))) (format "EXISTS (SELECT 1 FROM ~a~a)" (join name->t record-name (reference foreign) ...) (if (string? condition) (string-append " WHERE " condition) "")))))) (define-syntax where (syntax-rules (exists) ((_ escape depth () name->t) #f) ((_ escape depth ((exists x param) e ...) name->t) (let ((s (where escape depth (e ...) name->t)) (clause (exists-clause escape depth x param name->t))) (if (string? s) (string-append s " AND " clause) clause))) ((_ escape depth ((record-name (reference)) e ...) name->t) (let ((s (where escape depth (e ...) name->t)) (clause (format "~a.~a_id = ~a.id" (name->t 'record-name) (record-name->table-name 'reference) (name->t 'reference)))) (if (string? s) (string-append s " AND " clause) clause))) ((_ escape depth ((record-name (field-name value) ...) e ...) name->t) (fold-left (lambda (s clause) (if (string? s) (string-append s " AND " clause) clause)) (where escape depth (e ...) name->t) (list (equality escape (name->t 'record-name) (field-name->column-name 'field-name) value) ...))))) (define-syntax epilog (syntax-rules (order-by offset limit) ((_ () name->t) "") ((_ ((order-by (record-name (field-name dir) ...)) e ...) name->t) (string-append " ORDER BY " (fold-left (lambda (s clause) (if (string? s) (string-append s ", " clause) clause)) #f (list (format "~a.~a ~a" (name->t 'record-name) (field-name->column-name 'field-name) 'dir) ...)) (epilog (e ...) name->t))) ((_ ((offset val) e ...) name->t) (format "~a OFFSET ~a" (epilog (e ...) name->t) val)) ((_ ((limit val) e ...) name->t) (format "~a LIMIT ~a" (epilog (e ...) name->t) val)))) (define-syntax call-with-count (syntax-rules () ((_ escape (record-name (reference foreign) ...) param rest cont) (let* ((name->t (->t 0 record-name reference ...)) (condition (where escape 0 param name->t)) (tail (epilog rest name->t)) (query (format "SELECT COUNT(*) FROM ~a~a~a" (join name->t record-name (reference foreign) ...) (if (string? condition) (string-append " WHERE " condition) "") tail))) (cont query))))) (define-syntax call-with-tuple (syntax-rules () ((_ escape (record-name (reference foreign) ...) param rest cont) (let* ((name->t (->t 0 record-name reference ...)) (condition (where escape 0 param name->t)) (tail (epilog rest name->t)) (c-tuple (column-tuple (record-name reference ...) name->t)) (query (format "SELECT ~a FROM ~a~a~a" (fold-left (lambda (s column) (if (string? s) (string-append s ", " column) column)) #f (apply append c-tuple)) (join name->t record-name (reference foreign) ...) (if (string? condition) (string-append " WHERE " condition) "") tail))) (cont c-tuple query))))) (define (call/pv rtd names record proc) ; call-with-proper-values (let ((ns (vector->list names))) (apply proc (fold-left (lambda (couple name value) (if value `(,(cons (field-name->column-name name) (car couple)) ,(cons value (cadr couple))) couple)) '(() ()) ns (map (lambda (i) ((record-accessor rtd i) record)) (iota (length ns))))))) (define (update-query escape rtd names table record) (call/pv rtd names record (lambda (cols vals) (format "UPDATE ~a SET ~a WHERE id = '~d'" table (fold-left (lambda (x name value) (format "~a, ~a = '~a'" x name (escape value))) "updated_at = current_timestamp()" cols vals) (id-of record))))) (define (insert-query escape rtd names table record) (call/pv rtd names record (lambda (cols vals) (format "INSERT INTO ~a (~a) VALUES (~a)" table (fold-left (lambda (s name) (string-append s ", " name)) "created_at, updated_at" cols) (fold-left (lambda (s value) (format "~a, '~a'" s (escape value))) "current_timestamp(), current_timestamp()" vals))))) (define (delete-query/id table id) (format "DELETE FROM ~a WHERE id = '~d'" table id)) (define (delete-query table record) (delete-query/id table (id-of record))) )

true

53184b65449ceb922fd71f0b92531acf61d7d541

81d1b95e884f89ec9cbda45b70c500e7acb2b55e

/scheme/lambda/boolean.ss

da61b67c45b54c517ce9dcd8e8b049322cba3728

[]

no_license

eraserhd/ehk

3ec065adc5a06f4948c8ea2ad539eec5cffd0055

bde0c07d33f6d5498d61361a838dbe1848a6300e

refs/heads/master

2022-12-21T21:50:03.325068

2022-12-13T14:53:48

24,571,764

9

0

null

UTF-8

Scheme

false

483

ss

boolean.ss

(library (lambda boolean) (export booleans) (import (rnrs) (lambda parens)) (define (bind-all alist E) (fold-right (lambda (binding E) `($ (λ ,(car binding) ,E) ,(parenthesize (cdr binding)))) E alist)) (define (booleans E) (bind-all `((TRUE . (λt. λf. t)) (FALSE . (λt. λf. f)) (IF . (λc. λt. λf. c t f)) (AND . (λa. λb. IF a b FALSE)) (NOT . (λa. IF a FALSE TRUE)) (OR . (λa. λb. IF a TRUE b))) E)) )

false

adf99c483b68212965ac501cd4ff95a7209e55ab

bdcc255b5af12d070214fb288112c48bf343c7f6

/rebottled-examples/pstk/timer-6.sps

515f9360e16bf0f54d6632be0a002c1901c73e44

[]

no_license

xaengceilbiths/chez-lib

089af4ab1d7580ed86fc224af137f24d91d81fa4

b7c825f18b9ada589ce52bf5b5c7c42ac7009872

refs/heads/master

2021-08-14T10:36:51.315630

2017-11-15T11:43:57

109,713,952

5

1

null

UTF-8

Scheme

false

1,697

sps

timer-6.sps

#!chezscheme ;; Timer example ;; from http://www.linuxplanet.com/linuxplanet/tutorials/6708/3 ;; Listing 6 translated into Scheme (import (scheme base) (scheme process-context) (rebottled pstk)) (let* ((tk (tk-start)) (scale (tk 'create-widget 'scale 'from: 1 'to: 45 'orient: 'horizontal)) (message-window (lambda () (let* ((win (tk 'create-widget 'toplevel)) (b (win 'create-widget 'button 'text: "DING DING DING" 'bg: "blue" 'fg: "yellow" 'activebackground: "red" 'activeforeground: "white" 'padx: (/ (string->number (tk/winfo 'screenwidth tk)) 3) 'pady: (/ (string->number (tk/winfo 'screenheight tk)) 3) 'command: exit))) (tk/pack b) (tk-event-loop tk)))) (show-alert (lambda () (tk/bell) (message-window) (exit)))) (tk/grid (tk 'create-widget 'label 'text: "Minutes:") 'row: 0 'column: 0) (tk/grid scale 'row: 0 'column: 1) (tk/grid (tk 'create-widget 'button 'text: "Start timing" 'command: (lambda () (tk/after (* (string->number (scale 'get)) 600) show-alert))) 'row: 1 'column: 1 'pady: 5 'sticky: 'E) (tk-event-loop tk))

false

5e18b71c39533617223367cfaa81b219e7bfa731

2e4afc99b01124a1d69fa4f44126ef274f596777

/apng/resources/dracula/lang/dracula.ss

8c3b0a0808df27f76ba9fb02e9a8e61dd47debb0

[]

no_license

directrix1/se2

8fb8204707098404179c9e024384053e82674ab8

931e2e55dbcc55089d9728eb4194ebc29b44991f

refs/heads/master

2020-06-04T03:10:30.843691

2011-05-05T03:32:54

1,293,430

0

null

UTF-8

Scheme

false

181

ss

dracula.ss

#lang scheme (require "acl.ss" "dracula-module-begin.ss") (provide (all-from-out "acl.ss") (rename-out [dracula-module-begin #%module-begin]) #%top-interaction)

false

a63f168b417ed355cf727c97e29a0a2cbe558421

427586e066e5d7d146d3b24c1400781a91011a94

/code/include/print-eval.sld

7f740535b3abe972348c6cb8e1bed07e42451de1

[ "LicenseRef-scancode-public-domain" ]

permissive

cslarsen/scheme-presentation

07cb3d5d7850cc6e7616dad43718c139178cbd7c

7b66aef60041f95358f0eab72c58ac400e1f902f

refs/heads/master

2016-08-11T14:50:33.517262

2016-01-28T07:25:06

50,564,125

0

null

UTF-8

Scheme

false

509

sld

print-eval.sld

(define-library (print-eval) (import (scheme base) (scheme write)) (export print-eval) (begin ;; Print code and its result, e.g. ;; ;; (print-eval (+ 1 2 3)) ;; ;; prints "(+ 1 2 3) ==> 6\n" ;; (define-syntax print-eval (syntax-rules () ((_ body ...) (let ((code (quote body ...)) (result (begin body ...))) (display code) (display " ==> ") (display result) (newline)))))))

true

c344afea8d1defb631049da815916db625e6a0cd

8a0660bd8d588f94aa429050bb8d32c9cd4290d5

/sitelib/scheme/lazy.scm

1c8f600be27ab8e5841936ec1dc89bf1bbc180f7

[ "BSD-2-Clause" ]

permissive

david135/sagittarius-scheme

dbec76f6b227f79713169985fc16ce763c889472

2fbd9d153c82e2aa342bfddd59ed54d43c5a7506

refs/heads/master

2016-09-02T02:44:31.668025

2013-12-21T07:24:08

32,497,456

0

null

UTF-8

Scheme

false

307

scm

lazy.scm

;; -*- mode:scheme; coding: utf-8; -*- #!compatible (library (scheme lazy) (export delay force delay-force make-promise promise?) (import (rnrs) (core r5rs)) (define (promise? obj) (and (pair? obj) (pair? (car obj)) (null? (cdr obj)) (boolean? (caar obj)) (procedure? (cdar obj)))) )

false

041c9b69b484d7168a355d6d3b3bbbc3649c3ab4

c157305e3b08b76c2f4b0ac4f9c04b435097d0dc

/eopl2e/code/interps/3-7.scm

31e0635f1d32b8543fbdabfdc2e29772eac0992a

[]

no_license

rstewart2702/scheme_programs

a5e91bd0e1587eac3859058da18dd9271a497721

767d019d84896569f2fc02de95925b05a38cac4d

refs/heads/master

2021-05-02T02:01:01.964797

2014-03-31T19:02:36

13,077,035

0

1

null

UTF-8

Scheme

false

7,525

scm

3-7.scm

;; 3-7.scm : interp with variable assignment (let ((time-stamp "Time-stamp: <2001-05-10 16:13:41 dfried>")) (eopl:printf "3-7.scm - interp with variable assignment ~a~%" (substring time-stamp 13 29))) ;;;;;;;;;;;;;;;; top level and tests ;;;;;;;;;;;;;;;; (define run (lambda (string) (eval-program (scan&parse string)))) (define run-all (lambda () (run-experiment run use-execution-outcome '(lang3-1 lang3-5 lang3-6 lang3-7) all-tests))) (define run-one (lambda (test-name) (run-test run test-name))) ;; needed for testing (define equal-external-reps? equal?) ;;;;;;;;;;;;;;;; grammatical specification ;;;;;;;;;;;;;;;; (define the-lexical-spec '((whitespace (whitespace) skip) (comment ("%" (arbno (not #\newline))) skip) (identifier (letter (arbno (or letter digit "_" "-" "?"))) symbol) (number (digit (arbno digit)) number))) (define the-grammar '((program (expression) a-program) (expression (number) lit-exp) (expression (identifier) var-exp) (expression (primitive "(" (separated-list expression ",") ")") primapp-exp) (expression ("if" expression "then" expression "else" expression) if-exp) (expression ("let" (arbno identifier "=" expression) "in" expression) let-exp) (expression ("proc" "(" (separated-list identifier ",") ")" expression) proc-exp) (expression ("(" expression (arbno expression) ")") app-exp) (expression ("set" identifier "=" expression) varassign-exp) ; new for 3-7 (expression ("letrec" (arbno identifier "(" (separated-list identifier ",") ")" "=" expression) "in" expression) letrec-exp) (primitive ("+") add-prim) (primitive ("-") subtract-prim) (primitive ("*") mult-prim) (primitive ("add1") incr-prim) (primitive ("sub1") decr-prim) (primitive ("zero?") zero-test-prim) )) (sllgen:make-define-datatypes the-lexical-spec the-grammar) (define list-the-datatypes (lambda () (sllgen:list-define-datatypes the-lexical-spec the-grammar))) (define scan&parse (sllgen:make-string-parser the-lexical-spec the-grammar)) (define just-scan (sllgen:make-string-scanner the-lexical-spec the-grammar)) ;;;;;;;;;;;;;;;; the interpreter ;;;;;;;;;;;;;;;; (define eval-program (lambda (pgm) (cases program pgm (a-program (body) (eval-expression body (init-env)))))) (define eval-expression ;^exp x env -> expval (lambda (exp env) (cases expression exp (lit-exp (datum) datum) (var-exp (id) (apply-env env id)) (varassign-exp (id rhs-exp) ;\new6 (begin (setref! (apply-env-ref env id) (eval-expression rhs-exp env)) 1)) (primapp-exp (prim rands) (let ((args (eval-rands rands env))) (apply-primitive prim args))) (if-exp (test-exp true-exp false-exp) ;\new4 (if (true-value? (eval-expression test-exp env)) (eval-expression true-exp env) (eval-expression false-exp env))) (proc-exp (ids body) (closure ids body env)) ;\new1 (let-exp (ids rands body) ;\new3 (let ((args (eval-rands rands env))) (eval-expression body (extend-env ids args env)))) (app-exp (rator rands) ;\new7 (let ((proc (eval-expression rator env)) (args (eval-rands rands env))) (if (procval? proc) (apply-procval proc args) (eopl:error 'eval-expression "Attempt to apply non-procedure ~s" proc)))) (letrec-exp (proc-names idss bodies letrec-body) ;\new4 (eval-expression letrec-body (extend-env-recursively proc-names idss bodies env))) ))) (define eval-rands (lambda (rands env) (map (lambda (x) (eval-rand x env)) rands))) (define eval-rand (lambda (rand env) (eval-expression rand env))) (define apply-primitive (lambda (prim args) (cases primitive prim (add-prim () (+ (car args) (cadr args))) (subtract-prim () (- (car args) (cadr args))) (mult-prim () (* (car args) (cadr args))) (incr-prim () (+ (car args) 1)) (decr-prim () (- (car args) 1)) (zero-test-prim () (if (zero? (car args)) 1 0)) ))) (define init-env (lambda () (extend-env '(i v x) '(1 5 10) (empty-env)))) ;;;;;;;;;;;;;;;; booleans ;;;;;;;;;;;;;;;; (define true-value? (lambda (x) (not (zero? x)))) ;;;;;;;;;;;;;;;; procedures ;;;;;;;;;;;;;;;; (define-datatype procval procval? (closure (ids (list-of symbol?)) (body expression?) (env environment?))) (define apply-procval (lambda (proc args) (cases procval proc (closure (ids body env) (eval-expression body (extend-env ids args env)))))) ;;;;;;;;;;;;;;;; references ;;;;;;;;;;;;;;;; (define-datatype reference reference? (a-ref (position integer?) (vec vector?))) (define primitive-deref (lambda (ref) (cases reference ref (a-ref (pos vec) (vector-ref vec pos))))) (define primitive-setref! (lambda (ref val) (cases reference ref (a-ref (pos vec) (vector-set! vec pos val))))) (define deref (lambda (ref) (primitive-deref ref))) (define setref! (lambda (ref val) (primitive-setref! ref val))) ;;;;;;;;;;;;;;;; environments ;;;;;;;;;;;;;;;; (define-datatype environment environment? (empty-env-record) (extended-env-record (syms (list-of symbol?)) (vec vector?) ; can use this for anything. (env environment?)) ) (define empty-env (lambda () (empty-env-record))) ;;;; Right now a prefix must appear earlier in the file. (define extend-env (lambda (syms vals env) (extended-env-record syms (list->vector vals) env))) ;;;; Right now a prefix must appear earlier in the file. (define apply-env (lambda (env sym) (deref (apply-env-ref env sym)))) (define apply-env-ref (lambda (env sym) (cases environment env (empty-env-record () (eopl:error 'apply-env-ref "No binding for ~s" sym)) (extended-env-record (syms vals env) (let ((pos (rib-find-position sym syms))) (if (number? pos) (a-ref pos vals) (apply-env-ref env sym))))))) (define extend-env-recursively (lambda (proc-names idss bodies old-env) (let ((len (length proc-names))) (let ((vec (make-vector len))) (let ((env (extended-env-record proc-names vec old-env))) (for-each (lambda (pos ids body) (vector-set! vec pos (closure ids body env))) (iota len) idss bodies) env))))) (define rib-find-position (lambda (sym los) (list-find-position sym los))) (define list-find-position (lambda (sym los) (list-index (lambda (sym1) (eqv? sym1 sym)) los))) (define list-index (lambda (pred ls) (cond ((null? ls) #f) ((pred (car ls)) 0) (else (let ((list-index-r (list-index pred (cdr ls)))) (if (number? list-index-r) (+ list-index-r 1) #f)))))) (define iota (lambda (end) (let loop ((next 0)) (if (>= next end) '() (cons next (loop (+ 1 next))))))) (define difference (lambda (set1 set2) (cond ((null? set1) '()) ((memv (car set1) set2) (difference (cdr set1) set2)) (else (cons (car set1) (difference (cdr set1) set2))))))

false

4b0af72d22c754a8da8d8ede368ddf588805a11c

75a71f8ec7db121c3c0356f68dde06a88576cd22

/scheme/read.sld

38b7f38efe37a5f219e1ce19fc7f9d4817226e53

[ "MIT" ]

permissive

ckkashyap/cyclone-bootstrap

37df6441af04c3c12e297e679e0520cd05f9476f

ce61ddedf3ec740b40863408e86d589da03a6d6d

refs/heads/master

2021-01-21T08:05:13.104621

2017-05-24T01:46:45

91,618,359

1

0

null

2017-05-17T20:41:48

2017-05-17T20:41:47

null

UTF-8

Scheme

false

24,852

sld

read.sld

;;;; Cyclone Scheme ;;;; https://github.com/justinethier/cyclone ;;;; ;;;; Copyright (c) 2014-2016, Justin Ethier ;;;; All rights reserved. ;;;; ;;;; This module contains the s-expression parser and supporting functions. ;;;; (define-library (scheme read) (import (scheme base) ;(scheme write) (scheme char)) (export read read-all include include-ci ) (inline in-port:get-cnum in-port:get-lnum in-port:get-buf ) (begin (define-syntax include (er-macro-transformer (lambda (expr rename compare) (apply append (cons '(begin) (map (lambda (filename) (call-with-port (open-input-file filename) (lambda (port) (read-all port)))) (cdr expr))))))) (define-syntax include-ci (er-macro-transformer (lambda (expr rename compare) `(include ,@(cdr expr))))) (define read cyc-read) ;; Extended information for each input port (define *in-port-table* '()) (define (reg-port fp) (let ((r (assoc fp *in-port-table*))) (cond ((not r) ;(write `(ADDED NEW ENTRY TO in port table!!)) (set! r (list fp #f ; Buffered char, if any 1 ; Line number 0)) ; Char number (set! *in-port-table* (cons r *in-port-table*)) r) (else r)))) ;; TODO: unreg-port - delete fp entry from *in-port-table* ;; would want to do this when port is closed (define (in-port:get-buf ptbl) (cadr ptbl)) (define (in-port:get-lnum ptbl) (caddr ptbl)) (define (in-port:get-cnum ptbl) (cadddr ptbl)) ;(define in-port:get-buf cadr) ;(define in-port:get-lnum caddr) ;(define in-port:get-cnum cadddr) (define (in-port:set-buf! ptbl buf) (set-car! (cdr ptbl) buf)) (define (in-port:set-lnum! ptbl lnum) (set-car! (cddr ptbl) lnum)) (define (in-port:set-cnum! ptbl cnum) (set-car! (cdddr ptbl) cnum)) ;(define-syntax in-port:set-buf! ; (er-macro-transformer ; (lambda (e r c) ; `(set-car! (cdr ,(cadr e)) ,(caddr e))))) ;(define-syntax in-port:set-lnum! ; (er-macro-transformer ; (lambda (e r c) ; `(set-car! (cddr ,(cadr e)) ,(caddr e))))) ;(define-syntax in-port:set-cnum! ; (er-macro-transformer ; (lambda (e r c) ; `(set-car! (cdddr ,(cadr e)) ,(caddr e))))) (define (in-port:read-buf! ptbl) (let ((result (cadr ptbl))) (in-port:set-buf! ptbl #f) result)) ;; END input port table ;; Helper functions (define (add-tok tok toks) (cons tok toks)) ;; Get completed list of tokens (define (get-toks tok toks) (if (null? tok) toks (add-tok (->tok tok) toks))) ;; Add a token to the list, quoting it if necessary (define (->tok lst) (parse-atom (reverse lst))) ;; Did we read a dotted list (define (dotted? lst) (and (> (length lst) 2) (equal? (cadr (reverse lst)) (string->symbol ".")))) ;; Convert a list read by the reader into an improper list (define (->dotted-list lst) (cond ((null? lst) '()) ((equal? (car lst) (string->symbol ".")) (cadr lst)) (else (cons (car lst) (->dotted-list (cdr lst)))))) (define (parse-error msg lnum cnum) (error (string-append "Error (line " (number->string lnum) ", char " (number->string cnum) "): " msg))) ;; Add finished token, if there is one, and continue parsing (define (parse/tok fp tok toks all? comment? parens ptbl curr-char) (cond ((null? tok) (parse fp '() toks all? comment? parens ptbl)) (all? (parse fp '() (add-tok (->tok tok) toks) all? comment? parens ptbl)) (else ;; Reached a terminating char, return current token and ;; save term char for the next (read). ;; Note: never call set-buf! if in "all?" mode, since ;; that mode builds a list of tokens (in-port:set-buf! ptbl curr-char) ;(write `(DEBUG ,tok ,ptbl)) ;(write "\n") (car (add-tok (->tok tok) toks))))) ;; Parse input from stream ;; ;; Input: ;; - Port object ;; - Current token ;; - List of tokens read (if applicable) ;; - Bool - Read-all mode, or just read the next object? ;; - Bool - Are we inside a comment? ;; - Level of nested parentheses ;; - Entry in the in-port table for this port ;; ;; Output: next object, or list of objects (if read-all mode) ;; (define (parse fp tok toks all? comment? parens ptbl) (in-port:set-cnum! ptbl (+ 1 (in-port:get-cnum ptbl))) (let ((c (if (in-port:get-buf ptbl) (in-port:read-buf! ptbl) ;; Already buffered (read-char fp)))) ;; DEBUGGING ;(write `(DEBUG read ,tok ,c)) ;(write (newline)) ;; END DEBUG (cond ((eof-object? c) (if (> parens 0) (parse-error "missing closing parenthesis" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (if all? (reverse (get-toks tok toks)) (let ((last (get-toks tok toks))) (if (> (length last) 0) (car last) c)))) ;; EOF (comment? (if (eq? c #\newline) (begin (in-port:set-lnum! ptbl (+ 1 (in-port:get-lnum ptbl))) (in-port:set-cnum! ptbl 0) (parse fp '() toks all? #f parens ptbl)) (parse fp '() toks all? #t parens ptbl))) ((eq? c #\newline) (in-port:set-lnum! ptbl (+ 1 (in-port:get-lnum ptbl))) (in-port:set-cnum! ptbl 0) (parse/tok fp tok toks all? #f parens ptbl c)) ((char-whitespace? c) (parse/tok fp tok toks all? #f parens ptbl c)) ((eq? c #\;) (parse/tok fp tok toks all? #t parens ptbl c)) ((eq? c #\') (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token ;; TODO: would also need to do this if previous char was ;; not a quote! ;; EG: 'a'b ==> (quote a) (quote b), NOT (quote (quote b)) (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) (else ;; Read the next expression and wrap it in a quote (let ((sub (parse fp '() '() #f ;all? #f ;comment? 0 ;parens ptbl))) (define new-toks (add-tok (list 'quote sub) ;(if (and (pair? sub) (dotted? sub)) ; (->dotted-list sub) ; sub)) (get-toks tok toks))) ;; Keep going (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))))) ((eq? c #\`) ;; TODO: should consolidate this with above (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) (else ;; Read the next expression and wrap it in a quote (let ((sub (parse fp '() '() #f #f 0 ptbl))) (define new-toks (add-tok (list 'quasiquote sub) (get-toks tok toks))) ;; Keep going (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))))) ((eq? c #\,) (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) (else ;; TODO: ; buffer must be empty now since it is only 1 char, so ; call read-char. then: ; - @ - unquote-splicing processing ; - eof - error ; - otherwise, add char back to buffer and do unquote processing ;; Read the next expression and wrap it in a quote (letrec ((sub #f) (next-c (read-char fp)) (unquote-sym (if (equal? next-c #\@) 'unquote-splicing 'unquote)) (new-toks #f)) ;; Buffer read-ahead char, if unused (cond ((eof-object? next-c) (parse-error "unexpected end of file" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) ((not (equal? next-c #\@)) (in-port:set-buf! ptbl next-c)) (else #f)) (set! sub (parse fp '() '() #f #f 0 ptbl)) (set! new-toks (add-tok (list unquote-sym sub) (get-toks tok toks))) ;; Keep going (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))))) ((eq? c #$) (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) (else (let ((sub ;(_cyc-read-all fp (+ parens 1))) (parse fp '() '() #t #f (+ parens 1) ptbl)) (toks* (get-toks tok toks))) (define new-toks (add-tok (if (and (pair? sub) (dotted? sub)) (->dotted-list sub) sub) toks*)) ;(write `(DEBUG incrementing paren level ,parens ,sub)) (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))))) ((eq? c #$) (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) ((= parens 0) (parse-error "unexpected closing parenthesis" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (else (reverse (get-toks tok toks))))) ((eq? c #\") (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) (else (let ((str (read-str fp '() ptbl)) (toks* (get-toks tok toks))) (define new-toks (add-tok str toks*)) (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))))) ((eq? c #\#) (if (null? tok) ;; # reader (let ((next-c (read-char fp))) (in-port:set-cnum! ptbl (+ 1 (in-port:get-cnum ptbl))) (cond ;; Block comments ((eq? #\| next-c) (read-block-comment fp ptbl) (parse fp '() toks all? #f parens ptbl)) ;; Booleans ;; Do not use add-tok below, no need to quote a bool ((eq? #\t next-c) ;; read in rest of #true if it is there (when (eq? #\r (peek-char fp)) (if (not (and (eq? #\r (read-char fp)) (eq? #\u (read-char fp)) (eq? #\e (read-char fp)))) (parse-error "Invalid syntax for boolean true" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)))) (if all? (parse fp '() (cons #t toks) all? #f parens ptbl) #t)) ((eq? #\f next-c) ;; read in rest of #false if it is there (when (eq? #\a (peek-char fp)) (if (not (and (eq? #\a (read-char fp)) (eq? #\l (read-char fp)) (eq? #\s (read-char fp)) (eq? #\e (read-char fp)))) (parse-error "Invalid syntax for boolean false" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)))) (if all? (parse fp '() (cons #f toks) all? #f parens ptbl) #f)) ;; Numbers ((eq? #\e next-c) (parse-number fp toks all? parens ptbl 10 (lambda (num) (exact (string->number (list->string num)))))) ((eq? #\i next-c) (parse-number fp toks all? parens ptbl 10 (lambda (num) (inexact (string->number (list->string num)))))) ((eq? #\b next-c) (parse-number fp toks all? parens ptbl 2 (lambda (num) (string->number (list->string num) 2)))) ((eq? #\o next-c) (parse-number fp toks all? parens ptbl 8 (lambda (num) (string->number (list->string num) 8)))) ((eq? #\x next-c) (parse-number fp toks all? parens ptbl 16 (lambda (num) (string->number (list->string num) 16)))) ;; Bytevector ((eq? #\u next-c) (set! next-c (read-char fp)) (if (not (eq? #\8 next-c)) (parse-error "Unhandled input sequence" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (set! next-c (read-char fp)) (if (not (eq? #\( next-c)) (parse-error "Unhandled input sequence" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (let ((sub (parse fp '() '() #t #f (+ parens 1) ptbl)) (toks* (get-toks tok toks))) (define new-toks (add-tok (if (and (pair? sub) (dotted? sub)) (parse-error "Invalid vector syntax" ;(->dotted-list sub) (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)) (apply bytevector sub)) toks*)) (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))) ;; Vector ((eq? #\( next-c) (let ((sub (parse fp '() '() #t #f (+ parens 1) ptbl)) (toks* (get-toks tok toks))) (define new-toks (add-tok (if (and (pair? sub) (dotted? sub)) (parse-error "Invalid vector syntax" ;(->dotted-list sub) (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)) (list->vector sub)) toks*)) (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))) ;; Character ((eq? #\\ next-c) (let ((new-toks (cons (read-pound fp ptbl) toks))) (if all? (parse fp '() new-toks all? #f parens ptbl) (car new-toks)))) ;; Datum comment ((eq? #\; next-c) ; Read and discard next datum (parse fp '() '() #f #f 0 ptbl) (cond ((and (not all?) (not (null? tok))) ;; Reached a terminal char, read out previous token (in-port:set-buf! ptbl c) (car (add-tok (->tok tok) toks))) (else (parse fp tok toks all? #f parens ptbl)))) (else (parse-error "Unhandled input sequence" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))))) ;; just another char... (parse fp (cons c tok) toks all? #f parens ptbl))) ((eq? c #\|) (parse-literal-identifier fp toks all? parens ptbl)) (else (parse fp (cons c tok) toks all? #f parens ptbl))))) ;; Read chars past a leading #\ (define (read-pound fp ptbl) (define (done raw-buf) (let ((buf (reverse raw-buf))) (cond ((= 0 (length buf)) (parse-error "missing character" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) ((= 1 (length buf)) (car buf)) ((equal? buf '(#\a #\l #\a #\r #\m)) (integer->char 7)) ((equal? buf '(#\b #\a #\c #\k #\s #\p #\a #\c #\e)) (integer->char 8)) ((equal? buf '(#\d #\e #\l #\e #\t #\e)) (integer->char 127)) ((equal? buf '(#\e #\s #\c #\a #\p #\e)) (integer->char 27)) ((equal? buf '(#\n #\e #\w #\l #\i #\n #\e)) (integer->char 10)) ((equal? buf '(#\n #\u #\l #\l)) (integer->char 0)) ((equal? buf '(#\r #\e #\t #\u #\r #\n)) (integer->char 13)) ((equal? buf '(#\s #\p #\a #\c #\e)) (integer->char 32)) ((equal? buf '(#\t #\a #\b)) (integer->char 9)) ((and (> (length buf) 1) (equal? (car buf) #\x)) (integer->char (string->number (list->string (cdr buf)) 16))) (else (parse-error (string-append "unable to parse character: " (list->string buf)) (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)))))) (define (loop buf) (let ((c (peek-char fp))) (cond ((or (eof-object? c) (and (char-whitespace? c) (> (length buf) 0)) (and (> (length buf) 0) (equal? c #\)))) (done buf)) (else (loop (cons (read-char fp) buf)))))) (loop '())) (define (read-hex-scalar-value fp ptbl) (define (done buf) (cond ((= 0 (length buf)) (parse-error "missing character" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (else (integer->char (string->number (list->string buf) 16))))) (define (loop buf) (let ((c (read-char fp))) (cond ((or (eof-object? c) (eq? #\; c)) (done (reverse buf))) (else (loop (cons c buf)))))) (loop '())) (define (read-str fp buf ptbl) (let ((c (read-char fp))) (cond ((eof-object? c) (parse-error "missing closing double-quote" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) ((equal? #\\ c) (read-str fp (read-str-esc fp buf ptbl) ptbl)) ((equal? #\" c) (list->string (reverse buf))) (else (read-str fp (cons c buf) ptbl))))) ;; Read an escaped character within a string ;; The escape '\' has already been read at this point (define (read-str-esc fp buf ptbl) (let ((c (read-char fp))) (cond ((eof-object? c) (parse-error "missing escaped character within string" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) ((or (equal? #\" c) (equal? #\' c) (equal? #\? c) (equal? #\| c) (equal? #\\ c)) (cons c buf)) ((equal? #\a c) (cons #\alarm buf)) ((equal? #\b c) (cons #\backspace buf)) ((equal? #\n c) (cons #\newline buf)) ((equal? #\r c) (cons #\return buf)) ((equal? #\t c) (cons #\tab buf)) ((equal? #\x c) (cons (read-hex-scalar-value fp ptbl) buf)) (else (parse-error (string-append "invalid escape character [" (list->string (list c)) "] in string") (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)))))) (define (sign? c) (or (equal? c #\+) (equal? c #\-))) ;; token-numeric? -> [chars] -> boolean (define (token-numeric? a) (or (char-numeric? (car a)) (and (> (length a) 1) (eq? #\. (car a)) (char-numeric? (cadr a))) (and (> (length a) 1) (or (char-numeric? (cadr a)) (eq? #\. (cadr a))) (sign? (car a))))) ;; parse-atom -> [chars] -> literal (define (parse-atom a) (if (token-numeric? a) (string->number (list->string a)) (if (or (equal? a '(#\+ #\i #\n #\f #\. #\0)) (equal? a '(#\- #\i #\n #\f #\. #\0))) (expt 2.0 1000000) (if (or (equal? a '(#\+ #\n #\a #\n #\. #\0)) (equal? a '(#\- #\n #\a #\n #\. #\0))) (/ 0.0 0.0) (string->symbol (list->string a)))))) ;;;;; ;; Read next character from port, using buffered char if available (define (get-next-char fp ptbl) (if (in-port:get-buf ptbl) (in-port:read-buf! ptbl) ;; Already buffered (read-char fp))) ;; Read chars in the middle of a block comment (define (read-block-comment fp ptbl) (let ((c (get-next-char fp ptbl))) (cond ((eq? #\| c) (read-block-terminator fp ptbl)) (else (read-block-comment fp ptbl))))) ;; Read (possibly) the end of a block comment (define (read-block-terminator fp ptbl) (let ((c (get-next-char fp ptbl))) (cond ((eq? #\# c) #t) ((eq? #\| c) (read-block-terminator fp ptbl)) (else (read-block-comment fp ptbl))))) ;; Parse literal identifier encountered within pipes (define (parse-literal-identifier fp toks all? parens ptbl) (let ((sym (parse-li-rec fp '() ptbl))) (if all? (parse fp '() (cons sym toks) all? #f parens ptbl) sym))) ;; Helper for parse-literal-identifier (define (parse-li-rec fp tok ptbl) (let ((c (get-next-char fp ptbl)) (next (lambda (c) (parse-li-rec fp (cons c tok) ptbl)))) (cond ((eq? #\| c) (let ((str (if (null? tok) "||" (list->string (reverse tok))))) (string->symbol str))) ((eof-object? c) (parse-error "EOF encountered parsing literal identifier" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (else (next c))))) (define (parse-number fp toks all? parens ptbl base tok->num) ; (parse-number-rec base fp '() ptbl)) (let ((num (parse-number-rec base fp '() ptbl))) ;(write `(DEBUG2 ,num ,(string? num))) (cond ((and (not (null? num)) (or (token-numeric? num) (and (> (length num) 0) (= base 16) (hex-digit? (car num))))) (let ((result (tok->num num))) (if all? (parse fp '() (cons result toks) all? #f parens ptbl) result))) (else (parse-error "Illegal number syntax" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl)))))) (define (parse-number-rec base fp tok ptbl) (let ((c (get-next-char fp ptbl)) (next (lambda (c) (parse-number-rec base fp (cons c tok) ptbl)))) (cond ((sign? c) (next c)) ((eq? #\. c) (next c)) ((char-numeric? c) (if (or (and (= base 2) (char>? c #\1)) (and (= base 8) (char>? c #\7))) (parse-error "Illegal digit" (in-port:get-lnum ptbl) (in-port:get-cnum ptbl))) (next c)) ((and (= base 16) (hex-digit? c)) (next c)) (else ;; We are done parsing a number (in-port:set-buf! ptbl c) ;; rebuffer unprocessed char (reverse tok))))) ;; Return token (define (hex-digit? c) (or (and (char>=? c #\a) (char<=? c #\f)) (and (char>=? c #\A) (char<=? c #\F)))) ;;;;; ;; Main lexer/parser (define cyc-read ;; TODO: should be (read), but that is breaking on csi 4.8.0.5 (lambda args (let ((fp (if (null? args) (current-input-port) (car args)))) (parse fp '() '() #f #f 0 (reg-port fp))))) ;; read-all -> port -> [objects] (define (read-all . args) (let ((fp (if (null? args) (current-input-port) (car args)))) (define (loop fp result) (let ((obj (cyc-read fp))) (if (eof-object? obj) (reverse result) (loop fp (cons obj result))))) (loop fp '()))) ;; TODO: for some reason this causes trouble in chicken 4.8. WTF?? ;; read -> port -> object ;(define read cyc-read) ; ;; Test code ; ;(let ((fp (open-input-file "tests/begin.scm"))) ; ;(let ((fp (open-input-file "tests/strings.scm"))) ; (let ((fp (open-input-file "test.scm"))) ; (let ((fp (open-input-file "tests/unit-tests.scm"))) ; (write (read-all fp))) ;(define (repl) ; (let ((fp (current-input-port))) ; (write (cyc-read fp))) ; (repl)) ;(repl) ))

true

ff32d9d7e0b246de95e54fd1fb9068ae5569d26d

b39668eccdb1b003b6f98ea6e7a92c7bb2b5e951

/game.bak

b08436c562a84d6c32ac9e244334779e555738a4

[]

no_license

angryzor/magic-the-gathering-project

d9c1f99bfbb38a8f9850427140d72db8c691297c

a58993eae9a7b0130353735b2d09ae6c8b07b006

refs/heads/master

2021-01-01T17:17:16.742759

2013-01-12T17:32:04

7,578,284

0

1

null

UTF-8

Scheme

false

2,461

bak

game.bak

#!r6rs (library (game) (export game) (import (rnrs base (6)) (rnrs io simple) (magic fields) (magic double-linked-position-list) (magic phase) (magic player) (magic gui-view) (magic null-card) (magic tenth-edition) (magic mana)) (define (game names) (define num-players (length names)) (define (construct) (for-each (lambda (name) (players 'add-after! (player obj-game field name))) names) (players 'for-each (lambda (player) (player 'set-gui! (gui-view player obj-game))))) (define (get-field) field) (define (get-players) players) (define (get-num-players) num-players) (define (get-active-player) (players 'value (players 'first-position))) (define (next-turn!) (let* ([pos (players 'first-position)] [p (players 'value pos)]) (players 'delete! pos) (players 'add-after! p))) (define (get-phases) phases) (define (update-all-guis) (players 'for-each (lambda (player) ((player 'get-gui) 'update)))) (define (obj-game msg . args) (case msg ((get-field) (apply get-field args)) ((get-players) (apply get-players args)) ((get-num-players) (apply get-num-players args)) ((get-active-player) (apply get-active-player args)) ((next-turn!) (apply next-turn! args)) ((get-phases) (apply get-phases args)) ((update-all-guis) (apply update-all-guis args)) (else (assertion-violation 'game "message not understood" msg)))) (define field (main-field)) (define players (position-list eq?)) (define phases (phases-fsm obj-game)) (construct) obj-game) (define (tr) ((a 'get-phases) 'transition) (display ((a 'get-phases) 'get-current-type)) (newline)) (define a (game '("Ruben" "Sander"))) (define b (a 'get-players)) (define c (b 'value (b 'first-position))) (define d (c 'get-field)) (define e (d 'get-hand-zone)) (define f (d 'get-library-zone)) (e 'add-card! (card-doomed-necromancer a c)) (e 'add-card! (card-canopy-spider a c)) (e 'add-card! (card-forest a c)) (e 'add-card! (card-forest a c)) (f 'add-card! (card-forest a c)) ((c 'get-gui) 'update) (tr) )

false

04659ba393e5585e4bf433a0f83165eb6b8871b7

0768e217ef0b48b149e5c9b87f41d772cd9917f1

/heap/boot/macro/derived.scm

927acb4b058955e143197332238923357ce43978

[ "LicenseRef-scancode-unknown-license-reference", "BSD-2-Clause" ]

permissive

fujita-y/ypsilon

e45c897436e333cf1a1009e13bfef72c3fb3cbe9

62e73643a4fe87458ae100e170bf4721d7a6dd16

refs/heads/master

2023-09-05T00:06:06.525714

2023-01-25T03:56:13

2023-01-25T04:02:59

41,003,666

45

7

BSD-2-Clause

2022-06-25T05:44:49

2015-08-19T00:05:35

Scheme

UTF-8

Scheme

false

17,104

scm

derived.scm

;;; Copyright (c) 2004-2022 Yoshikatsu Fujita / LittleWing Company Limited. ;;; See LICENSE file for terms and conditions of use. (define warning-contract-violation (lambda (form inits lst) (for-each (lambda (var) (display-warning (format "warning: binding construct may attempt to reference uninitialized variable ~u" var) form (any1 (lambda (e) (and (check-rec-contract-violation (list var) e) e)) inits))) lst))) (define expand-let (lambda (form env) (destructuring-match form ((_ (? symbol? name) (? list? bindings) body ...) (begin (check-let-bindings form bindings) (expand-form (annotate `(|.let| ,bindings (|.letrec*| ((,name (|.lambda| ,(map car bindings) ,@body))) (,name ,@(map car bindings)))) form) env))) ((_ () body ...) (let ((body (expand-body form body env))) (if (null? body) (syntax-violation (car form) "empty body" form) (annotate `(let () ,@body) form)))) ((_ bindings body ...) (begin (check-let-bindings form bindings) (let ((vars (map car bindings)) (inits (map (lambda (a) (expand-form (cadr a) env)) bindings)) (suffix (fresh-rename-count))) (let* ((renames (map (lambda (id) (rename-variable-id id suffix)) vars)) (body (expand-body form (cddr form) (extend-env (map cons vars renames) env)))) (cond ((null? body) (syntax-violation (car form) "empty body" form)) (else (annotate-bindings vars inits env) (annotate `(let ,(map list renames inits) ,@body) form))))))) (_ (syntax-violation (car form) "expected bindings and body" form))))) (define expand-letrec* (lambda (form env) (destructuring-match form ((_ () body ...) (let ((body (expand-body form body env))) (if (null? body) (syntax-violation (car form) "empty body" form) (annotate `(let () ,@body) form)))) ((_ bindings body ...) (begin (check-let-bindings form bindings) (let ((vars (map car bindings)) (suffix (fresh-rename-count))) (let* ((renames (map (lambda (id) (rename-variable-id id suffix)) vars)) (env (extend-env (map cons vars renames) env))) (let ((inits (map (lambda (a) (expand-form (cadr a) env)) bindings)) (body (expand-body form (cddr form) env))) (annotate-bindings vars inits env) (cond ((null? body) (syntax-violation (car form) "empty body" form)) ((check-rec*-contract-violation renames inits) => (lambda (lst) (and (warning-level) (warning-contract-violation form inits lst)) (annotate `(let ,(map (lambda (e) (list e '|.&UNDEF|)) renames) ,@(map (lambda (lhs rhs) `(set! ,lhs ,rhs)) renames inits) (let () ,@body)) form))) (else (annotate `(letrec* ,(rewrite-letrec*-bindings (map list renames inits) env) ,@body) form))))))))))) (define expand-letrec (lambda (form env) (destructuring-match form ((_ () body ...) (expand-form (annotate `(|.let| () ,@body) form) env)) ((_ ((var init)) body ...) (expand-form (annotate `(|.letrec*| ((,var ,init)) ,@body) form) env)) ((_ bindings body ...) (begin (check-let-bindings form bindings) (let ((vars (map car bindings)) (suffix (fresh-rename-count))) (let* ((renames (map (lambda (id) (rename-variable-id id suffix)) vars)) (env (extend-env (map cons vars renames) env))) (let ((inits (map (lambda (a) (expand-form (cadr a) env)) bindings)) (body (expand-body form (cddr form) env))) (annotate-bindings vars inits env) (cond ((null? body) (syntax-violation (car form) "empty body" form)) ((check-rec-contract-violation renames inits) => (lambda (lst) (and (warning-level) (warning-contract-violation form inits lst))))) (if (every1 (lambda (e) (if (pair? e) (denote-lambda? env (car e)) (not (symbol? e)))) inits) (annotate `(letrec* ,(rewrite-letrec*-bindings (map list renames inits) env) ,@body) form) (let ((temps (map (lambda (_) (rename-id (generate-temporary-symbol) suffix)) bindings))) `(let ,(map (lambda (e) (list e '|.&UNDEF|)) renames) (let ,(map list temps inits) ,@(map (lambda (lhs rhs) `(set! ,lhs ,rhs)) renames temps) ,@body)))))))))))) (define expand-let* (lambda (form env) (if (> (safe-length form) 2) (let ((bindings (cadr form))) (check-let*-bindings form bindings) (expand-form (annotate (let loop ((lst bindings)) (if (null? lst) `(|.let| () ,@(cddr form)) `(|.let| (,(car lst)) ,(loop (cdr lst))))) form) env)) (syntax-violation (car form) "expected bindings and body" form)))) (define expand-let-values (lambda (form env) (destructuring-match form ((_ bindings body ...) (begin (or (list? bindings) (syntax-violation (car form) "malformed bindings" form)) (and (null? body) (syntax-violation (car form) "expected bindings and body" form)) (or (unique-id-list? (apply append (map (lambda (binding) (destructuring-match binding ((formals init) (collect-lambda-formals formals form)) (_ (syntax-violation (car form) "expected each binding consist of formals and expression" form)))) bindings))) (syntax-violation (car form) "duplicate formals" form)) (let ((init-env env)) (annotate (let loop ((lst bindings) (env env)) (cond ((null? lst) (expand-form `(|.let| () ,@body) env)) (else (destructuring-match (car lst) ((formals init) (let ((vars (collect-lambda-formals formals form))) (let* ((suffix (fresh-rename-count)) (renames (map cons vars (map (lambda (id) (rename-variable-id id suffix)) vars)))) `(|.call-with-values| (lambda () ,(expand-form init init-env)) (lambda ,(rename-lambda-formals formals renames) ,(loop (cdr lst) (extend-env renames env))))))) (_ (scheme-error "internal error: let-values: ~m" form)))))) form)))) (_ (syntax-violation (car form) "expected bindings and body" form))))) (define expand-do (lambda (form env) (destructuring-match form ((_ clauses (test expr ...) body ...) (begin (or (list? clauses) (syntax-violation (car form) "malformed (variable init update)" form clauses)) (let ((temp (generate-temporary-symbol)) (bindings (map (lambda (clause) (destructuring-match clause (((? symbol? var) init . _) (list var init)) (_ (syntax-violation (car form) "malformed (variable init update)" form clause)))) clauses)) (updates (map (lambda (clause) (destructuring-match clause ((var _) var) ((_ _ update) update) (_ (syntax-violation (car form) "malformed (variable init update)" form clause)))) clauses))) (expand-form (annotate `(|.let| ,temp ,bindings (|.if| ,test ,(if (null? expr) `(,_unspecified) `(|.begin| ,@expr)) (|.begin| ,@body (,temp ,@updates)))) form) env)))) (_ (syntax-violation (car form) "expected (variable init update), test, and command" form))))) (define expand-let*-values (lambda (form env) (destructuring-match form ((_ bindings body ...) (begin (or (list? bindings) (syntax-violation (car form) "malformed bindings" form)) (and (null? body) (syntax-violation (car form) "missing body" form)) (expand-form (annotate (let loop ((lst bindings)) (cond ((null? lst) `(|.let| () ,@body)) (else (destructuring-match (car lst) ((formals init) `(,_call-with-values (|.lambda| () ,init) (|.lambda| ,formals ,(loop (cdr lst))))) (_ (syntax-violation (car form) "expected each binding consist of formals and expression" form (car lst))))))) form) env))) (_ (syntax-violation (car form) "expected bindings and body" form))))) (define expand-cond (lambda (form env) (define else? (lambda (id) (denote-else? env id))) (define =>? (lambda (id) (denote-=>? env id))) (define lambda? (lambda (id) (denote-lambda? env id))) (cond ((> (safe-length form) 1) (expand-form (annotate (let loop ((lst (cdr form))) (if (null? lst) `(,_unspecified) (let ((clause (car lst))) (destructuring-match clause (((? else? _) . (? pair? expr)) (if (null? (cdr lst)) `(|.begin| ,@expr) (syntax-violation (car form) "misplaced else" form clause))) ((test (? =>? _) ((? lambda? _) (a) expr ...)) (let ((temp (generate-temporary-symbol))) `(|.let| ((,temp ,test)) (|.if| ,temp (|.let| ((,a ,temp)) ,@expr) ,(loop (cdr lst)))))) ((test (? =>? _) result) (let ((temp (generate-temporary-symbol))) `(|.let| ((,temp ,test)) (|.if| ,temp (,result ,temp) ,(loop (cdr lst)))))) ((test) `(|.or| ,test ,(loop (cdr lst)))) ((test expr ...) `(|.if| ,test (|.begin| ,@expr) ,(loop (cdr lst)))) (_ (syntax-violation (car form) "malformed cond clause" form clause)))))) form) env)) (else (syntax-violation (car form) "expected cond clause" form))))) (define expand-case (lambda (form env) (define else? (lambda (id) (denote-else? env id))) (define =>? (lambda (id) (denote-=>? env id))) (define maplist (lambda (func lst) (cond ((null? lst) '()) (else (cons (func lst) (maplist func (cdr lst))))))) (destructuring-match form ((_ key . (? pair? clauses)) (let ((temp (generate-temporary-symbol))) (expand-form (annotate `(|.let| ((,temp ,key)) (|.cond| ,@(maplist (lambda (lst) (destructuring-match lst ((((? else? _) (? =>? _) expr) more ...) (right-arrow-in-case) (if (null? more) `(|.else| (,expr ,temp)) (syntax-violation (car form) "misplaced else" form (car lst)))) ((((? else? _) . (? pair? expr)) more ...) (if (null? more) `(|.else| ,@expr) (syntax-violation (car form) "misplaced else" form (car lst)))) ((((datum) (? =>? _) expr) _ ...) (right-arrow-in-case) (if (or (symbol? datum) (fixnum? datum) (char? datum) (boolean? datum) (null? datum)) `((,_eq? ,temp ',datum) (,expr ,temp)) `((,_eqv? ,temp ',datum) (,expr ,temp)))) ((((datum) . (? pair? expr)) _ ...) (if (or (symbol? datum) (fixnum? datum) (char? datum) (boolean? datum) (null? datum)) `((,_eq? ,temp ',datum) ,@expr) `((,_eqv? ,temp ',datum) ,@expr))) ((((? list? datum) (? =>? _) expr) _ ...) (right-arrow-in-case) (cond ((null? datum) '(#f)) ((every1 (lambda (e) (or (symbol? e) (fixnum? e) (char? e) (boolean? e) (null? datum))) datum) `((,_memq ,temp ',datum) (,expr ,temp))) (else `((,_memv ,temp ',datum) (,expr ,temp))))) ((((? list? datum) . (? pair? expr)) _ ...) (cond ((null? datum) '(#f)) ((every1 (lambda (e) (or (symbol? e) (fixnum? e) (char? e) (boolean? e) (null? datum))) datum) `((,_memq ,temp ',datum) ,@expr)) (else `((,_memv ,temp ',datum) ,@expr)))) (_ (syntax-violation (car form) "malformed case clause" form (car lst))))) clauses))) form) env))) (_ (syntax-violation (car form) "expected case clause" form))))) (define expand-and (lambda (form env) (annotate `(and ,@(expand-each (cdr form) env)) form))) (define expand-or (lambda (form env) (annotate `(or ,@(expand-each (cdr form) env)) form))) (define desugar-define (lambda (form) (destructuring-match form ((_ (? symbol? _) _) form) ((_ (? symbol? name)) (annotate `(define ,name (,_unspecified)) form)) ((_ ((? symbol? name) . formals)) (begin (collect-lambda-formals (annotate formals form) form) (annotate `(define ,name (|.lambda| ,formals (,_unspecified))) form))) ((_ ((? symbol? name) . formals) . (? pair? body)) (begin (collect-lambda-formals (annotate formals form) form) (annotate `(define ,name (|.lambda| ,formals ,@body)) form))) ((_ (e1 . e2) . _) (syntax-violation (car form) "invalid syntax" form e1)) (_ (let ((len (- (length form) 1))) (case len ((0) (syntax-violation (car form) "expected 1 or 2, but no clause given" form)) ((1 2) (syntax-violation (car form) "expected symbol for first clause" form)) (else (syntax-violation (car form) (format "expected 1 or 2, but ~a clauses given" len) form)))))))) (define expand-identifier-syntax (lambda (form env) (define set!? (lambda (id) (denote-set!? env id))) (destructuring-match form ((_ e) (expand-form (annotate `(|.lambda| (x) (|.syntax-case| x () (id (,_identifier? (|.syntax| id)) (|.syntax| ,e)) ((_ x ...) (|.syntax| (,e x ...))))) form) env)) ((_ (id exp1) (((? set!? _) var val) exp2)) (expand-form (annotate `(|.make-variable-transformer| (|.lambda| (x) (|.syntax-case| x (set!) ((set! ,var ,val) (|.syntax| ,exp2)) ((,id x ...) (|.syntax| (,exp1 x ...))) (,id (,_identifier? (|.syntax| id)) (|.syntax| ,exp1))))) form) env))))) (define expand-assert (lambda (form env) (destructuring-match form ((_ e) (expand-form (annotate `(|.or| ,e (assertion-violation ',(current-top-level-exterior) ,(format "assertion failed in expression ~u" e))) form) env)) (_ (syntax-violation (car form) "expected single expression" form)))))

false

7ce0889bd968013253ac01efac73de0bf5d08750

c369eb130ec92b2f313c55e62c30c68c7e6710ae

/src/ru/mik/tenorequal/top-scores.scm

7e9dfd1a950355609fb636b99ca82025bb8c5f5b

[]

no_license

VyacheslavMik/10-or-equal

80d1e307512e1ed4dbe20011850d79fbd61a022d

adf63d3ddc39c154c3d10b885ea6f72777da0041

refs/heads/master

2020-03-18T11:20:23.717377

2018-05-24T05:31:07

134,665,037

0

null

UTF-8

Scheme

false

1,960

scm

top-scores.scm

(require 'android-defs) (import (srfi 95)) (define-simple-class top-scores-adapter (android.widget.ArrayAdapter) (context ::android.content.Context) ((*init* (context ::android.content.Context) (strings ::string[])) (invoke-special android.widget.ArrayAdapter (this) '*init* context -1 -1 strings) (set! (this):context context)) ((getView (position ::int) (convert-view ::android.view.View) (parent ::android.view.ViewGroup)) ::android.view.View (parameterize ((current-activity context)) (let ((list-layout (android.widget.LinearLayout id: 100)) (list-text (android.widget.TextView TextColor: #0xFF000000))) (list-layout:setLayoutParams (android.widget.AbsListView:LayoutParams android.widget.AbsListView:LayoutParams:WRAP_CONTENT android.widget.AbsListView:LayoutParams:WRAP_CONTENT)) (list-layout:addView list-text) (list-text:setText (as string (invoke-special android.widget.ArrayAdapter (this) 'getItem position))) list-layout)))) (activity topScores (on-create (let ((lst (android.widget.ListView (this) BackgroundColor: (as int #0xFFFAFFE3)))) (let ((top-scores '()) (array #!null)) (let ((top-scores-setting ((getIntent):getStringExtra "top-scores"))) (when top-scores-setting (let ((p (open-input-string top-scores-setting))) (do ((score (read p) (read p))) ((eof-object? score)) (set! top-scores (cons score top-scores)))))) (set! array (string[] length: (length top-scores))) (let ((i 0)) (for-each (lambda (score) (set! (array i) (format "~a: ~a - ~a" (+ i 1) (car score) (cdr score))) (set! i (+ i 1))) (sort top-scores (lambda (l r) (if (= (cdr l) (cdr r)) (string<? (car l) (car r)) (> (cdr l) (cdr r))))))) (lst:setAdapter (top-scores-adapter (this) array))) ((this):setContentView lst))))

false

2d00a67c1fbd7ebc660186865119f1da16648521

d35144c1ad0d53e13a43722a2357fd0aeefe98da

/gl-utils-ply.scm

411027441022744a56b520902d8e39faad5382f4

[ "BSD-3-Clause", "BSD-2-Clause" ]

permissive

AlexCharlton/gl-utils

e86e98796ce46c5f5b98e081e720671a52f38d21

5d31808418c5a9031d62aa12867e136f4254c357

refs/heads/master

2021-01-18T21:34:02.303086

2016-05-04T12:39:10

23,294,015

2

1

null

2016-01-31T15:29:24

2014-08-24T21:56:25

Scheme

UTF-8

Scheme

false

12,747

scm

gl-utils-ply.scm

(module gl-utils-ply (load-ply load-ply-mesh) (import chicken scheme) (use (prefix opengl-glew gl:) gl-utils-core gl-utils-bytevector gl-utils-mesh z3 matchable srfi-42 miscmacros files srfi-1 srfi-13 extras data-structures ports) ;;; Ply (define data-format (make-parameter #f)) (define (type->unsigned-type type) (case type ((char: int8: byte: uchar: uint8: unsigned-byte:) unsigned-byte:) ((short: int16: ushort: uint16: unsigned-short:) unsigned-short:) ((int: int32: integer: integer32: uint: uint32: unsigned-int: unsigned-int32: unsigned-integer: unsigned-integer32:) unsigned-int:))) (define (type->setter type) (case type ((char: int8: byte:) bytevector-u8-set!) ((uchar: uint8: unsigned-byte:) bytevector-s8-set!) ((short: int16:) bytevector-s16-set!) ((ushort: uint16: unsigned-short:) bytevector-u16-set!) ((int: int32: integer: integer32:) bytevector-s32-set!) ((uint: uint32: unsigned-int: unsigned-int32: unsigned-integer: unsigned-integer32:) bytevector-u32-set!) ((float: float32:) bytevector-f32-set!) ((double: float64:) bytevector-f64-set!))) (define (bytes-per-element els) (foldl (lambda (count el) (+ count (type->bytes (second el)))) 0 els)) ;; For ((name type) ...), return ((name b0 b1 b2) ... ) (define (get-bytes els) (let loop ((els els) (result '()) (n 0)) (if (null? els) result (let ((bytes (type->bytes (cadar els)))) (loop (cdr els) (cons (cons (caar els) (list-ec (: i bytes) (+ n i))) result) (+ n bytes)))))) (define (endian-swap?) (or (and (member little-endian: (features)) (equal? (data-format) binary-big-endian:)) (and (member big-endian: (features)) (equal? (data-format) binary-little-endian:)))) (define (binary el spec) (match-let (((name n . vars) el)) (if* (assoc name spec) (let* ((var-bytes (get-bytes vars)) (mapping (concatenate (list-ec (: el (second it)) ((if (endian-swap?) reverse identity) (cdr (assoc el var-bytes)))))) (stride (length mapping)) (buffer (make-bytevector (* n stride)))) (dotimes (vertex n) (let ((bytes (list-ec (: _ (bytes-per-element vars)) (read-byte)))) (for-each (lambda (m i) (bytevector-u8-set! buffer (+ (* vertex stride) i) (list-ref bytes m))) mapping (iota stride)))) buffer) (dotimes (_ (* n (bytes-per-element vars))) (read-byte))))) (define (ascii el spec) (match-let (((name n . vars) el)) (if* (assoc name spec) (let* ((var/type/bytes/i (map (lambda (v i) (list (car v) (second v) (type->bytes (second v)) i)) vars (iota (length vars)))) (elements (map (lambda (el) (assoc el var/type/bytes/i)) (second it))) (mapping (map fourth elements)) (offsets (reverse (let loop ((lst (map third elements)) (accum '()) (count 0)) (if (null? lst) accum (loop (cdr lst) (cons count accum) (+ count (car lst))))))) (setters (map (lambda (el) (type->setter (second el))) elements)) (stride (fold + 0 (map third elements))) (buffer (make-bytevector (* n stride)))) (dotimes (vertex n) (let ((values (list-ec (: _ (length vars)) (read)))) (for-each (lambda (mapping offset setter) (setter buffer (+ (* vertex stride) offset) (list-ref values mapping))) mapping offsets setters))) buffer) (dotimes (_ (* n (length vars))) (read))))) (define n-face-vertices (make-parameter 0)) (define (binary-list el spec) (match-let (((name n (var ('list: list-type type))) el)) (when (> (type->bytes list-type) 1) (error 'load-ply "Face list type must be one byte" list-type)) (if* (assoc name spec) (let* ((buffer #f) (n-bytes (type->bytes type)) (mapping ((if (endian-swap?) reverse identity) (iota n-bytes)))) (dotimes (face n) (let ((n-verts (read-byte))) (if (= (n-face-vertices) 0) (begin (n-face-vertices n-verts) (set! buffer (make-bytevector (* n n-verts n-bytes)))) (when (not (= (n-face-vertices) n-verts)) (error 'load-ply "Number of elements must be constant in face list"))) (dotimes (vertex n-verts) (let ((bytes (list-ec (: b n-bytes) (read-byte)))) (for-each (lambda (byte i) (bytevector-u8-set! buffer (+ (* vertex n-bytes) (* face n-verts n-bytes) i) byte)) bytes mapping))))) buffer) (dotimes (_ n) (let ((n-verts (read-byte))) (if (= (n-face-vertices) 0) (n-face-vertices n-verts) (when (not (= (n-face-vertices) n-verts)) (error 'load-ply "Number of elements must be constant in face list"))) (dotimes (_ (* n-verts (type->bytes type))) (read-byte))))))) (define (ascii-list el spec) (match-let (((name n (var ('list: list-type type))) el)) (if* (assoc name spec) (let* ((buffer #f) (n-bytes (type->bytes type)) (setter (type->setter type))) (dotimes (face n) (let ((n-verts (read))) (if (= (n-face-vertices) 0) (begin (n-face-vertices n-verts) (set! buffer (make-bytevector (* n n-verts n-bytes)))) (when (not (= (n-face-vertices) n-verts)) (error 'load-ply "Number of elements must be constant in face list"))) (dotimes (vertex n-verts) (setter buffer (+ (* vertex n-bytes) (* face n-verts n-bytes)) (read))))) buffer) (dotimes (_ n) (let ((n-verts (read))) (if (= (n-face-vertices) 0) (n-face-vertices n-verts) (when (not (= (n-face-vertices) n-verts)) (error 'load-ply "Number of elements must be constant in face list"))) (dotimes (_ n-verts) (read))))))) (define (get-buffers elements spec) (let ((buffers (list-ec (: el elements) (cons (first el) (if (list? (car (cdaddr el))) (if (equal? (data-format) ascii:) (ascii-list el spec) (binary-list el spec)) (if (equal? (data-format) ascii:) (ascii el spec) (binary el spec))))))) ; Return buffers in order of spec (list-ec (: s spec) (cdr (assoc (car s) buffers))))) (define (check-spec spec elements) (define (err el) (error 'load-ply "buffer-spec does not match ply" el)) (for-each (lambda (s) (if* (assoc (first s) elements) (for-each (lambda (var) (unless (assoc var (cddr it)) (err var))) (if (list? (second s)) (second s) (list (second s)))) (err (first s)))) spec)) (define (load-ply file buffer-spec) (define (err) (error 'load-ply "Not a valid PLY file:" file)) (define (parse-elements) (reverse (map reverse (let loop ((elements '())) (match (string-tokenize (read-line)) (("comment" . rest) (loop elements)) (("element" name n) (loop (cons (list (string->number n) (string->keyword name)) elements))) (("property" "list" list-type type name) (loop (cons (cons (list (string->symbol name) (list list: (string->keyword list-type) (string->keyword type))) (car elements)) (cdr elements)))) (("property" type name) (loop (cons (cons (list (string->symbol name) (string->keyword type)) (car elements)) (cdr elements)))) (("end_header") elements) (other (err))))))) (with-input-from-port (if (equal? (pathname-extension file) "gz") (z3:open-compressed-input-file file) (open-input-file file)) (lambda () (match (read-line) ("ply" #t) (else (err))) (match (string-tokenize (read-line)) (("format" "ascii" version) (data-format #:ascii)) (("format" "binary_little_endian" version) (data-format #:binary-little-endian)) (("format" "binary_big_endian" version) (data-format #:binary-big-endian)) (else (err))) (let ((elements (parse-elements))) (check-spec buffer-spec elements) (values (get-buffers elements buffer-spec) elements))))) (define (verts->primitive verts) (case verts ((1) points:) ((2) lines:) ((3) triangles:) (else (error 'load-ply-mesh "Unsupported number of vertices" verts)))) (define (load-ply-mesh ply #!key vertex face) (define (attribute-vars attribute elements) (let* ((vertices (cddr (assoc vertex: elements))) (type (let loop ((els (cddr attribute)) (type (second (assoc (cadr attribute) vertices)))) (if (null? els) type (if (equal? type (second (assoc (car els) vertices))) (loop (cdr els) type) (error 'load-ply-mesh "Properties of the same attribute must have the same type" attribute)))))) (list (car attribute) type (length (cdr attribute)) normalized: #t))) (let ((buffer-spec `((vertex: ,(flatten (map cdr vertex))) (face: ,face)))) (let-values (((buffers elements) (load-ply ply buffer-spec))) (unless (and (assoc face: elements) (assoc vertex: elements)) (error 'load-ply-mesh "Ply must contain vertex and face elements" ply)) (let* ((face (cdr (assoc face: elements))) (primitive-type (verts->primitive (n-face-vertices))) (element-type (type->unsigned-type (third (cadadr face)))) (attributes (map (lambda (v) (attribute-vars v elements)) vertex))) (make-mesh vertices: `(attributes: ,attributes initial-elements: ,(car buffers)) indices: `(type: ,element-type initial-elements: ,(cadr buffers)) mode: primitive-type))))) )

false

a34e6d317b366a22c071154ac06c25c4ff345bf0

0768e217ef0b48b149e5c9b87f41d772cd9917f1

/sitelib/srfi/64/test-runner.sld

0dca88e0586f47fe57218f547a210d58152f38cf

[ "LicenseRef-scancode-unknown-license-reference", "BSD-2-Clause" ]

permissive

fujita-y/ypsilon

e45c897436e333cf1a1009e13bfef72c3fb3cbe9

62e73643a4fe87458ae100e170bf4721d7a6dd16

refs/heads/master

2023-09-05T00:06:06.525714

2023-01-25T03:56:13

2023-01-25T04:02:59

41,003,666

45

7

BSD-2-Clause

2022-06-25T05:44:49

2015-08-19T00:05:35

Scheme

UTF-8

Scheme

false

211

sld

test-runner.sld

#!nobacktrace (define-library (srfi 64 test-runner) (import (scheme base) (scheme case-lambda) (srfi 1)) (include-library-declarations "test-runner.exports.sld") (include "test-runner.body.scm"))

false

3b887c235bdeb5d7a89f66917bc928c1472c4e00

52ab7b9306b88657adce2547f75f670d0fb0d8cd

/testlib/test-utils.scm

45cc4c9c5665c4cc3b3de3907e97f2ea09e8416b

[]

no_license

torus/gauche-rheingau

e57672f80cf9831b74fc2867c39ff426e13d5f8e

2704d40adfac53c6003135234b9d3cec71fdf2e4

refs/heads/master

2022-06-30T01:01:22.805375

2022-05-30T01:55:18

131,427,814

0

null

2022-05-30T01:55:19

2018-04-28T16:54:50

Scheme

UTF-8

Scheme

false

178

scm

test-utils.scm

(define (assert-equal a b) (test* "equality check" a b)) (define (test-behavior comment proc) (test-section comment) (proc) ) (define (id x) x) (define (fail x) 'fail)

false

74673a408b0312762689f9e87b028b38c613ddcb

b58f908118cbb7f5ce309e2e28d666118370322d

/src/68.scm

60587f3c9c05eddaf33df5662663319efd1c68ac

[ "MIT" ]

permissive

arucil/L99

a9e1b7ad2634850db357f7cc292fa2871997d93d

8b9a3a8e7fb63efb2d13fab62cab2c1254a066d9

refs/heads/master

2021-09-01T08:18:39.029308

2017-12-26T00:37:55

114,847,976

1

0

null

UTF-8

Scheme

false

1,663

scm

68.scm

;;; P68 (load "prelude.scm") ;; a (define (preorder t) (if (null? t) '() (cons (car t) (append (preorder (cadr t)) (preorder (caddr t)))))) (test (preorder '()) '()) (test (preorder '(x () ())) '(x)) (test (preorder '(a (b (d () ()) (e () ())) (c () (f (g () ()) ())))) '(a b d e c f g)) (define (inorder t) (if (null? t) '() (append (inorder (cadr t)) (list (car t)) (inorder (caddr t))))) (test (inorder '()) '()) (test (inorder '(x () ())) '(x)) (test (inorder '(a (b (d () ()) (e () ())) (c () (f (g () ()) ())))) '(d b e a c g f)) ;; c (define (partial-length a b) (let f ([a a] [len 0]) (if (eq? a b) len (f (cdr a) (add1 len))))) (define (pre-in-tree pre in) (let f ([pre pre] [in-beg in] [in-end '()]) (if (eq? in-beg in-end) '() (let ([in-mid (memq (car pre) in-beg)]) (list (car pre) (f (cdr pre) in-beg in-mid) (f (list-tail (cdr pre) (partial-length in-beg in-mid)) (cdr in-mid) in-end)))))) (test (pre-in-tree '(a) '(a)) '(a () ())) (test (pre-in-tree '(a c b d) '(c a d b)) '(a (c () ()) (b (d () ()) ()))) (test (pre-in-tree '(a b d e c f g) '(d b e a c g f)) '(a (b (d () ()) (e () ())) (c () (f (g () ()) ()))))

false

b2e41a9dc1a9f83d7c47dc84a872c5a1e8ee24e9

557c51d080c302a65e6ef37beae7d9b2262d7f53

/workspace/scheme-tester/tests/ncr.scm

29c18ec469c9a3e1a037116b17c7ce0966c30806

[]

no_license

esaliya/SchemeStack

286a18a39d589773d33e628f81a23bcdd0fc667b

dcfa1bbfa63b928a7ea3fc244f305369763678ad

refs/heads/master

2020-12-24T16:24:08.591437

2016-03-08T15:30:37

28,023,003

3

4

null

UTF-8

Scheme

false

1,468

scm

ncr.scm

;;(define recur-ncr ;; (trace-lambda ncr (n r) ;; (cond ;; [(zero? r) 1] ;; [(and (zero? n) (> r 0)) 0] ;; [else (+ (recur-ncr (sub1 n) (sub1 r)) (recur-ncr (sub1 n) r))]))) ;;(define recur-k-ncr ;; (lambda (n r k) ;; (cond ;; [(zero? r) (begin ;; (printf "recur-k: r==0 => n: ~s r: ~s\n" n r) ;; (k 1))] ;; [(and (zero? n) (> r 0)) (begin ;; (printf "recur-k: n==0 => n: ~s r: ~s\n" n r) ;; (k 0))] ;; [else (recur-k-ncr (sub1 n) (sub1 r) (lambda (v) (recur-k-ncr (sub1 n) r (lambda (w) (k (+ v w))))))]))) (define insertf (lambda (ls x) (cond [(null? ls) '()] [else (cons (cons x (car ls)) (insertf (cdr ls) x))]))) (define n->ls (lambda (n) (if (zero? n) '() (if (eq? 1 n) '(1) (cons n (n->ls (sub1 n))))))) (define ls->ls* (lambda (ls) (if (null? ls) '() (cons (list (car ls)) (ls->ls* (cdr ls)))))) (define ncr (lambda (n r) (letrec ([lsncr (lambda (ls r) (cond [(null? ls) '()] [(eq? r 1) (ls->ls* ls)] [else (append (insertf (lsncr (cdr ls) (sub1 r)) (car ls)) (lsncr (cdr ls) r)))])]) (lsncr (n->ls n) r))))

false

59a83629213136ed6c5968912040f2b60164f7cb

30834f7acf1b5f9969e5114f3837e0e05abc171e

/ex3.82.scm

a299299438ac3bfad357f7f4a0364af583894887

[]

no_license

rbarraud/sicp-2

1407a292e2c130ee68fa004f55867383d9a836a3

057c5467d4b638678247ea7b3cdf5f9137debb27

refs/heads/master

2020-12-03T03:41:27.848469

2012-05-20T02:01:47

null

0

null

UTF-8

Scheme

false

4,407

scm

ex3.82.scm

#lang scheme (define-syntax cons-stream (syntax-rules () [(cons-stream x y) (cons x (delay y))])) (define the-empty-stream '()) (define stream-null? null?) (define (stream-ref s n) (if (= n 0) (stream-car s) (stream-ref (stream-cdr s) (- n 1)))) (define (stream-for-each proc s) (if (stream-null? s) 'done (begin (proc (stream-car s)) (stream-for-each proc (stream-cdr s))))) (define (display-stream s) (stream-for-each display-line s)) (define (display-line x) (newline) (display x)) (define (stream-car stream) (car stream)) (define (stream-cdr stream) (force (cdr stream))) (define (stream-enumerate-interval low high) (if (> low high) the-empty-stream (cons-stream low (stream-enumerate-interval (+ low 1) high)))) (define (stream-map proc . argstreams) (if (null? (car argstreams)) the-empty-stream (cons-stream (apply proc (map stream-car argstreams)) (apply stream-map (cons proc (map stream-cdr argstreams)))))) (define (show x) (display-line x) x) (define (add-streams s1 s2) (stream-map + s1 s2)) (define (mul-streams s1 s2) (stream-map * s1 s2)) (define (div-streams s1 s2) (stream-map / s1 s2)) (define (scale-stream stream factor) (stream-map (lambda (x) (* x factor)) stream)) (define ones (cons-stream 1 ones)) (define integers (cons-stream 1 (add-streams ones integers))) (define (take num stream) (if (= num 0) the-empty-stream (cons-stream (stream-car stream) (take (- num 1) (stream-cdr stream))))) (define (stream-filter pred stream) (cond ((stream-null? stream) the-empty-stream) ((pred (stream-car stream)) (cons-stream (stream-car stream) (stream-filter pred (stream-cdr stream)))) (else (stream-filter pred (stream-cdr stream))))) (define (square x) (* x x)) (define (cube x) (* x x x)) (define random-init 0) (define (rand-update x) (modulo (+ (* 132417 x) 141341437) 114329)) (define random-numbers (cons-stream random-init (stream-map rand-update random-numbers))) (define (make-random-numbers init) (define random-numbers (cons-stream init (stream-map rand-update random-numbers))) random-numbers) (define (generator input-stream) (define (inner input rands) (let ((instruction (stream-car input))) (if (null? instruction) the-empty-stream (if (eq? (car instruction) 'generate) (cons-stream (stream-car rands) (inner (stream-cdr input) (stream-cdr rands))) (let ((new-init (cadr instruction))) (inner (stream-cdr input) (make-random-numbers new-init))))))) (inner input-stream (make-random-numbers 0))) (define (monte-carlo experiment-stream passed failed) (define (next passed failed) (cons-stream (/ passed (+ passed failed)) (monte-carlo (stream-cdr experiment-stream) passed failed))) (if (stream-car experiment-stream) (next (+ passed 1) failed) (next passed (+ failed 1)))) ; Thanks http://wqzhang.wordpress.com/2009/09/10/sicp-exercise-3-82/ ! ; I'm not sure if this works very well though... (define (random-numbers-in-range low high init) (define random-max 12344) (define random-numbers (cons-stream init (stream-map rand-update random-numbers))) (define (rand-update x) (let ((a (expt 2 32)) (c 1103515245) (m 12345)) (modulo (+ (* a x) c) m))) (let ((range (- high low))) (stream-map (lambda (x) (+ low (* range (/ x random-max)))) random-numbers))) ;(display-stream (take 10 (random-numbers-in-range 0 10 0))) (define (estimate-integral P x1 x2 y1 y2) (let ((area (* (- x2 x1) (- y2 y1)))) (let ((points (stream-map cons (random-numbers-in-range x1 x2 80085) (random-numbers-in-range y1 y2 1337)))) (scale-stream (monte-carlo (stream-map P points) 0 0) area)))) (define (in-unit-circle? point) (let ((x (car point)) (y (cdr point))) (<= (+ (* x x) (* y y)) 1))) (define estimate-pi (estimate-integral in-unit-circle? -1.0 1.0 -1.0 1.0)) ;(display-stream (take 100 (estimate-pi))) (stream-ref estimate-pi 100000)

true

96b0342b26b53afafefecf7c3009d43c9f05d75d

f08220a13ec5095557a3132d563a152e718c412f

/logrotate/skel/usr/share/guile/2.0/language/elisp/runtime/function-slot.scm

896e3cece35969a49ad0f5c1b7c65aab7deb673a

[ "Apache-2.0" ]

permissive

sroettger/35c3ctf_chals

f9808c060da8bf2731e98b559babd4bf698244ac

3d64486e6adddb3a3f3d2c041242b88b50abdb8d

refs/heads/master

2020-04-16T07:02:50.739155

2020-01-15T13:50:29

165,371,623

15

5

Apache-2.0

2020-01-18T11:19:05

2019-01-12T09:47:33

Python

UTF-8

Scheme

false

4,703

scm

function-slot.scm

;;; Guile Emacs Lisp ;;; Copyright (C) 2009, 2010 Free Software Foundation, Inc. ;;; ;;; This library is free software; you can redistribute it and/or ;;; modify it under the terms of the GNU Lesser General Public ;;; License as published by the Free Software Foundation; either ;;; version 3 of the License, or (at your option) any later version. ;;; ;;; This library is distributed in the hope that it will be useful, ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;;; Lesser General Public License for more details. ;;; ;;; You should have received a copy of the GNU Lesser General Public ;;; License along with this library; if not, write to the Free Software ;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA (define-module (language elisp runtime function-slot) #:use-module (language elisp runtime subrs) #:use-module ((language elisp runtime macros) #:select ((macro-lambda . lambda) (macro-prog1 . prog1) (macro-prog2 . prog2) (macro-when . when) (macro-unless . unless) (macro-cond . cond) (macro-and . and) (macro-or . or) (macro-dotimes . dotimes) (macro-dolist . dolist) (macro-catch . catch) (macro-unwind-protect . unwind-protect) (macro-pop . pop) (macro-push . push))) #:use-module ((language elisp compile-tree-il) #:select ((compile-progn . progn) (compile-if . if) (compile-defconst . defconst) (compile-defvar . defvar) (compile-setq . setq) (compile-let . let) (compile-lexical-let . lexical-let) (compile-flet . flet) (compile-let* . let*) (compile-lexical-let* . lexical-let*) (compile-flet* . flet*) (compile-with-always-lexical . with-always-lexical) (compile-guile-ref . guile-ref) (compile-guile-primitive . guile-primitive) (compile-while . while) (compile-function . function) (compile-defun . defun) (compile-defmacro . defmacro) (#{compile-`}# . #{`}#) (compile-quote . quote))) #:duplicates (last) ;; special operators #:re-export (progn if defconst defvar setq let lexical-let flet let* lexical-let* flet* with-always-lexical guile-ref guile-primitive while function defun defmacro #{`}# quote) ;; macros #:re-export (lambda prog1 prog2 when unless cond and or dotimes dolist catch unwind-protect pop push) ;; functions #:re-export (eq equal floatp integerp numberp wholenump zerop = /= < <= > >= max min abs float 1+ 1- + - * % ffloor fceiling ftruncate fround consp atomp listp nlistp null car cdr car-safe cdr-safe nth nthcdr length cons list make-list append reverse copy-tree number-sequence setcar setcdr symbol-value symbol-function set fset makunbound fmakunbound boundp fboundp apply funcall throw not eval load))

false

6568fdaedfbad4ea8aa5ecd85e16ec6270690c93

2bcf33718a53f5a938fd82bd0d484a423ff308d3

/programming/sicp/ch3/ex-3.72.scm

0f7e34aa6d66c3e165f70368608150fc49f35844

[]

no_license

prurph/teach-yourself-cs

50e598a0c781d79ff294434db0430f7f2c12ff53

4ce98ebab5a905ea1808b8785949ecb52eee0736

refs/heads/main

2023-08-30T06:28:22.247659

2021-10-17T18:27:26

345,412,092

0

null

UTF-8

Scheme

false

1,209

scm

ex-3.72.scm

#lang sicp (#%require "stream.scm") (#%require "ex-3.70.scm") ; weighted-pairs ;; https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-24.html#%_thm_3.72 ;; Construct a stream of all numbers that can be written as the sum of two ;; squares in three different ways by weighting a stream of integer pairs by ;; the sum of their squares, then looking for three entries in a row with the ;; same sum of squares. (define (sum-of-two-squares-three-ways) (define (sum-of-squares pair) (let ((i (car pair)) (j (cadr pair))) (+ (* i i) (* j j)))) (define (go s) (let ((i (stream-car s)) (j (stream-car (stream-cdr s))) (k (stream-car (stream-cdr (stream-cdr s))))) (if (= (sum-of-squares i) (sum-of-squares j) (sum-of-squares k)) (cons-stream (list (sum-of-squares i) i j k) (go (stream-cdr s))) (go (stream-cdr s))))) (go (weighted-pairs integers integers sum-of-squares))) (display-stream-next (sum-of-two-squares-three-ways) 5) ;; (325 (1 18) (6 17) (10 15)) ;; (425 (5 20) (8 19) (13 16)) ;; (650 (5 25) (11 23) (17 19)) ;; (725 (7 26) (10 25) (14 23)) ;; (845 (2 29) (13 26) (19 22))

false

e08e40c95534397227bee959660dc9a3b1837f86

01a7d3740477d33d84a574a909571d0128b31e43

/c21-prims-test.scm

8f76fda19e8841d07a0c243a3de79418312573cb

[]

no_license

propella/3imp-westwood

7a19f2113555d7d531d6a6acd087f96fb9eb93d4

9c7912ac1b2596e62dc7736d10ef73362296c001

refs/heads/master

2021-01-23T13:23:04.505262

2010-01-12T19:51:58

456,584

1

0

null

UTF-8

Scheme

false

740

scm

c21-prims-test.scm

#!/usr/bin/env gosh (require "./check") (require "./c21-prims") ;; The rec syntctic form allows the creation of self-recursive ;; closures. (p25) (srfi-31) (check ((rec count (lambda (x) (if (null? x) 0 (+ (count (cdr x)) 1)))) '(1 2 3 4 5)) => 5) (check (recur count ([x '(a b c d e)]) (if (null? x) 0 (+ (count (cdr x)) 1))) => 5) (check (record (x y) '(3 4) (+ x y)) => 7) (check (record (a b c) '(1 2 3) (list c b a)) => '(3 2 1)) (define calc (lambda (x) (if (integer? x) x (record-case x (add (x y) (+ (calc x) (calc y))) (mul (x y) (* (calc x) (calc y))) (neg (x) (- 0 (calc x))) (else (error "invalid expression")))))) (check (calc '(neg (mul (add 3 4) 6))) => -42)

false

26cdbb36b38a16e385c0d8ece347c234ff6b0e70

ffb2e7c6951bb43c61fb5142c94f95f8b2ed5ffa

/Assignment 12/parser.ss

2c2e4632056caaf2b45575694e4198fb89760be1

[]

no_license

shahdk/SchemeInterpreter

6dd97d9ddf085947876eb569aab953c0dc1fef50

8a2035e658e862ab3c185fe362c2dd62ca46950a

refs/heads/master

2021-01-10T19:51:02.159237

2014-06-12T01:04:44

null

0

null

UTF-8

Scheme

false

7,543

ss

parser.ss

(define scheme-value? (lambda (v) #t)) (define list-of (lambda (pred . l) (let ((all-preds (cons pred l))) (lambda (obj) #t)))) ;(let loop ((obj obj) (preds '())) ;(or ;(and (null? obj) (null? preds)) ;(if (null? preds) ;(loop obj all-preds) ;(and (pair? obj) ;((car preds) (car obj)) ;(loop (cdr obj) (cdr preds)))))))))) (define expression? (lambda (exp) (if (or (null? exp) (null? (car exp))) #t (cond ((equal? (car exp) 'lit-exp) (scheme-value? (cadr exp))) ((equal? (car exp)'var-exp) ((lambda (v) (or (symbol? v) (eqv? 'sys-var (car v)))) (cadr exp))) ((equal? (car exp)'lambda-exp) (and ((lambda (var) (or ((list-of symbol?) var) (pair? var) (symbol? var))) (cadr exp)) (expression? (caddr exp)))) ((equal? (car exp)'app-exp) (and (expression? (cadr exp)) ((list-of expression?) (caddr exp)))) ((equal? (car exp)'if-exp) (and (expression? (cadr exp)) (expression? (caddr exp)) (expression? (car (cdddr exp))))) ((equal? (car exp)'let-exp) (and ((list-of symbol?) (cadr exp)) ((list-of expression?) (caddr exp)) (expression? (car (cdddr exp))))) ((equal? (car exp)'named-let-exp) (name symbol?) (symbols (list-of symbol?)) (values (list-of expression?)) (body expression?)) ((equal? (car exp)'letrec-exp) (symbols (list-of symbol?)) (values (list-of expression?)) (body expression?)) ((equal? (car exp)'let*-exp) (symbols (list-of symbol?)) (values (list-of expression?)) (body expression?)) ((equal? (car exp)'set!-exp) (var symbol?) (value expression?)) ((equal? (car exp)'begin-exp) ((list-of expression?) (cadr exp))) ((equal? (car exp)'while-exp) (and (expression? (cadr exp)) (expression? (caddr exp)))) ((equal? (car exp)'and-exp) ((list-of expression?) (cadr exp))) ((equal? (car exp)'or-exp) ((list-of expression?) (cadr exp))) ((equal? (car exp)'cond-exp) ((list-of (lambda (cd) (and (or (expression? (car cd)) (scheme-value? (car cd))) (expression? (cadr cd))))) (cadr exp))) ((equal? (car exp)'case-exp) (and (expression? (cadr exp)) ((list-of (lambda (cd) (and ((list-of expression?) (car cd)) (expression? (cadr cd))))) (caddr exp)))) ((equal? (car exp)'define-exp) (and (symbol? (cadr exp)) (expression? (caddr exp)))) (else #f))))) (define param-list (lambda (args) (cond [(null? args) '()] [(atom? args) (cons 'variable (list args))] [(list? args) (if (atom? (car args)) (append (list (car args)) (param-list (cdr args))) (if (list? (car args)) (append (list (car args)) (param-list (cdr args))) (append (param-list (car args)) (param-list (cdr args)))))] [else (cons 'improper (list (improper->proper args)))]))) (define valid? (lambda (args) (cond [(null? args) #t] [else (and (isvalid (car args)) (valid? (cdr args)))]))) (define isvalid (lambda (arg) (cond [(null? arg) #t] [(not (list? arg)) #f] [(number? (car arg)) #f] [(null? (cdr arg)) #f] [(not (null? (cddr arg))) #f] [else #t]))) (define parse-expression (lambda (datum) (cond [(null? datum) (list 'lit-exp datum)] [(symbol? datum) (list 'var-exp datum)] [(number? datum) (list 'lit-exp datum)] [(string? datum) (list 'lit-exp datum)] [(boolean? datum) (list 'lit-exp datum)] [(vector? datum) (list 'lit-exp datum)] [(pair? datum) (cond [(eq? (car datum) 'quote) (list 'lit-exp (cadr datum))] [(equal? (car datum) 'lambda) (list 'lambda-exp (param-list (cadr datum)) (if (= (length (cddr datum)) 1) (parse-expression (caddr datum)) (list 'begin-exp (map parse-expression (cddr datum)))))] [(equal? (car datum) 'set!) (list 'set!-exp (cadr datum) (parse-expression (caddr datum)))] [(equal? (car datum) 'letrec) (if (valid? (cadr datum)) (list 'letrec-exp (map car (cadr datum)) (map parse-expression (map cadr (cadr datum))) (list 'begin-exp (map parse-expression (cddr datum)))) '())] [(equal? (car datum) 'let*) (if (valid? (cadr datum)) (list 'let*-exp (map car (cadr datum)) (map parse-expression (map cadr (cadr datum))) (list 'begin-exp (map parse-expression (cddr datum)))) '())] [(equal? (car datum) 'let) (if (list? (cadr datum)) (if (or (valid? (cadr datum)) #t) (list 'let-exp (map car (cadr datum)) (map parse-expression (map cadr (cadr datum))) (list 'begin-exp (map parse-expression (cddr datum)))) '()) (list 'named-let-exp (cadr datum) (map car (caddr datum)) (map parse-expression (map cadr (caddr datum))) (list 'begin-exp (map parse-expression (cdddr datum)))))] [(equal? (car datum) 'if) (list 'if-exp (parse-expression (cadr datum)) (parse-expression (caddr datum)) (if (null? (cdddr datum)) '() (parse-expression (car (cdddr datum)))))] [(equal? (car datum) 'begin) (list 'begin-exp (map parse-expression (cdr datum)))] [(equal? (car datum) 'while) (list 'while-exp (parse-expression (cadr datum)) (list 'begin-exp (map parse-expression (cddr datum))))] [(equal? (car datum) 'and) (list 'and-exp (map parse-expression (cdr datum)))] [(equal? (car datum) 'or) (list 'or-exp (map parse-expression (cdr datum)))] [(equal? (car datum) 'cond) (list 'cond-exp (map cd-lambda (cdr datum)))] [(equal? (car datum) 'case) (list 'case-exp (parse-expression (cadr datum)) (map (lambda (ls) (list (if (equal? 'else (car ls)) (list (parse-expression (cadr datum))) (if (atom? (car ls)) (list 'lit-exp (car ls)) (map parse-expression (car ls)))) (parse-expression (cadr ls)))) (cddr datum)))] [(equal? (car datum) 'define) (list 'define-exp (cadr datum) (parse-expression (caddr datum)))] [else (if (not (list? (cdr datum))) '(()) (list 'app-exp (parse-expression (car datum)) (if (null? (cdr datum)) '(()) (map parse-expression (cdr datum)))))])]))) (define valid-clause? (lambda (ls) (cond [(null? ls) #t] [(not (eq? (length (car ls)) 2)) #f] [(and (equal? 'else (caar ls)) (not (null? (cdr ls)))) #f] [else (valid-clause? (cdr ls))]))) (define cd-lambda (lambda (ls) (list (if (equal? 'else (car ls)) (list 'lit-exp '#t) (parse-expression (car ls))) (parse-expression (cadr ls)))))

false

8029a10e08b78e7d44648c28907a9334ba7becfa

5eb631d9a0885a550b709c6e9f905066f6af531b

/ex/chap2/35.scm

65afe67f72e3aeb460f6154bb9613aa5567c16df

[]

no_license

hanpum/sicp

344cb6456daf2c2f6b002aa20dc3e177c34b18bd

454efaf28ee0f0487e372ede28f452eb762de404

refs/heads/master

2023-06-09T08:11:55.080048

2021-06-29T00:01:49

381,190,193

0

null

UTF-8

Scheme

false

597

scm

35.scm

(load "utils") (define (count-leaves tree) (cond ((null? tree) 0) ((not (pair? tree)) 1) (else (+ (count-leaves (car tree)) (count-leaves (cdr tree)))))) ;; count tree leaves with accumulate (define (count-leaves2 tree) (accumulate + 0 (map (lambda (sub-tree) (cond ((null? sub-tree) 0) ((not-pair? sub-tree) 1) (else (count-leaves2 sub-tree)))) tree))) (println "~%begin testing of 35") (define tree (list '(1 2) (list 3 4) 5 6)) (println "count-leaves of ~S: ~S" tree (count-leaves tree)) (println "count-leaves2 of ~S: ~S" tree (count-leaves2 tree))

false