mes/module/srfi/srfi-1.mes

;;; -*-scheme-*-

;;; Mes --- Maxwell Equations of Software
;;; Copyright © 2016,2017 Jan Nieuwenhuizen <janneke@gnu.org>
;;;
;;; This file is part of Mes.
;;;
;;; Mes is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; Mes is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with Mes.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;; srfi-1.mes is the minimal srfi-1 needed to run mescc.

;;; Code:

(define (find pred lst)
  (let loop ((lst lst))
    (if (null? lst) #f
        (if (pred (car lst)) (car lst)
            (loop (cdr lst))))))

(define (filter pred lst)
  (let loop ((lst lst))
    (if (null? lst) '()
        (if (pred (car lst))
            (cons (car lst) (loop (cdr lst)))
            (loop (cdr lst))))))

(define (append-map f lst . rest)
  (apply append (apply map f (cons lst rest))))

(define (filter-map f lst)
  (if (null? lst) (list)
      (let ((r (f (car lst))))
        (if r (cons r (filter-map f (cdr lst)))
            (filter-map f (cdr lst))))))

;;; nyacc requirements

(define (fold proc init lst1 . rest)
  (if (null? rest)
      (let loop ((lst lst1) (result init))
        (if (null? lst) result
            (loop (cdr lst) (proc (car lst) result))))
      '*FOLD-n-NOT-SUPPORTED))

(define (fold-right proc init lst1 . rest)
  (if (null? rest)
      (let loop ((lst lst1))
        (if (null? lst) init
            (proc (car lst) (loop (cdr lst)))))
      '*FOLD-RIGHT-n-NOT-SUPPORTED))

(define (remove pred lst) (filter (lambda (x) (not (pred x))) lst))

(define (append-reverse rev-head tail)
  (let loop ((rev-head rev-head) (tail tail))
    (if (null? rev-head) tail
	(loop (cdr rev-head) (cons (car rev-head) tail)))))

(define (reverse! lst)
  (let loop ((lst lst) (result '()))
    (if (null? lst) result
        (let ((tail (cdr lst)))
          (set-cdr! lst result)
          (loop tail lst)))))

(define (srfi-1:member x lst eq)
  (if (null? lst) #f
      (if (eq x (car lst)) lst
          (srfi-1:member x (cdr lst) eq))))

(define mes:member member)

(define (member x lst . rest)
  (if (null? rest) (mes:member x lst)
      (srfi-1:member x lst (car rest))))

(define mes:iota iota)

(define (srfi-1:iota n start step)
  (if (<= n 0) '()
      (cons start (srfi-1:iota (- n 1) (+ start step) step))))

(define (iota n . rest)
  (if (null? rest) (mes:iota n)
      (let ((start (car rest))
            (step (if (null? (cdr rest)) 1
                      (cadr rest))))
        (srfi-1:iota n start step))))

(define last (compose car last-pair))

(include-from-path "srfi/srfi-1.scm")