suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved unstable/cce/values to unstable/values.

Browse Source
This commit is contained in:
Carl Eastlund 2010-05-29 11:52:34 -04:00
parent a22a1a4c15
commit 14b2daab66
7 changed files with 73 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
collects/tests/unstable/values.rkt Normal file
View File

@ -0,0 +1,60 @@
#lang racket
(require rackunit rackunit/text-ui unstable/values "helpers.rkt")
(run-tests
(test-suite "values.ss"
(test-suite "map2"
(test-case "numerator and denominator"
(let*-values ([(ns ds)
(map2
(lambda (r)
(values (numerator r) (denominator r)))
(list 1/2 3/4 5/6))])
(check-equal? (list ns ds) (list '(1 3 5) '(2 4 6))))))
(test-suite "map/values"
(test-case "complex numerator and denominator"
(let*-values ([(rns rds ins ids)
(map/values
4
(lambda (c)
(values (numerator (real-part c))
(denominator (real-part c))
(numerator (imag-part c))
(denominator (imag-part c))))
(list 1/2+3/4i 5/6+7/8i))])
(check-equal? (list rns rds ins ids)
(list '(1 5) '(2 6) '(3 7) '(4 8)))))
(test-case "multiple lists"
(let*-values ([(as bs cs)
(map/values 3 values '(1 2 3) '(4 5 6) '(7 8 9))])
(check-equal? as '(1 2 3))
(check-equal? bs '(4 5 6))
(check-equal? cs '(7 8 9)))))
(test-suite "foldl/values"
(test-case "sum, product, and last"
(let*-values ([(sum prod last)
(foldl/values
(lambda (next sum prod last)
(values (+ next sum)
(* next prod)
next))
(list 0 1 #f)
(list 1 2 3 4))])
(check-equal? (list sum prod last)
(list 10 24 4)))))
(test-suite "foldr/values"
(test-case "sum, product, and last"
(let*-values ([(sum prod last)
(foldr/values
(lambda (next sum prod last)
(values (+ next sum)
(* next prod)
next))
(list 0 1 #f)
(list 1 2 3 4))])
(check-equal? (list sum prod last)
(list 10 24 1)))))
(test-suite "values->list"
(test-case "1 2 3 4"
(check-equal? (values->list (values 1 2 3 4)) (list 1 2 3 4))))))

2
collects/unstable/cce/reference/manual.scrbl
View File

@ -10,8 +10,6 @@
@table-of-contents[]
@include-section["values.scrbl"]
@include-section["regexp.scrbl"]
@include-section["web.scrbl"]

2
collects/unstable/cce/test/test-main.ss
View File

@ -17,7 +17,6 @@
"test-scribble.ss"
"test-set.ss"
"test-syntax.ss"
"test-values.ss"
"test-web.ss")
(run-tests
@ -38,5 +37,4 @@
scribble-suite
set-suite
syntax-suite
values-suite
web-suite))

63
collects/unstable/cce/test/test-values.ss
View File

@ -1,63 +0,0 @@
#lang scheme
(require "checks.ss"
"../values.ss")
(provide values-suite)
(define values-suite
(test-suite "values.ss"
(test-suite "map2"
(test-case "numerator and denominator"
(let*-values ([(ns ds)
(map2
(lambda (r)
(values (numerator r) (denominator r)))
(list 1/2 3/4 5/6))])
(check-equal? (list ns ds) (list '(1 3 5) '(2 4 6))))))
(test-suite "map/values"
(test-case "complex numerator and denominator"
(let*-values ([(rns rds ins ids)
(map/values
4
(lambda (c)
(values (numerator (real-part c))
(denominator (real-part c))
(numerator (imag-part c))
(denominator (imag-part c))))
(list 1/2+3/4i 5/6+7/8i))])
(check-equal? (list rns rds ins ids)
(list '(1 5) '(2 6) '(3 7) '(4 8)))))
(test-case "multiple lists"
(let*-values ([(as bs cs)
(map/values 3 values '(1 2 3) '(4 5 6) '(7 8 9))])
(check-equal? as '(1 2 3))
(check-equal? bs '(4 5 6))
(check-equal? cs '(7 8 9)))))
(test-suite "foldl/values"
(test-case "sum, product, and last"
(let*-values ([(sum prod last)
(foldl/values
(lambda (next sum prod last)
(values (+ next sum)
(* next prod)
next))
(list 0 1 #f)
(list 1 2 3 4))])
(check-equal? (list sum prod last)
(list 10 24 4)))))
(test-suite "foldr/values"
(test-case "sum, product, and last"
(let*-values ([(sum prod last)
(foldr/values
(lambda (next sum prod last)
(values (+ next sum)
(* next prod)
next))
(list 0 1 #f)
(list 1 2 3 4))])
(check-equal? (list sum prod last)
(list 10 24 1)))))
(test-suite "values->list"
(test-case "1 2 3 4"
(check-equal? (values->list (values 1 2 3 4)) (list 1 2 3 4))))))

1
collects/unstable/scribblings/unstable.scrbl
View File

@ -86,6 +86,7 @@ Keep documentation and tests up to date.
@include-section["struct.scrbl"]
@include-section["syntax.scrbl"]
@include-section["text.scrbl"]
@include-section["values.scrbl"]
@include-section["poly-c.scrbl"]
@include-section["mutated-vars.scrbl"]
@include-section["find.scrbl"]

22
collects/unstable/cce/reference/values.scrbl → collects/unstable/scribblings/values.scrbl
View File

@ -1,13 +1,11 @@
#lang scribble/doc
@(require scribble/manual
scribble/eval
"../scribble.ss"
"eval.ss")
@(require (for-label scheme unstable/cce/values))
#lang scribble/manual
@(require scribble/eval "utils.rkt" (for-label racket unstable/values))
@title[#:style 'quiet #:tag "cce-values"]{Multiple Values}
@title{Multiple Values}
@defmodule[unstable/cce/values]
@defmodule[unstable/values]
@unstable[@author+email["Carl Eastlund" "cce@racket-lang.org"]]
This module provides tools for manipulating functions and expressions that
produce multiple values.
@ -17,7 +15,7 @@ produce multiple values.
Produces a list of the values returned by @scheme[expr].
@defexamples[
#:eval (evaluator 'unstable/cce/values)
#:eval (eval/require 'unstable/values)
(values->list (values 1 2 3))
]
@ -30,7 +28,7 @@ Produces a pair of lists of the respective values of @scheme[f] applied to the
elements in @scheme[lst ...] sequentially.
@defexamples[
#:eval (evaluator 'unstable/cce/values)
#:eval (eval/require 'unstable/values)
(map2 (lambda (x) (values (+ x 1) (- x 1))) (list 1 2 3))
]
@ -46,7 +44,7 @@ Produces lists of the respective values of @scheme[f] applied to the elements in
@scheme[lst ...] sequentially.
@defexamples[
#:eval (evaluator 'unstable/cce/values)
#:eval (eval/require 'unstable/values)
(map/values
3
(lambda (x)
@ -74,7 +72,7 @@ multiple-valued function @scheme[f]; @scheme[foldr/values] traverses the lists
right to left and @scheme[foldl/values] traverses left to right.
@defexamples[
#:eval (evaluator 'unstable/cce/values)
#:eval (eval/require 'unstable/values)
(define (add/cons a b c d)
(values (+ a c) (cons b d)))
(foldr/values add/cons (list 0 null)

4
collects/unstable/cce/values.ss → collects/unstable/values.rkt
View File

@ -1,5 +1,5 @@
#lang scheme/base
(require (for-syntax scheme/base))
#lang racket/base
(require (for-syntax racket/base))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;