new recipes

recipes/all-elements-equal.md

@@ -0,0 +1,45 @@
+# Check if all elements are equal
+
+## Problem
+
+I want to check if all arguments are equal, by default `eq?`, `eqv?`, and `equal?` accepts only two arguments.
+
+## Solution
+
+The code use procedure:
+* `sublist-reduce` from recipe: [Fold over n consecutive elements inside a list](/fold-over-sequance-of-elements-inside-list/)
+
+```scheme
+(define (same? . args)
+  (sublist-reduce 2 (lambda (a b result)
+                      (and result (eq? a b)))
+                  #t
+                  args))
+```
+
+And here is alernative that exit early when any pair return `#f`.
+
+```scheme
+(define (same? . args)
+  (call/cc
+   (lambda (return)
+     (sublist-reduce 2 (lambda (a b result)
+                         (let ((eq (eq? a b)))
+                           (if (not eq)
+                               (return eq)
+                               eq)))
+                     #t
+                     args))))
+```
+
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me)
+
+## Usage
+
+```scheme
+(same? 10 10 10)
+;; ==> #t
+(same? 10 10 10 20 30 40)
+;; ==> #f
+```
+

recipes/fold-over-sequance-of-elements-inside-list.md

@@ -0,0 +1,47 @@
+# Fold over n consecutive elements inside a list
+
+## Problem
+
+This is similar problem to [Map over n consecutive elements inside a list](/map-over-sequance-of-elements-inside-list/)
+
+But this time I want to fold a list of elements into a single value, using more than one element at the time.
+
+e.g.:
+
+for list `(1 2 3 4 5)` and `N = 2` it will call:
+
+```scheme
+(fn 4 5 (fn 3 4 (fn 2 3 (fn 1 2 <init>))))
+```
+
+## Solution
+
+The code use function:
+* `take` from recipe: [Select first n elements from list](/select-first-n-elements-from-list/)
+
+```scheme
+(define (sublist-reduce n fn init lst)
+  (let loop ((lst lst) (result init))
+    (if (< (length lst) n)
+        result
+        (let* ((next-list (take lst n))
+               (args (append! next-list (list result))))
+          (loop (cdr lst) (apply fn args))))))
+```
+
+The other name for this procedure could be `sublist-fold-right` anlalogous to fold-right method from
+[SRFI-1]()
+
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me)
+
+## Usage
+
+```scheme
+(sublist-reduce 2 (lambda (a b) (< a b)) #t '(1 2 3 4))
+;; ==> #t
+(sublist-reduce 3 (lambda (a b c result)
+                    (and result (= a b c)))
+                #t
+                '(2 2 2 3 3 3 4 4 4))
+;; ==> #f
+```

recipes/map-over-sequance-of-elements-inside-list.md

@@ -0,0 +1,74 @@
+# Map over n consecutive elements inside a list
+
+## Problem
+
+I have a list of elements, and I want to map using a function when on
+each loop the function gets n items from a list.
+
+e.g.:
+
+for list `(1 2 3 4 5)` and `N = 2` it will call:
+
+```scheme
+(fn 1 2)
+(fn 2 3)
+(fn 3 4)
+(fn 4 5)
+```
+
+for list '(1 2 3 4 5) and `N = 3` it will call:
+
+```scheme
+(fn 1 2 3)
+(fn 2 3 4)
+(fn 3 4 5)
+```
+
+and collect the results into a single list.
+
+## Solution
+
+The code use function:
+* `take` from recipe: [Select first n elements from list](/select-first-n-elements-from-list/)
+
+```scheme
+(define (sublist-map n fn lst)
+  (let loop ((lst lst) (result '()))
+    (if (< (length lst) n)
+        (reverse result)
+        (let ((next-list (take lst n)))
+          (loop (cdr lst) (cons (apply fn next-list) result))))))
+```
+
+**NOTE:** This looping overlap the list, so window is always moving one element per loop.
+If you want the whole window to move to the next n elements you can use this solution instead:
+
+```scheme
+(define (group-map n fn seq-list)
+  (map (lambda (lst)
+         (apply fn lst))
+       (group n seq-list)))
+```
+
+Above function uses:
+* function `group` from recipe: [Split list into groups of N elements](/plit-list-into-groups-of-n-elements/)
+
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me)
+
+## Usage
+
+```scheme
+(sublist-map 2 < '(1 2 3 4))
+;; ==> (#t #t #t)
+(sublist-map 3 = '(2 2 2 3 3 3 4 4 4))
+;; ==> (#t #f #f #t #f #f #t)
+
+(group-map 3 = '(2 2 2 3 3 3 4 4 4))
+;; ==> (#t #t #t)
+(group-map 3 = '(2 2 2 0 1 2 4 4 4))
+;; ==> (#t #f #t)
+(group-map 3 + '(2 2 2 3 3 3 4 4 4))
+;; ==> (6 9 12)
+(group-map 3 max '(1 2 3 4 5 6 7 8 9))
+;; ==> (3 6 9)
+```

recipes/select-first-n-elements-from-list.md

@@ -0,0 +1,37 @@
+# Select first n elements from a list
+
+## Problem
+
+I want to select first elements from a list.
+
+## Solution
+
+```scheme
+(define (take lst n)
+  (let loop ((result '()) (i n) (lst lst))
+    (if (or (null? lst) (<= i 0))
+        (reverse result)
+        (loop (cons (car lst) result) (- i 1) (cdr lst)))))
+
+(define (take/alternative lst n)
+  (let loop ((result '()) (i n) (lst lst))
+    (cond ((<= i 0) (reverse result))
+          ((null? lst) (error "take: not enough elements"))
+          (else
+           (loop (cons (car lst) result) (- i 1) (cdr lst))))))
+```
+
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me)
+
+### SRFI
+The same function is part of the [SRFI-1](https://srfi.schemers.org/srfi-1/srfi-1.html#take).
+
+## Usage
+```scheme
+(take '(1 2 3 4 5) 3)
+;; ==> (1 2 3)
+(take '(1 2) 10)
+;; ==> (1 2)
+(take/alternative '(1 2) 10)
+;; ==> take: not enough elements
+```

recipes/test-if-all-items-pass-predicate.md

@@ -0,0 +1,32 @@
+# Test if all items in list pass the predicate
+
+## Problem
+
+I have a list and I want to check if function return true for all items.
+
+## Solution
+
+```scheme
+(define (every? fn list)
+  (or (null? list)
+      (and (fn (car list)) (every? fn (cdr list)))))
+```
+
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me)
+
+## SRFI
+
+[SRFI-1](https://srfi.schemers.org/srfi-1/) has function `every`, but `every?` always return `#f` or `#f` that's why it has question mark.
+
+## Usage
+
+```scheme
+(every? number? '(1 2 3 4))
+;; ==> #t
+(every? number? '(1 foo 3 4))
+;; ==> #f
+(every? number? '())
+;; ==> #t
+(every? string->number '("foo" "bar" "baz"))
+;; ==> #f
+```

recipes/test-if-list-is-ordered-by-comparator.md

@@ -0,0 +1,31 @@
+# Test if list is ordered by comparator
+
+## Problem
+
+I have a list and I want to check if it's ordered or sorted using a functions
+
+## Solution
+
+It uses functions:
+
+* `every` from [Map over n consecutive elements inside a list](/test-if-all-items-pass-predicate/)
+* `sublist-map` from [Map over n consecutive elements inside a list](/map-over-sequance-of-elements-inside-list/)
+
+```scheme
+(define (ordered? predicate lst)
+  (let ((result (sublist-map 2 predicate lst)))
+    (every identity result)))
+```
+
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me)
+
+## Usage
+
+```scheme
+(ordered? < '(1 2 3 4))
+;; ==> #t
+(ordered? < '(1 3 3 4))
+;; ==> #f
+(ordered? >= '(4 3 3 1))
+;; ==> #t
+```

recipes/use-lists-as-2d-matrix.md

@@ -71,7 +71,7 @@ Create matrix data structure and functions to operate on matrices.
   (map (lambda (nrow mrow) (map + nrow mrow)) N M))
 ```
 
-Credit: [Jakub T. Jankiewicz](https://jcubic.pl) (ref: [Matrix manipulation in scheme](https://jcubic.wordpress.com/2011/09/29/matrix-manipulation-in-scheme/))
+Credit: [Jakub T. Jankiewicz](https://jcubic.pl/me) (ref: [Matrix manipulation in scheme](https://jcubic.wordpress.com/2011/09/29/matrix-manipulation-in-scheme/))
 
 ## Usage