How do I take a slice of a list (A sublist) in scheme?

Question

Given a list, how would I select a new list, containing a slice of the original list (Given offset and number of elements) ?

EDIT:

Good suggestions so far. Isn't there something specified in one of the SRFI's? This appears to be a very fundamental thing, so I'm surprised that I need to implement it in user-land.

Answer 1

The following code will do what you want:

(define get-n-items
    (lambda (lst num)
        (if (> num 0)
            (cons (car lst) (get-n-items (cdr lst) (- num 1)))
            '()))) ;'

(define slice
    (lambda (lst start count)
        (if (> start 1)
            (slice (cdr lst) (- start 1) count)
            (get-n-items lst count))))

Example:

> (define l '(2 3 4 5 6 7 8 9)) ;'
()
> l
(2 3 4 5 6 7 8 9)
> (slice l 2 4)
(3 4 5 6)
>

Answer 2

(define (sublist list start number)
  (cond ((> start 0) (sublist (cdr list) (- start 1) number))
        ((> number 0) (cons (car list)
                      (sublist (cdr list) 0 (- number 1))))
        (else '())))

Answer 3

Try something like this:

    (define (slice l offset length)
      (if (null? l)
        l
        (if (> offset 0)
            (slice (cdr l) (- offset 1) length)
            (if (> length 0)
                (cons (car l) (slice (cdr l) 0 (- length 1)))
                '()))))

Answer 4

You can try this function:

subseq sequence start &optional end

The start parameter is your offset. The end parameter can be easily turned into the number of elements to grab by simply adding start + number-of-elements.

A small bonus is that subseq works on all sequences, this includes not only lists but also string and vectors.

Edit: It seems that not all lisp implementations have subseq, though it will do the job just fine if you have it.

Answer 5

Strangely, slice is not provided with SRFI-1 but you can make it shorter by using SRFI-1's take and drop:

(define (slice l offset n)
  (take (drop l offset) n))

I thought that one of the extensions I've used with Scheme, like the PLT Scheme library or Swindle, would have this built-in, but it doesn't seem to be the case. It's not even defined in the new R6RS libraries.

Answer 6

(define (slice a-list start end)
  (define (slicify n)
    (if (negative? n)
        (+ (length a-list) n)
        n))

  (let* ((s (slicify start))
         (e (slicify end))
         (len (abs (- s e))))
    (take (drop a-list (min s e)) len)))

More complicated than the other attempts, but

>(define l '(1 2 3 4 5 6 7 8 9 0))
l
>(slice l 3 6)
'(4 5 6)
>(slice l 2 -2)
'(3 4 5 6 7 8)
>(slice l -3 -8)
'(3 4 5 6 7)

I'm sure I missed edge cases and other interactions, but this is a bit closer to how python treats slicing. It is sort of surprising that you have to write this yourself instead of having it provided. That said, I've never really found myself slicing very much in Scheme. And when I do, it's typically easier/more semantically accurate to use take, drop and list-ref than actual slicing.