Recent changes to Scheme-tutorial

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Mon, 04 Sep 2017 00:30:14 -0000

--- v117
+++ v118
@@ -373,7 +373,7 @@

 But what if you actually want to refer to "\\\\"?  No problem, just use the expression "{\\\\}".  Exactly what this means will depend on whether or not your Lisp uses "slashification" (e.g., if "\" followed by any character means that character is part of a symbol).  If it doesn't use slashification, \\\\ means the symbol with a two-character name \\\\.  If it uses slashification, \\\\ means the symbol with the one-character name \\.  The good news is that you can use the marker \\\\ on practically any Lisp system, so you don't need to constantly change notation if you use different ones.

-The readable-lisp implementation also supports a special line continuation extension.  If there's at least one expression on the line, and the line ends with "\\\\", then this is consier a line continuation - the line continues as if the newline never occurred.  This is similar to how many other languages handle "\\" at the end of a line.  The following line has to have the same indentation as the previous line with the "\\\\" at the end.  You can keep doing this for as many lines as you'd like.  This extension is not part of the sweet-expression specification in SRFI-110, it's simply a permitted extension, but in Common Lisp this extension can be useful.  It has been added to the Scheme implementation for consistency with the Common Lisp implementation.
+The readable-lisp implementation also supports a special line continuation extension.  If there's at least one expression on the line, and the line ends with "\\\\", then the "\\\\" is considered a line continuation.  That is, the line continues as if the newline never occurred.  This is similar to how many other languages handle "\\" at the end of a line.  The following line has to have the same indentation as the previous line (the line with the "\\\\" at the end).  You can keep doing this for as many lines as you'd like.  This extension is not part of the sweet-expression specification in SRFI-110, it's simply a permitted extension, but in Common Lisp this extension can be useful.  It has been added to the Scheme implementation for consistency with the Common Lisp implementation.

 Sublist
 -------

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Mon, 04 Sep 2017 00:25:39 -0000

--- v116
+++ v117
@@ -373,6 +373,8 @@

 But what if you actually want to refer to "\\\\"?  No problem, just use the expression "{\\\\}".  Exactly what this means will depend on whether or not your Lisp uses "slashification" (e.g., if "\" followed by any character means that character is part of a symbol).  If it doesn't use slashification, \\\\ means the symbol with a two-character name \\\\.  If it uses slashification, \\\\ means the symbol with the one-character name \\.  The good news is that you can use the marker \\\\ on practically any Lisp system, so you don't need to constantly change notation if you use different ones.

+The readable-lisp implementation also supports a special line continuation extension.  If there's at least one expression on the line, and the line ends with "\\\\", then this is consier a line continuation - the line continues as if the newline never occurred.  This is similar to how many other languages handle "\\" at the end of a line.  The following line has to have the same indentation as the previous line with the "\\\\" at the end.  You can keep doing this for as many lines as you'd like.  This extension is not part of the sweet-expression specification in SRFI-110, it's simply a permitted extension, but in Common Lisp this extension can be useful.  It has been added to the Scheme implementation for consistency with the Common Lisp implementation.
+
 Sublist
 -------

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Wed, 02 Jul 2014 05:14:48 -0000

--- v115
+++ v116
@@ -405,6 +405,14 @@
         (* 2 x))

+Indent characters
+-----------------
+
+You can indent using one or more of the indent characters, which are space, tab, and the exclamation point (!). Lines after the first line need to be consistently indented, that is, the current line’s indentation, when compared to the previous line’s, are equal or one is a prefix of the other. Indentation processing does not occur inside ( ), [ ], and { }, whether they are prefixed or not; this makes sweet-expressions backwards-compatible with traditional s-expressions, and also provides an easy way to disable indentation processing if it’s inconvenient. 
+
+These rules eliminate many concerns people have with indentation systems.  One objection that people raise about indentation-sensitive syntax is that horizontal whitespace can get lost in many transports (HTML readers, etc.). In addition, sometimes there are indented groups that you’d like to highlight; traditional whitespace indentation provides no opportunity to highlight indented groups specially.  By allowing "!" as an indent character (as well as space and tab), these problems disappear.  Also, some like to use spaces to indent; others like tabs. Python allows either. Sweet-expressions also allow people to use spaces, tabs, or a combination, as long as you are consistent, so developers can use whatever they prefer.
+
+
 What's the big deal?
 ====================

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Wed, 02 Jul 2014 05:06:27 -0000

--- v114
+++ v115
@@ -53,6 +53,8 @@
     {cos(0) + 1}

 Just execute "(exit)" to get out.
+
+Note: GNU guile version 2.0.7 (released 2012-11-30), and later, include built-in support for reading curly-infix-expressions (aka SRFI-105).  Just need to use "#!curly-infix" to enable it.

 Using Neoteric-expressions (n-expressions)

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Sat, 14 Jun 2014 14:37:51 -0000

--- v113
+++ v114
@@ -207,14 +207,14 @@

 Remember to enter a blank line (*Enter* *Enter*) to end an expression.

-You can use this tool to process files, say, via a makefile.  Then you can use sweet-expressions to write your code, and have it quickly translated to s-expressions.  The following portable Makefile snippet translates all ".sscm" (Sweet Scheme) files into ".scm" (Scheme) files; as this is Makefile be sure the first character on the last line is TAB:
+You can use this tool to process files, say, via a makefile.  Then you can use sweet-expressions to write your code, and have it quickly translated to s-expressions.  The following POSIX-portable Makefile snippet translates all ".sscm" (Sweet Scheme) files into ".scm" (Scheme) files.  Since this is a Makefile, be sure that the first character on the indented line is TAB:

     UNSWEETEN = unsweeten
     .sscm.scm:
         $(UNSWEETEN) $< > $@
     .SUFFIXES: .sscm .scm

-Unsweeten also copies out comments, but only in certain cases.  Only a group of semicolon comments starting from either the file's very beginning, or after a blank line, are copied to the output.  Such semicolon comments will have indentation (if any) removed. Block comments and comments *inside* a datum are never copied.  Semicolon comments immediately after a datum aren't copied either (the reader has to consume them to see if it's reached the end of the datum - and once it is consumed unsweeten can't copy the comment out).
+Unsweeten also copies comments to the output file, but only in certain cases.  Only a group of semicolon comments starting from either the file's very beginning, or after a blank line, are copied to the output.  Such semicolon comments will have indentation (if any) removed. Block comments and comments *inside* a datum are never copied.  Semicolon comments immediately after a datum aren't copied either (the reader has to consume them to see if it's reached the end of the datum - and once the data is consumed unsweeten can't copy the comment out).

 Unsweeten also has some special substitutions.  If a semicolon begins a line, the next character may cause it to do something special.  If line begins with ";#: or ";!", the line is copied back without the leading semicolon.  If a line begins with ";_", then the line is copied back without either of those first two characters.

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Sat, 14 Jun 2014 14:34:52 -0000

--- v112
+++ v113
@@ -212,7 +212,7 @@
     UNSWEETEN = unsweeten
     .sscm.scm:
         $(UNSWEETEN) $< > $@
-
+    .SUFFIXES: .sscm .scm

 Unsweeten also copies out comments, but only in certain cases.  Only a group of semicolon comments starting from either the file's very beginning, or after a blank line, are copied to the output.  Such semicolon comments will have indentation (if any) removed. Block comments and comments *inside* a datum are never copied.  Semicolon comments immediately after a datum aren't copied either (the reader has to consume them to see if it's reached the end of the datum - and once it is consumed unsweeten can't copy the comment out).

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Mon, 14 Oct 2013 21:36:28 -0000

--- v111
+++ v112
@@ -414,7 +414,7 @@
 Closing Remarks
 ===============

-You can see more Scheme-specific information about sweet-expressions in SRFI-110.
+See [Examples] for some additional examples. You can see more Scheme-specific information about sweet-expressions in SRFI-110.

 Although we used some specific implementations, note that these notations could be used with any Lisp-based system.

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Sun, 13 Oct 2013 22:48:43 -0000

--- v110
+++ v111
@@ -32,7 +32,7 @@

 it will respond with (+ 2 3).  That is, once it's read in, it will read in a quoted (+ 2 3), and "executing" it will return the simple (+ 2 3).  Note that the infix operator *must* be surrounded by whitespace - otherwise, it would have no way to know where the name of the operation begins or ends.

-There is intentionally no support for precedence between different operators. While precedence is useful in some circumstances, in typical uses for Lisp-derived languages and sweet-expressions, it doesn't help and is often harmful. In particular, precedence can hide where different lists occur.  This lack of precedence is not a problem at all; usually you can just use curly braces or parentheses when mixing different infix operators:
+There is intentionally no support for precedence between different operators. While precedence is useful in some circumstances, in typical uses for Lisp-derived languages, it doesn't help much and is often harmful. In particular, precedence can hide where different lists occur.  This lack of precedence is not a problem at all; usually you can just use curly braces or parentheses when mixing different infix operators:

     {2 + {3 * 4}}

@@ -53,8 +53,6 @@
     {cos(0) + 1}

 Just execute "(exit)" to get out.
-
-(Note: If you want to try the draft curly-infix implementation in Common Lisp, run a Common Lisp implementation such as clisp, and then execute (load "readable.cl").).

 Using Neoteric-expressions (n-expressions)
@@ -64,7 +62,7 @@

       ./neoteric-guile

-We have reports that guile version 2.0's "autocompilation" feature can cause troubles.  If you see ";; compiling /blah/blah...", then just exit by typing **exit()** and **Enter**.  Then restart it (don't the clear cache first), and it should work.
+Again, you can omit the beginning "./" if you installed the programs to their final system locations.  We have reports that guile version 2.0's "autocompilation" feature can cause troubles.  If you see ";; compiling /blah/blah...", then just exit by typing **exit()** and **Enter**.  Then restart it (don't clear the cache first) with "./neoteric-guile", and it should work.

 Neoteric-expressions support curly-infix-expressions, including normally-formatted s-expressions.  In addition, neoteric-expressions add special meanings to the grouping symbols ( ), [ ], and { } if they *immediately* follow an expression (instead of being separated by whitespace).  In particular, any e( ... ) is mapped to (e ...), and any e{ ... } is mapped to (e { ... }).

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Sun, 13 Oct 2013 22:44:19 -0000

--- v109
+++ v110
@@ -1,4 +1,4 @@
-This tutorial describes shows how to use the "readable" free-libre/open source software with the Scheme, especially the guile implementation of Scheme.  The "readable" software adds new abbreviations to traditional Lisp notation, to make it far more readable.  You don't need to be familiar with Lisp-like languages to understand this tutorial, though it greatly helps.
+This tutorial describes shows how to use the "readable" free-libre/open source software with Scheme, especially the guile implementation of Scheme.  The "readable" software adds new abbreviations to traditional Lisp notation, to make it far more readable.  You don't need to be familiar with Lisp-like languages to understand this tutorial, though it greatly helps.

 But first, here are some related pages you might find useful:

Scheme-tutorial modified by David A. Wheeler

David A. Wheeler — Sun, 13 Oct 2013 22:43:44 -0000

--- v108
+++ v109
@@ -7,6 +7,7 @@
 * [Problem] provides more information on the problems of traditional Lisp notation.  Historically Lisp-derived systems represent programs as *s-expressions*, where an operation and its parameters is surrounded by parentheses in that order.  Thus, “2+3” is written as “(+ 2 3)” in a Lisp-derived language. Lisp notation is simple, but most people find it hard to read.
 * [Solution] describes in more detail our solution to the [Problem] of traditional Lisp notation.  We've developed three tiers of notation, each building on the previous. These are simply new abbreviations for common cases; you can continue to use normally-formatted s-expressions wherever you want to. Curly-infix-expressions add infix notation; neoteric-expressions add the ability to write f(x) instead of (f x), and sweet-expressions deduce parentheses from indentation.

+So let's get started!

 Using curly-infix-expressions (c-expressions)
 =============================================