Scheme cheat sheet

Idiom ID Imports Comments Links

The snippets are under the CC-BY-SA license.
Please consider keeping a bookmark
(instead of printing)

		Scheme
1	Print Hello World Print a literal string on standard output	`(display "Hello World")`
2	Print Hello 10 times Loop to execute some code a constant number of times	`(define (hellos i) (if (> i 0) (begin (display "Hello") (newline) (hellos (- i 1))))) (hellos 10)` Demo Alternative implementation: `(for-each (lambda (x) (display "Hello\n")) (iota 10))` Chez Scheme Demo Alternative implementation: `(do ((i 0 (+ i 1))) ((= i 10)) (display "Hello") (newline))` Demo
3	Create a procedure Like a function which doesn't return any value, thus has only side effects (e.g. Print to standard output)	`(define (finish name) (display "My job here is done. Goodbye ") (display name) (newline))` This is a short syntax for a lambda definition. Demo Alternative implementation: `(define finish (lambda (name) (display "My job here is done. Goodbye ") (display name) (newline)))` Demo
4	Create a function Create a function which returns the square of an integer	`(define square (lambda (x) (* x x)))` Demo Alternative implementation: `(define (square x) (* x x))` This is a short syntax for a lambda definition. Demo
5	Create a 2D Point data structure Declare a container type for two floating-point numbers x and y	`(define (make-point x y) (cons x y)) (define (point-x p) (car p)) (define (point-y p) (cdr p))`
6	Iterate over list values Do something with each item x of the list (or array) items, regardless indexes.	`(define (doSomething x) (if (not (null? x)) (begin (display "Item=") (display (car x)) (newline) (doSomething (cdr x)))))` Iteration is achieved by recursion. Demo Alternative implementation: `(define (sum a b) (sum-iter a b 0)) (define (sum-iter index n sum) (if (= n index) (+ sum index) (+ (sum-iter n (+ index 1) (+ sum index))) )` Alternative implementation: `(map doSomething items)`
7	Iterate over list indexes and values Print each index i with its value x from an array-like collection items	`(define (display-list items) (define (display-list items i) (if (not (null? items)) (begin (display (string-append (number->string i) ": " (number->string (first items)) "\n")) (display-list (rest items) (+ i 1))) 'done)) (display-list items 0))` Iteration is tail-recursion.
8	Create a map (associative array) Create a new map object x, and provide some (key, value) pairs as initial content.	`(define x '( ("one" 1) ("two" 2) ("three" 3)))` Warning : the built-in association lists are inefficient, so don't use them for large data sets. Demo
9	Create a Binary Tree data structure The structure must be recursive because left child and right child are binary trees too. A node has access to children nodes, but not to its parent.	`(define (make-btree value left right) (cons value (cons left right))) (define (btree-value bt) (car bt)) (define (btree-left bt) (cadr bt)) (define (btree-right bt) (cddr bt))`
10	Shuffle a list Generate a random permutation of the elements of list x	`(shuffle x)` Alternative implementation: `(define shuffle (lambda (x) (if (< (length x) 2) list (let ((item (list-ref list (random (length x))))) (cons item (shuffle (remove item x)))))))`
11	Pick a random element from a list The list x must be non-empty.	`(list-ref x (random (length x)))` Tested with Chez Scheme
12	Check if list contains a value Check if the list contains the value x. list is an iterable finite container.	`(define (contains list x) (cond [(null? list) #f] [(equal? (car list) x) #t] [else (contains (cdr list) x)]))` This is a custom implementation, use it if no built-in predicate is available in your Scheme environment. Demo Alternative implementation: `(member x list)` Demo Doc
14	Pick uniformly a random floating point number in [a..b) Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b.	`(+ a (* (- b a) (random 1.0)))` Tested with Chez Scheme
15	Pick uniformly a random integer in [a..b] Pick a random integer greater than or equals to a, inferior or equals to b. Precondition : a < b.	`(+ a (random (add1 (- b a))))` Tested with Chez Scheme; a and b must be integers and written without decimal points and trailing zeros, e.g., 10 vs 10.0 Alternative implementation: `(floor (+ a (* (add1 (- b a)) (random 1.0))))` Tested with Chez Scheme
16	Depth-first traversal of a binary tree Call a function f on every node of binary tree bt, in depth-first infix order	`(define (map-btree f bt) (if (not (null? bt)) (make-btree (f (btree-value bt)) (map-btree f (btree-left bt)) (map-btree f (btree-right bt))) bt))` See binary tree definition in idiom 9.
17	Create a Tree data structure The structure must be recursive. A node may have zero or more children. A node has access to its children nodes, but not to its parent.	`(define (make-tree value children) (cons value children)) (define (tree-value t) (car t)) (define (tree-first-child t) (cadr t)) (define (tree-rest-children t) (cddr t))` children is list of trees
19	Reverse a list Reverse the order of the elements of the list x. This may reverse "in-place" and destroy the original ordering.	`(reverse x)`
21	Swap values Swap the values of the variables a and b	`(define (swap a b) (list b a))`
22	Convert string to integer Extract the integer value i from its string representation s (in radix 10)	`(define i (string->number s))`
26	Create a 2-dimensional array Declare and initialize a matrix x having m rows and n columns, containing real numbers.	`(build-list m (lambda (x) (build-list n (lambda (y) 0))))` The (lambda (y) 0) isn't strictly necessary, it just initializes the values in the matrix to 0.
28	Sort by a property Sort the elements of the list (or array-like collection) items in ascending order of x.p, where p is a field of the type Item of the objects in items.	`(define-struct item (p x y) #:transparent) (define items (list (item 1 2 3) (item 0 0 0) (item 5 2 1))) (sort items < #:key item-p)` < is the integer comparison function. There is also string<?. Doc
29	Remove item from list, by its index Remove i-th item from list items. This will alter the original list or return a new list, depending on which is more idiomatic. Note that in most languages, the smallest valid value for i is 0.	`(define (removeElementByIndex L i) (if (null? L) null (if (= i 0) (cdr L) (cons (car L) (removeElementByIndex (cdr L) (- i 1))) ) ) )`
31	Recursive factorial (simple) Create the recursive function f which returns the factorial of the non-negative integer i, calculated from f(i-1)	`(define (f i) (if (> i 1) (* (f (- i 1)) i) 1))`
35	First-class function : compose Implement a function compose (A -> C) with parameters f (A -> B) and g (B -> C), which returns the composition function g ∘ f	`(define (compose f g) (lambda (x) (g (f (x)))))`
36	First-class function : generic composition Implement a function compose which returns composition function g ∘ f for any functions f and g having exactly 1 parameter.	`(define (compose f g) (lambda x (f (apply g x))))` Alternative implementation: `(define compose (lambda (f g) (lambda (x) (f (g x)))))`
37	Currying Transform a function that takes multiple arguments into a function for which some of the arguments are preset.	`(define add5 (curry + 5))`
38	Extract a substring Find substring t consisting in characters i (included) to j (excluded) of string s. Character indices start at 0 unless specified otherwise. Make sure that multibyte characters are properly handled.	`(define t (substring s i j))` Chez Scheme
41	Reverse a string Create the string t containing the same characters as the string s, in reverse order. The original string s must remain unaltered. Each character must be handled correctly regardless its number of bytes in memory.	`(define t (list->string (reverse (string->list s))))` s is unaltered
45	Pause execution for 5 seconds Sleep for 5 seconds in current thread, before proceeding with the next instructions.	`(sleep 5)` Same as Lisp. Doc
48	Multi-line string literal Assign to variable s a string literal consisting in several lines of text, including newlines.	`(define s "This is my multi-line literal. Line number two! This line starts with two spaces.")` Demo Doc
49	Split a space-separated string Build list chunks consisting in substrings of the string s, separated by one or more space characters.	`(define (tokenize l) (let loop ((t '()) (l l)) (if (pair? l) (let ((c (car l))) (if (char=? c #\space) (cons (reverse t) (loop '() (cdr l))) (loop (cons (car l) t) (cdr l)))) (if (null? t) '() (list (reverse t)))))) (define (string-split s) (map list->string (tokenize (string->list s))))`
50	Make an infinite loop Write a loop that has no end clause.	`(let forever () (forever))` Named let infinite loop with no arguments.
51	Check if map contains key Determine whether the map m contains an entry for the key k	`(assoc k m)`
53	Join a list of strings Concatenate elements of string list x joined by the separator ", " to create a single string y.	`(define y (foldr (lambda (a b) (if (string=? b "") a (string-append a ", " b))) "" x))`
54	Compute sum of integers Calculate the sum s of the integer list or array x.	`(define s (foldr + 0 x))` Alternative implementation: `(define s (fold-right + 0 x))` Chez Scheme Alternative implementation: `(define s (apply + x))` Alternative implementation: `(define s (apply fx+ x))` fx+ is integer (fixnum) operation Alternative implementation: `(define s (apply + x))`
55	Convert integer to string Create the string representation s (in radix 10) of the integer value i.	`(define s (number->string i))`
57	Filter list Create the list y containing the items from the list x that satisfy the predicate p. Respect the original ordering. Don't modify x in-place.	`(define y (filter p x))`
64	Big integer : value 3 power 247 Assign to x the value 3^247	`(define x (expt 3 247))` Most Schemes handle arbitrary precision arithmetic by default. Doc
71	Echo program implementation Basic implementation of the Echo program: Print all arguments except the program name, separated by space, followed by newline. The idiom demonstrates how to skip the first argument if necessary, concatenate arguments as strings, append newline and print it to stdout.	`(display (string-join (list-tail (command-line) 1) " ")) (newline)`
76	Binary digits from an integer Create the string s of integer x written in base 2. E.g. 13 -> "1101"	`(define (binary-representation x) (let loop ([N x] [s '()]) (let ([NN (arithmetic-shift N -1)]) (cond [(zero? N) (list->string s)] [(odd? N) (loop NN (cons #\1 s))] [else (loop NN (cons #\0 s))]))))`
77	Complex number Declare a complex x and initialize it with value (3i - 2). Then multiply it by i.	`(define x -2+3i) (display (* x 0+1i))` Most Schemes have a specialized reader syntax for complex numbers. Doc
81	Round floating point number to integer Declare the integer y and initialize it with the rounded value of the floating point number x . Ties (when the fractional part of x is exactly .5) must be rounded up (to positive infinity).	`(define y (round x))` Similar functions: - round: compat with IEEE floating point rounding rules; rounds to even when halfway b/w two integers - floor: largest int not larger than x - ceiling: smallest int not smaller than x - truncate: integer closest to x whose absolute value is not larger than the absolute value of x Doc
87	Stop program Exit immediately. If some extra cleanup work is executed by the program runtime (not by the OS itself), describe it.	`(exit)` Checked on: Racket, Guile. Doc
93	Pass a runnable procedure as parameter Implement the procedure control which receives one parameter f, and runs f.	`(define (control f) (f))`
110	Check if string is blank Set the boolean blank to true if the string s is empty, or null, or contains only whitespace ; false otherwise.	`(define (empty-string? s) (= (string-length s) 0)) (define blank (empty-string? (string-trim s)))`
114	Test deep equality Set boolean b to true if objects x and y contain the same values, recursively comparing all referenced elements in x and y. Tell if the code correctly handles recursive types.	`(define b (equal? x y))`
117	Get list size Set n to the number of elements of the list x.	`(define n (length x))`
119	Deduplicate list Remove duplicates from the list x. Explain if the original order is preserved.	`(define (remove-duplicates l) (cond ((null? l) '()) ((member (car l) (cdr l)) (remove-duplicates (cdr l))) (else (cons (car l) (remove-duplicates (cdr l)))))) (remove-duplicates x)`
126	Multiple return values Write a function foo that returns a string and a boolean value.	`(define (foo) (cons "bar" false))` Alternative implementation: `(define (foo) (values "foo" #t))`
131	Successive conditions Execute f1 if condition c1 is true, or else f2 if condition c2 is true, or else f3 if condition c3 is true. Don't evaluate a condition when a previous condition was true.	`(cond (c1 (f1)) (c2 (f2)) (c3 (f3)))`
134	Create a new list Declare and initialize a new list items, containing 3 elements a, b, c.	`(define items (list a b c))`
141	Iterate in sequence over two lists Iterate in sequence over the elements of the list items1 then items2. For each iteration print the element.	`(map (lambda (x) (display x) (newline)) (append items1 items2))`
143	Iterate alternatively over two lists Iterate alternatively over the elements of the lists items1 and items2. For each iteration, print the element. Explain what happens if items1 and items2 have different size.	`(map (lambda (x) (display x) (newline)) (foldr append '() (map list items1 items2)))`
163	Print list elements by group of 2 Print all the list elements, two by two, assuming list length is even.	`(let print-pairs ((l list)) (if (null? l) '() (begin (display (car l)) (display " ") (display (cadr l)) (newline) (print-pairs (cddr l)))))`
165	Last element of list Assign to the variable x the last element of the list items.	`(define items (list 1 2 3 4)) (define x (last items))` This runs in O(n) time since list produces a linked list.
166	Concatenate two lists Create the list ab containing all the elements of the list a, followed by all the elements of the list b.	`(define ab (append a b))`
171	Add an element at the end of a list Append the element x to the list s.	`(reverse (cons x (reverse s)))`
182	Quine program Output the source of the current program. A quine is a computer program that takes no input and produces a copy of its own source code as its only output. Reading the source file from disk is cheating.	`1` This is cheating, I know.
191	Check if any value in a list is larger than a limit Given a one-dimensional array a, check if any value is larger than x, and execute the procedure f if that is the case	`(let iter ((l a)) (cond ((null? l) '()) ((> (car l) x) (f)) (else (iter (cdr l)))))`
234	Encode bytes to base64 Assign to the string s the standard base64 encoding of the byte array data, as specified by RFC 4648.	`(require net/base64)` `(base64-encode (list->bytes (map char->integer (string->list "hi there"))))` Racket
243	Print list Print the contents of the list or array a on the standard output.	`(write a)`
256	Count backwards Print the numbers 5, 4, ..., 0 (included), one line per number.	`(let loop ([x 5]) (when (>= x 0) (display x) (newline) (loop (sub1 x))))` Named let is a common way of iterating in Scheme. The "loop" label could have been "cat," for instance.
257	Traverse list backwards Print each index i and value x from the list items, from the last down to the first.	`(define (reversed-inspect items) (foldl (lambda (x i) (display (format "~a ~a\n" i x)) (sub1 i)) (sub1 (length items)) (reverse items)))`
261	Format time hours-minutes-seconds Assign to the string x the value of fields (hours, minutes, seconds) of the date d, in format HH:MM:SS.	`(define d (current-date)) (define x (substring (date-and-time d) 11 19))` Chez Scheme; `date-and-time` always returns string with the same format and same length Doc
265	Even parity bit Calculate the parity p of the integer variable i : 0 if it contains an even number of bits set, 1 if it contains an odd number of bits set.	`(define (popcount x) (let loop ([s x] [count 0]) (cond [(zero? s) count] [(odd? s) (loop (arithmetic-shift s -1) (add1 count))] [else (loop (arithmetic-shift s -1) count)]))) (define i 42) (popcount i)` Named let is a common way to iterate in Scheme because it allows for tail recursion.
267	Pass string to argument that can be of any type Declare an argument x to a procedure foo that can be of any type. If the type of the argument is a string, print it, otherwise print "Nothing." Test by passing "Hello, world!" and 42 to the procedure.	`(define (foo x) (displayln (if (string? x) x "Nothing"))) (foo "Hello, world!") (foo 42)` if evaluates to a result.