and isn’t a normal function because it will only evaluate as few arguments as it needs, to know whether the result is true or false. For example, if the first argument is false, then no matter what the other arguments are, the result has to be false so it won’t evaluate the other arguments. If … Read more
In Scheme and Racket, a symbol is like an immutable string that happens to be interned so that symbols can be compared with eq? (fast, essentially pointer comparison). Symbols and strings are separate data types. One use for symbols is lightweight enumerations. For example, one might say a direction is either ‘north, ‘south, ‘east, or … Read more
Try reading Practical Common Lisp, by Peter Seibel.
The primitive cons simply sticks together two things, the fact that some of those things are considered lists is incidental. For instance, this works and creates a pair (also known as a cons cell): (cons 1 2) => ‘(1 . 2) ; a pair Now, if the second argument to cons happens to be a … Read more
Basic Predicates/F-functions McCarthy‘s Elementary S-functions and Predicates were: atom Which was necessary because car and cdr are defined for lists only, which means you cannot count on any sort of answer to indicate what was happening if you gave car an atom. eq For testing equality between atoms. car For returning the first half (address) … Read more
The basic idea behind a named let is that it allows you to create an internal function, that can call itself, and invoke it automatically. So your code is equivalent to: (define (number->list n) (define (loop n acc) (if (< n 10) (cons n acc) (loop (quotient n 10) (cons (remainder n 10) acc)))) (loop … Read more
I have a version that uses only “first-principles” operations and is efficient (does not require more than one pass through any of the lists, unlike append-based solutions). 🙂 It does this by defining two simple building blocks (fold and reverse), and then defining flatten (and its helper, reverse-flatten-into) atop those (and notice how each function … Read more
(note: the answer is at the bottom of this post) The 2nd function, (define (swap-ends x) ; swap [] = [] (if (or (equal (length x) 0) (equal (length x) 1)) ; swap [x] = [x] x ; swap (x:xs) (cons (first (swap-ends (rest x))) ; | (a:b) <- swap xs (swap-ends (cons (first x) … Read more
Just look at the Wikipedia article to get your definition: Tacit programming (point-free programming) is a programming paradigm in which a function definition does not include information regarding its arguments, using combinators and function composition […] instead of variables. Haskell example: Conventional (you specify the arguments explicitly): sum (x:xs) = x + (sum xs) sum … Read more
I think @Vijay’s answer is the best one so far and I just intend to Erlangify it. Pairs (cons cells) in Erlang are written as [Head|Tail] and nil is written as []. There is no restriction as to what the head and tail are but if you use the tail to chain more cons cells … Read more