T>Замечательный аргумент.

map f (xs ++ ys) = map f xs ++ map f ys

(define sum (match-lambda
    ((list) 0)
    ((list h t ...) (+ h (sum t)))))

myIf :: Bool -> a -> a -> a
myIf True  thenA elseA = thenA
myIf False thenA elseA = elseA

#lang scheme
(require srfi/41)
(stream-car (stream-map sqrt
                        (stream-append (stream 1 2 3)
                                       (stream -1 -2 -3))))
(stream-car (stream-append (stream-map sqrt (stream 1 2 3))
                           (stream-map sqrt (stream -1 -2 -3))))

(This particular problem would go away if streams were redesigned to delay
evaluation of the head as well as delaying evaluation of the tail. However, the
theorem would still not be true, as can be seen by replacing
(enumerate- i nt erval -42 -7) by (bottom), where evaluation of (bottom)
enters an infinite loop.)

T>А он про это и говорит.

It is particularly annoying that two very similar types — lists and streams — must be
Philip Wader Why Caicuiating is Better than Scheming 20
treated differently. Thus, one needs sum to find the sum of a list of numbers, and
sum-stream to find the sum of a stream of numbers.

#lang scheme
(match '((1 2) (3 4) (5 6))
((list (list a b) ...) (list a b)))

;;; Code written by Oleg Kiselyov
;;; (http://pobox.com/~oleg/ftp/)
;;;
;;; Taken from leanTAP.scm
;;; http://kanren.cvs.sourceforge.net/kanren/kanren/mini/leanTAP.scm?view=log

; A simple linear pattern matcher
; It is efficient (generates code at macro-expansion time) and simple:
; it should work on any R5RS Scheme system.

; (pmatch exp <clause> ...[<else-clause>])
; <clause> ::= (<pattern> <guard> exp ...)
; <else-clause> ::= (else exp ...)
; <guard> ::= boolean exp | ()
; <pattern> :: =
;        ,var  -- matches always and binds the var
;                 pattern must be linear! No check is done
;         _    -- matches always
;        'exp  -- comparison with exp (using equal?)
;        exp   -- comparison with exp (using equal?)
;        (<pattern1> <pattern2> ...) -- matches the list of patterns
;        (<pattern1> . <pattern2>)  -- ditto
;        ()    -- matches the empty list

(define-syntax pmatch
  (syntax-rules ()
    ((_ exp clause ...)
     (let ((val-to-match exp))
       (pmatch* val-to-match clause ...)))))

(define match-failure
  (lambda (val)
    (error 'match-failure "failed match ~s\n" val)))

(define-syntax pmatch*
  (syntax-rules (else)
    ((_ val (else exp ...))
     (let () exp ...))
    ((_ val)
     (match-failure val))
    ((_ val (pattern () exp0 exp ...) . clauses)
     (let ((fail (lambda () (pmatch* val . clauses))))
                                        ; note that match-pattern may do binding. Here,
                                        ; other clauses are outside of these binding
       (match-pattern val pattern (let () exp0 exp ...) (fail))))
    ((_ val (pattern guard exp0 exp ...) . clauses)
     (let ((fail (lambda () (pmatch* val . clauses))))
       (match-pattern val pattern
                      (if guard (let () exp0 exp ...) (fail))
                      (fail))))))

; (match-pattern val pattern kt kf)
(define-syntax match-pattern
  (syntax-rules (_ quote unquote)
    ((_ val _ kt kf) kt)
    ((_ val () kt kf)
     (if (null? val) kt kf))
    ((_ val (quote lit) kt kf)
     (if (equal? val (quote lit)) kt kf))
    ((_ val (unquote var) kt kf)
     (let ((var val)) kt))
    ((_ val (x . y) kt kf)
     (if (pair? val)
         (let ((valx (car val))
               (valy (cdr val)))
           (match-pattern valx x
                          (match-pattern valy y kt kf)
                          kf))
         kf))
    ((_ val lit kt kf)
     (if (equal? val (quote lit)) kt kf))))

#lang scheme
(match '((1 2) (3 4) (5 6))
  ((list (list a b) ...)  и т.п.

Есть полновесная имплементация scheme, но в ней нет cond (другой вариант — if или short-circuit-логические операции). Сделай cond, неотличимый от того, что прописан в стандарте.

Есть полновесная имплементация хаскеля но в ней нет let (или where — на твой выбор). Сделай let (ну или where), неотличимый от того, что прописан в репорте.

Instructors who would prefer that their students use a strongly-typed language such as ML or OCAML will find that the algorithms in the book are easy to rewrite in such a language. We have added to Scheme a new special form, define-datatype, that is very similar to ML's datatype or OCAML's type. With the use of our matching form, cases, the programs are structured much as they would be in ML or OCAML.

We rely on a Scheme-based parser generator, SLLGEN. It should be straightforward to port our lexical and grammatical specifications to an ML-based parser generator such as mllex/mlyacc or to ocamllex/ocamlyacc, or to write the parsers by hand

T>То есть, критика Вадлера всё-таки подействовала.

    SICP:                          HTDP:  
primality                      moving circles     
interval arithmetic            hangman            
symbolic differentiation       moving shapes      
representing sets              moving pictures    
huffman encoding trees         rearranging words  
symbolic algebra               binary search trees
digital circuits               evaluating scheme  
                               more on web pages            
                               evaluating scheme again      
                               moving pictures, again       
                               mathematical examples        
                               Gaussian elimination         
normal/applicative order       checking (on) queens         
strictness/laziness            accumulators on trees        
non-determinism                missionaries and cannibals   
logic programming              board solitaire              
register machines              exploring places             
compilers                      moving pictures, a last time

         Fig.1.  SICP and HTDP exercises

f "^\\d+$" = doSomething1
f "^\\w+$" = doSomething2

MC>f "^\\d+$" = doSomething1
MC>f "^\\w+$" = doSomething2
MC>

{-# LANGUAGE ViewPatterns, PatternGuards #-}

data Match = M [String] | F -- match or failure.

type REString = String

re :: REString -> String -> Match
re re string = M [re,string] -- должно быть что-то из regexp, что в ghc

f (re "something" -> M []) = "do something"
-- try f "really nothing".
f (re "nothing" -> M ["nothing","really nothing"]) = "do nothing"
f _ = "huh?"

-- Второй вариант:
g string
    | M [] <- re "something" = "do something"
    | m ["nothing","really nothing"] <- re "nothing" = "do nothing"
    | _ = "huh?"

getPart (ValueArr arr) ((Right index):path)
    | Just value <- lookup index arr = getPart value path
    | otherwise = dummyValue

MC>f "^\\d+$" = doSomething1
MC>f "^\\w+$" = doSomething2
MC>

f x | x =~ "^\\d+$" = doSomething1
    | x =~ "^\\w+$" = doSomething2

* type errors in SML are difficult
* type errors in Soft Scheme are pure torture
* explaining type errors in Soft Scheme remains for PhD-level experts