From 0928cc068fac5d3426a54b94639efdd01628067a Mon Sep 17 00:00:00 2001
From: AlexKnauth <alexander@knauth.org>
Date: Tue, 7 Jul 2015 10:23:53 -0400
Subject: [PATCH] export and document lens-view*, lens-set*, and
 lens-transform*

---
 info.rkt                  |  2 +-
 lens/core/transform.scrbl | 11 +++++++++++
 lens/core/view-set.rkt    | 19 +++++++++++++++++++
 lens/core/view-set.scrbl  | 23 +++++++++++++++++++++++
 lens/main.rkt             |  3 ---
 5 files changed, 54 insertions(+), 4 deletions(-)

diff --git a/info.rkt b/info.rkt
index 7d9ba04..1b34063 100644
--- a/info.rkt
+++ b/info.rkt
@@ -3,7 +3,7 @@
 (define collection 'multi)
 
 
-(define version 0.2)
+(define version "0.3")
 
 
 (define deps
diff --git a/lens/core/transform.scrbl b/lens/core/transform.scrbl
index 317c18f..e1e64aa 100644
--- a/lens/core/transform.scrbl
+++ b/lens/core/transform.scrbl
@@ -22,3 +22,14 @@
   @lenses-examples[
     (lens-transform first-lens number->string '(1 2 3))
 ]}
+
+@defproc[(lens-transform* [target target/c] [lens lens?] [transformer (-> view/c view/c)] ... ...)
+         target/c]{
+  Like @racket[lens-transform], except that it can take multiple
+  lenses-transformer pairs in the same way as @racket[lens-set*], and
+  the argument order is switched in the same way.
+  @lenses-examples[
+    (lens-transform* '(1 2 3 4 5)
+                     first-lens number->string
+                     third-lens (λ (x) (* 100 x)))
+]}
diff --git a/lens/core/view-set.rkt b/lens/core/view-set.rkt
index 2f54660..b5a55ff 100644
--- a/lens/core/view-set.rkt
+++ b/lens/core/view-set.rkt
@@ -3,6 +3,8 @@
 (require unstable/sequence
          fancy-app
          "base.rkt")
+(module+ test
+  (require rackunit))
 
 (provide lens-view
          lens-set
@@ -30,3 +32,20 @@
   (for/fold ([v v]) ([lens/x (in-slice 2 lenses/xs)])
     (match-define (list lens x) lens/x)
     (lens-set lens v x)))
+
+(module+ test
+  (define (set-first l v)
+    (list* v (rest l)))
+  (define (set-second l v)
+    (list* (first l) v (rest (rest l))))
+  (define first-lens (make-lens first set-first))
+  (define second-lens (make-lens second set-second))
+  (check-equal? (lens-view first-lens '(1 2 3)) 1)
+  (check-equal? (lens-set first-lens '(1 2 3) 'a) '(a 2 3))
+  (check-equal? (lens-view* '((1 2) 3) first-lens second-lens)
+                2)
+  (check-equal? (lens-set* '(1 2 3)
+                           first-lens 10
+                           second-lens 20)
+                '(10 20 3))
+  )
diff --git a/lens/core/view-set.scrbl b/lens/core/view-set.scrbl
index 2098333..c847089 100644
--- a/lens/core/view-set.scrbl
+++ b/lens/core/view-set.scrbl
@@ -22,3 +22,26 @@
   @lenses-examples[
     (lens-set first-lens '(1 2 3) 'a)
 ]}
+
+@defproc[(lens-view* [target target/c] [lens lens?] ...) view/c]{
+  Like @racket[lens-view], except that it can take multiple lenses,
+  which are combined into a nested lens. The argument order is
+  switched, so that the @racket[target] comes first and the
+  @racket[lens] arguments come after it.
+  @racket[(lens-view* target lens ...)] produces the same value as
+  @racket[(lens-view (lens-thrush lens ...) target)], but can be more
+  efficient.
+  @lenses-examples[
+    (lens-view* '(a b ((c d) e f) g) third-lens first-lens second-lens)
+]}
+
+@defproc[(lens-set* [target target/c] [lens lens?] [new-view view/c] ... ...) target/c]{
+  Like @racket[lens-set], except that it can take multiple
+  lenses-value pairs. Like @racket[lens-view*], the argument order is
+  switched, so that the @racket[target] comes first and the lens-value
+  pairs come after it. @racket[lens-set*] is analogous to @racket[hash-set*].
+  @lenses-examples[
+    (lens-set* '(1 2 3 4 5)
+               first-lens 10
+               third-lens 300)
+]}
diff --git a/lens/main.rkt b/lens/main.rkt
index 62060da..ef585d9 100644
--- a/lens/main.rkt
+++ b/lens/main.rkt
@@ -15,9 +15,6 @@
    "syntax-keyword.rkt")
   focus-lens
   drop-lens
-  lens-set*
-  lens-transform*
-  lens-view*
   list-ref-nested-lens
   take-lens
   use-applicable-lenses!))