Merge remote-tracking branch 'origin/dev' into HEAD

afilter.rkt

@@ -0,0 +1,13 @@
+#lang racket/base
+
+(provide afilter it)
+(require anaphoric/it
+         racket/stxparam
+         (for-syntax racket/base))
+
+(define-syntax-rule (afilter body lst)
+  (let ([func
+         (λ (var)
+           (syntax-parameterize ([it (make-rename-transformer #'var)])
+             body))])
+    (filter func lst)))

amap.rkt

@@ -0,0 +1,13 @@
+#lang racket/base
+
+(provide amap it)
+(require anaphoric/it
+         racket/stxparam
+         (for-syntax racket/base))
+
+(define-syntax-rule (amap body lst)
+  (let ([func
+         (λ (var)
+           (syntax-parameterize ([it (make-rename-transformer #'var)])
+             body))])
+    (map func lst)))

scribblings/anaphoric.scrbl

@@ -2,7 +2,7 @@
 @require[@for-label[anaphoric
                     racket/base]]
 
-@title{Anaphoric conditionals}
+@title{Anaphoric macros}
 @author[@author+email["Suzanne Soy" "racket@suzanne.soy"]]
 
 @defmodule[anaphoric]
@@ -10,7 +10,7 @@
 @section{Overview}
 
 This package provides anaphoric versions of @racket[if], 
-@racket[when] and @racket[cond]. These bind the syntax
+@racket[when], @racket[cond], @racket[map], and @racket[filter]. These bind the syntax
 parameter @racket[it] to the value produced by the
 condition expression. 
 
@@ -155,3 +155,30 @@ using @racket[it].
  @racket[conditionᵢ] is successful.
 }
 
+@section{Anaphoric map and filter}
+
+@defform[(amap body lst)]{
+ Anaphoric @racket[map]. Binds the syntax parameter @racket[it]
+ in the @racketid[body], and maps it over the list @racketid[lst]. Effectively the same
+ as wrapping the @racketid[body] in a @racket[lambda] with an @racket[it] parameter. Unlike @racket[map], @racket[amap]
+ only works on a single list.
+
+ @racket[amap] works with nested function calls:
+
+  @racketblock[(amap (string-append (string-upcase it) "!")
+                     '("apple" "banana"))]
+
+ The syntax parameter @racket[it] may be used multiple times in the procedure:
+
+  @racketblock[(amap (* it it) '(1 2 3))]
+}
+
+@defform[(afilter body lst)]{
+ Anaphoric @racket[filter]. Binds the syntax parameter @racket[it]
+ in the @racketid[body], and filters the list @racketid[lst] using it. Effectively the same
+ as wrapping the body in a @racket[lambda] with an @racket[it] parameter.
+
+ @racket[afilter] works with nested function calls:
+
+  @racketblock[(afilter ((* it it) . > . 50) lst)]
+}

test/afilter-test.rkt

@@ -0,0 +1,29 @@
+#lang racket/base
+
+(require anaphoric/afilter
+         rackunit)
+
+(define lst '(5 6 7 8 9))
+
+(check-equal?
+ '(6 8)
+ (afilter (odd? (add1 it)) lst)
+ "Nested function call.")
+
+(check-equal?
+ '(8 9)
+ (afilter ((* it it) . > . 50) lst)
+ "Multiple 'it' in a nested expression.")
+
+(define (f lst)
+  (afilter (/ it 0) lst))
+
+(check-equal?
+ '()
+ (f '())
+ "Empty list.")
+
+(check-exn
+   exn:fail?
+   (lambda () (f '(1)))
+   "To get 100% code coverage for the f function.")

test/amap-test.rkt

@@ -0,0 +1,27 @@
+#lang racket/base
+
+(require anaphoric/amap
+         rackunit)
+
+(check-equal?
+ '(2 3)
+ (amap (add1 it) '(1 2))
+ "Sanity check.")
+
+(check-equal?
+ '("2" "4")
+ (amap (number->string (+ it it)) '(1 2))
+ "Multiple 'it' in a nested expression.")
+
+(define (f lst)
+  (amap (/ it 0) lst))
+
+(check-equal?
+ '()
+ (f '())
+ "Empty list.")
+
+(check-exn
+   exn:fail?
+   (lambda () (f '(1)))
+   "To get 100% code coverage for the f function.")