Next: , Previous: , Up: Guile Algorithms   [Contents][Index]

2 Programming Interface

Scheme Procedure: adjacent-map proc lst

Returns a list of elements after apply proc to adjacent elements.

This algorithm is similar to Haskell’s mapAdjacent.

Examples: 

> (adjacent-map * '(1 2 3 4 5 6))
'(2 6 12 20 30)
> (adjacent-map < '(1 2 1 3 4 3))
'(#t #f #t #t #f)
Scheme Procedure: all? lst

Returns #t if all the elements of lst are #t, otherwise returns #f.

This algorithm is similar to Python’s all.

Examples: 

> (all? '(#t #t #t))
#t
> (all? '(#t #t #f))
#f
Scheme Procedure: any? lst

Returns #t if any of the elements of lst is #t, otherwise returns #f.

This algorithm is similar to Python’s any.

Examples: 

> (any? '(#f #t #f))
#t
> (any? '(#f #f #f))
#f
Scheme Procedure: chunks-of lst k

Returns a list of lists of k elements each.

Note that this is a specialization of sliding where size is equal to step.

This algorithms is the same as Haskell’s chunksOf.

Examples: 

> (chunks-of '(1 2 1 3 4 3) 2)
'((1 2) (1 3) (4 3))
> (chunks-of '(1 2 1 3 4 3) 3)
'((1 2 1) (3 4 3))
Scheme Procedure: flatten v

Flattens an arbitrary S-expression structure of pairs into a list. More precisely, v is treated as a binary tree where pairs are interior nodes, and the resulting list contains all of the non-null leaves of the tree in the same order as an inorder traversal.

This algorithm is a direct port of racket/base flatten, and is not coming from racket-algorithms package.

Examples: 

> (flatten '((a) b (c (d) . e) ()))
'(a b c d e)
> (flatten 'a)
'(a)
Scheme Procedure: generate n proc

Returns a list of n elements generated from invoking proc n times.

This algorithm is similar to C++’s generate.

Examples: 

> (generate 3 *)
'(1 1 1)
> (generate 3 +)
'(0 0 0)
Scheme Procedure: increasing? lst

Returns #t if all the elements of lst are strictly increasing, otherwise returns #f.

Examples: 

> (increasing? '(1 2 3 4))
#t
> (increasing? '(1 2 3 5))
#t
> (increasing? '(1 2 2 3))
#f
Scheme Procedure: init lst

Return all the elements of a list except the last one.

This algorithm comes from Haskell’s init.

Examples: 

> (init '(1 2 3 4))
'(1 2 3)
> (init '((1 2) (3 4) (5 6)))
'((1 2) (3 4))
Scheme Procedure: juxt proc…

Takes variable number of procedures and returns a procedure that is the juxtaposition of those procedures. The returned procedure takes a variable number of arguments, and returns a list containing the result of applying each procedures to the arguments.

This algorithm comes from Clojure’s juxt.

Examples: 

> ((juxt first last) '(1 2 3))
'(1 3)
> ((juxt + *) 1 2 3 4)
'(10 24)
> ((juxt zip append)  '(1 2 3) '(4 5 6))
'(((1 4) (2 5) (3 6)) (1 2 3 4 5 6))
Scheme Procedure: product lst

Returns the product of the elements in lst.

Examples: 

> (product '(1 2 3))
6
> (product '(1 2 3 4))
24
Scheme Procedure: repeat n val

Returns a list of val repeated n times.

This algorithms is the same as Clojures’s repeat and D’s repeat.

Note: this is in fact just alias to make-list and therefore isn’t really necessary.

Examples: 

> (repeat 5 #t)
'(#t #t #t #t #t)
> (repeat 5 '())
'(() () () () ())
Scheme Procedure: replicate lst lst2

Returns a list of of the lst2 values each repeated n times where n is the corresponding element in lst.

This algorithms is the similar to APL’s replicate.

Examples: 

> (replicate '(1 0 1) '(a b c))
'(a c)
> (replicate '(0 1 2) '(a b c))
'(b c c)
Scheme Procedure: scanl proc lst

Returns a list of successive reduced values from the left.

This algorithm originally comes from APL’s monadic \ scan operator. It is more similar to Haskell’s scanl1 however.

Examples: 

> (scanl + '(1 2 3 4))
'(1 3 6 10)
> (scanl * '(1 2 3 4))
'(1 2 6 24)
Scheme Procedure: scanr proc lst

Returns a list of successive reduced values from the right.

This algorithm originally comes from APL’s monadic \ scan operator. It is more similar to Haskell’s scanr1 however.

Examples: 

  > (scanr + '(1 2 3 4))
  '(10 9 7 4)
  > (scanr * '(1 2 3 4))
  '(24 24 12 4)
Scheme Procedure: sliding lst size [step 1]

Returns a list of lists of size elements each, at offset step apart.

step has to be smaller than length of the lst.

This algorithms is the same as Haskell’s divvy, Clojure’s partition and D’s slide.

Examples: 

> (sliding '(1 2 3 4) 2)
'((1 2) (2 3) (3 4))
> (sliding '(1 2 3 4 5) 2 3)
'((1 2) (4 5))
Scheme Procedure: sorted? lst

Returns #t if all the elements of lst are in sorted order, otherwise returns #f.

This algorithm is similar to C++’s std::is_sorted.

Examples: 

> (sorted? '(1 2 3 4))
#t
> (sorted? '(1 2 3 3))
#t
> (sorted? '(1 2 3 2))
#f
Scheme Procedure: sum lst

Returns the sum of the elements in lst.

Examples: 

> (sum '(1 2 3 4))
10
> (sum '())
0
Scheme Procedure: tail lst

Return all the elements of a list except the first one.

Name of this algorithm comes from Haskell’s tail

Note: this is the same as cdr and therefore isn’t really necessary.

Examples: 

> (tail '(1 2 3))
'(2 3)
> (tail '(1))
'()
Scheme Procedure: zip-with proc lst lst…

Returns a list after zipping together the variadic number of lsts and applying proc to each of the "zipped together" elements.

This algorithm is similar to Haskell’s zipWith.

Examples: 

> (zip-with + '(1 2 3) '(4 5 6))
'(5 7 9)
> (zip-with + '(1 2 3) '(4 5 6) '(7 8 9))
'(12 15 18)

Next: Contributing, Previous: Introduction, Up: Guile Algorithms   [Contents][Index]