
Scheme Programming Lessons from Tarot - mabynogy
https://rain-1.github.io/scheme-1
======
IncRnd
When I read the headline I had hoped this would be about esoteric but useful
programming lessons learnt from Tarot deck divination.

------
mabynogy
Part two:
[https://rain-1.github.io/scheme-2](https://rain-1.github.io/scheme-2)

~~~
mabynogy
Part three:
[https://rain-1.github.io/scheme-3](https://rain-1.github.io/scheme-3)

------
thyrsus
This uses a difference list data structure, which, when I learned it in
Prolog, requires lazy evaluation of the tail of the list.

Erlang doesn't seem to allow lazy evaluation; am I wrong about that? Is there
some way to do difference lists in Erlang?

~~~
thyrsus
Correction: it needs _unbound variables_ , not lazy evaluation. Erlang doesn't
have unbound variables; I suspect one would have to implement some form of
that before implementing difference lists.

------
Illniyar
Scheme syntax is so arcane that it appears divination by tarot cards is a
viable option to understanding it.

Like numerology and magic number'd Clang ;)

~~~
xfer
yeah, s-exprs are very hard, right? compared to bazillion new keywords that
can't be used by user programs and various kinds of brackets for different
purposes.

~~~
jjnoakes
Some people find s-expressions hard to read because they are almost too
uniform. Having different brackets and braces mean different things can aid
those folks.

There are languages that allow user-defined syntax and aren't only
parenthesis/s-expressions, so arguing one requires the other is a false
dichotomy.

~~~
pdkl95
Often the information that different brackets and braces would represented in
other languages becomes the _shape_ of the s-expressions. I find that easier
to parse than most[1] languages. With rainbow-delimiters[2] (example[3]),
parsing nested parens becomes _far_ easier.

[1] Ruby is a rare exception.

[2] [https://github.com/Fanael/rainbow-
delimiters](https://github.com/Fanael/rainbow-delimiters)

[3] [http://i.imgur.com/xS4y6rT.png](http://i.imgur.com/xS4y6rT.png)

~~~
steinuil
In Racket and other Schemes parens and square brackets are interchangeable.
The Racket style guide suggests to use square brackets in let- or cond-like
expression, or generally any expression with a list of lists of fixed length
that are not supposed to be evaluated. The expression you posted would become
like this:

    
    
        (do ([i 1 (+ i 1)])
            ((> i 100))
          (display
            (cond [(= 0 (modulo i 15)) "FizzBuzz"]
                  [(= 0 (modulo i 3))  "Fizz"]
                  [(= 0 (modulo i 5))  "Buzz"]
                  [else                i]))
          (newline))
    

I personally think this helps a lot with the problem of parsing s-expressions
visually.

~~~
soegaard
Also: It is rare to use `do`.

    
    
        #lang racket
        (require math)
    
        (for ([i 100])
          (displayln
           (cond [(divides? 15 i) "FizzBuzz"]
                 [(divides?  3 i) "Fizz"]
                 [(divides?  5 i) "Buzz"]
                 [else            i])))

