ZelphirKaltstahl
/
the-seasoned-schemer-notes


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344
							<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="English" xml:lang="English">
<head>
<!-- 2023-11-26 Sun 17:13 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>The Seasoned Schemer Notes</title>
<meta name="author" content="Zelphir Kaltstahl" />
<meta name="generator" content="Org Mode" />
<style>
  #content { max-width: 60em; margin: auto; }
  .title  { text-align: center;
             margin-bottom: .2em; }
  .subtitle { text-align: center;
              font-size: medium;
              font-weight: bold;
              margin-top:0; }
  .todo   { font-family: monospace; color: red; }
  .done   { font-family: monospace; color: green; }
  .priority { font-family: monospace; color: orange; }
  .tag    { background-color: #eee; font-family: monospace;
            padding: 2px; font-size: 80%; font-weight: normal; }
  .timestamp { color: #bebebe; }
  .timestamp-kwd { color: #5f9ea0; }
  .org-right  { margin-left: auto; margin-right: 0px;  text-align: right; }
  .org-left   { margin-left: 0px;  margin-right: auto; text-align: left; }
  .org-center { margin-left: auto; margin-right: auto; text-align: center; }
  .underline { text-decoration: underline; }
  #postamble p, #preamble p { font-size: 90%; margin: .2em; }
  p.verse { margin-left: 3%; }
  pre {
    border: 1px solid #e6e6e6;
    border-radius: 3px;
    background-color: #f2f2f2;
    padding: 8pt;
    font-family: monospace;
    overflow: auto;
    margin: 1.2em;
  }
  pre.src {
    position: relative;
    overflow: auto;
  }
  pre.src:before {
    display: none;
    position: absolute;
    top: -8px;
    right: 12px;
    padding: 3px;
    color: #555;
    background-color: #f2f2f299;
  }
  pre.src:hover:before { display: inline; margin-top: 14px;}
  /* Languages per Org manual */
  pre.src-asymptote:before { content: 'Asymptote'; }
  pre.src-awk:before { content: 'Awk'; }
  pre.src-authinfo::before { content: 'Authinfo'; }
  pre.src-C:before { content: 'C'; }
  /* pre.src-C++ doesn't work in CSS */
  pre.src-clojure:before { content: 'Clojure'; }
  pre.src-css:before { content: 'CSS'; }
  pre.src-D:before { content: 'D'; }
  pre.src-ditaa:before { content: 'ditaa'; }
  pre.src-dot:before { content: 'Graphviz'; }
  pre.src-calc:before { content: 'Emacs Calc'; }
  pre.src-emacs-lisp:before { content: 'Emacs Lisp'; }
  pre.src-fortran:before { content: 'Fortran'; }
  pre.src-gnuplot:before { content: 'gnuplot'; }
  pre.src-haskell:before { content: 'Haskell'; }
  pre.src-hledger:before { content: 'hledger'; }
  pre.src-java:before { content: 'Java'; }
  pre.src-js:before { content: 'Javascript'; }
  pre.src-latex:before { content: 'LaTeX'; }
  pre.src-ledger:before { content: 'Ledger'; }
  pre.src-lisp:before { content: 'Lisp'; }
  pre.src-lilypond:before { content: 'Lilypond'; }
  pre.src-lua:before { content: 'Lua'; }
  pre.src-matlab:before { content: 'MATLAB'; }
  pre.src-mscgen:before { content: 'Mscgen'; }
  pre.src-ocaml:before { content: 'Objective Caml'; }
  pre.src-octave:before { content: 'Octave'; }
  pre.src-org:before { content: 'Org mode'; }
  pre.src-oz:before { content: 'OZ'; }
  pre.src-plantuml:before { content: 'Plantuml'; }
  pre.src-processing:before { content: 'Processing.js'; }
  pre.src-python:before { content: 'Python'; }
  pre.src-R:before { content: 'R'; }
  pre.src-ruby:before { content: 'Ruby'; }
  pre.src-sass:before { content: 'Sass'; }
  pre.src-scheme:before { content: 'Scheme'; }
  pre.src-screen:before { content: 'Gnu Screen'; }
  pre.src-sed:before { content: 'Sed'; }
  pre.src-sh:before { content: 'shell'; }
  pre.src-sql:before { content: 'SQL'; }
  pre.src-sqlite:before { content: 'SQLite'; }
  /* additional languages in org.el's org-babel-load-languages alist */
  pre.src-forth:before { content: 'Forth'; }
  pre.src-io:before { content: 'IO'; }
  pre.src-J:before { content: 'J'; }
  pre.src-makefile:before { content: 'Makefile'; }
  pre.src-maxima:before { content: 'Maxima'; }
  pre.src-perl:before { content: 'Perl'; }
  pre.src-picolisp:before { content: 'Pico Lisp'; }
  pre.src-scala:before { content: 'Scala'; }
  pre.src-shell:before { content: 'Shell Script'; }
  pre.src-ebnf2ps:before { content: 'ebfn2ps'; }
  /* additional language identifiers per "defun org-babel-execute"
       in ob-*.el */
  pre.src-cpp:before  { content: 'C++'; }
  pre.src-abc:before  { content: 'ABC'; }
  pre.src-coq:before  { content: 'Coq'; }
  pre.src-groovy:before  { content: 'Groovy'; }
  /* additional language identifiers from org-babel-shell-names in
     ob-shell.el: ob-shell is the only babel language using a lambda to put
     the execution function name together. */
  pre.src-bash:before  { content: 'bash'; }
  pre.src-csh:before  { content: 'csh'; }
  pre.src-ash:before  { content: 'ash'; }
  pre.src-dash:before  { content: 'dash'; }
  pre.src-ksh:before  { content: 'ksh'; }
  pre.src-mksh:before  { content: 'mksh'; }
  pre.src-posh:before  { content: 'posh'; }
  /* Additional Emacs modes also supported by the LaTeX listings package */
  pre.src-ada:before { content: 'Ada'; }
  pre.src-asm:before { content: 'Assembler'; }
  pre.src-caml:before { content: 'Caml'; }
  pre.src-delphi:before { content: 'Delphi'; }
  pre.src-html:before { content: 'HTML'; }
  pre.src-idl:before { content: 'IDL'; }
  pre.src-mercury:before { content: 'Mercury'; }
  pre.src-metapost:before { content: 'MetaPost'; }
  pre.src-modula-2:before { content: 'Modula-2'; }
  pre.src-pascal:before { content: 'Pascal'; }
  pre.src-ps:before { content: 'PostScript'; }
  pre.src-prolog:before { content: 'Prolog'; }
  pre.src-simula:before { content: 'Simula'; }
  pre.src-tcl:before { content: 'tcl'; }
  pre.src-tex:before { content: 'TeX'; }
  pre.src-plain-tex:before { content: 'Plain TeX'; }
  pre.src-verilog:before { content: 'Verilog'; }
  pre.src-vhdl:before { content: 'VHDL'; }
  pre.src-xml:before { content: 'XML'; }
  pre.src-nxml:before { content: 'XML'; }
  /* add a generic configuration mode; LaTeX export needs an additional
     (add-to-list 'org-latex-listings-langs '(conf " ")) in .emacs */
  pre.src-conf:before { content: 'Configuration File'; }

  table { border-collapse:collapse; }
  caption.t-above { caption-side: top; }
  caption.t-bottom { caption-side: bottom; }
  td, th { vertical-align:top;  }
  th.org-right  { text-align: center;  }
  th.org-left   { text-align: center;   }
  th.org-center { text-align: center; }
  td.org-right  { text-align: right;  }
  td.org-left   { text-align: left;   }
  td.org-center { text-align: center; }
  dt { font-weight: bold; }
  .footpara { display: inline; }
  .footdef  { margin-bottom: 1em; }
  .figure { padding: 1em; }
  .figure p { text-align: center; }
  .equation-container {
    display: table;
    text-align: center;
    width: 100%;
  }
  .equation {
    vertical-align: middle;
  }
  .equation-label {
    display: table-cell;
    text-align: right;
    vertical-align: middle;
  }
  .inlinetask {
    padding: 10px;
    border: 2px solid gray;
    margin: 10px;
    background: #ffffcc;
  }
  #org-div-home-and-up
   { text-align: right; font-size: 70%; white-space: nowrap; }
  textarea { overflow-x: auto; }
  .linenr { font-size: smaller }
  .code-highlighted { background-color: #ffff00; }
  .org-info-js_info-navigation { border-style: none; }
  #org-info-js_console-label
    { font-size: 10px; font-weight: bold; white-space: nowrap; }
  .org-info-js_search-highlight
    { background-color: #ffff00; color: #000000; font-weight: bold; }
  .org-svg { }
</style>
</head>
<body>
<div id="content" class="content">
<h1 class="title">The Seasoned Schemer Notes
<br />
<span class="subtitle">Chapter 14</span>
</h1>
<div id="table-of-contents" role="doc-toc">
<h2>Table of Contents</h2>
<div id="text-table-of-contents" role="doc-toc">
<ul>
<li><a href="#prerequisites">1. Prerequisites</a></li>
<li><a href="#chapter-15">2. Chapter 15</a>
<ul>
<li><a href="#about">2.1. About</a></li>
<li><a href="#expression-value">2.2. About the value of expressions</a></li>
<li><a href="#differences-define-set-bang">2.3. Differences between <code class="src src-scheme">define</code> and <code class="src src-scheme">set!</code></a></li>
<li><a href="#remembering-things">2.4. Making procedures remember things</a>
<ul>
<li><a href="#assignment-warning">2.4.1. A warning</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>

<div id="outline-container-prerequisites" class="outline-2">
<h2 id="prerequisites"><span class="section-number-2">1.</span> Prerequisites</h2>
<div class="outline-text-2" id="text-prerequisites">
<p>
<code class="src src-scheme">atom?</code> checks, whether a thing is a non-compound thing, at least for simple code, that does not make use of vector and such things.
</p>

<div class="org-src-container">
<pre class="src src-scheme" id="org67c376c">(define atom?
  (λ (x)
    (and (not (pair? x))
         (not (null? x)))))
</pre>
</div>
</div>
</div>

<div id="outline-container-chapter-15" class="outline-2">
<h2 id="chapter-15"><span class="section-number-2">2.</span> Chapter 15</h2>
<div class="outline-text-2" id="text-chapter-15">
</div>

<div id="outline-container-about" class="outline-3">
<h3 id="about"><span class="section-number-3">2.1.</span> About</h3>
<div class="outline-text-3" id="text-about">
<p>
Chapter 15 deals with usage of assignment (<code class="src src-scheme">set!</code>). It explains when usage of <code class="src src-scheme">set!</code> can be kind of safe (at least in a single threaded scenario). It arrives at some rules (commandments) for <code class="src src-scheme">set!</code> usage.
</p>
</div>
</div>

<div id="outline-container-expression-value" class="outline-3">
<h3 id="expression-value"><span class="section-number-3">2.2.</span> About the value of expressions</h3>
<div class="outline-text-3" id="text-expression-value">
<p>
Usually expressions have a value. Exempt from this rule are <code class="src src-scheme">define</code> and the assignment <code class="src src-scheme">set!</code>, which makes them special.
</p>
</div>
</div>

<div id="outline-container-differences-define-set-bang" class="outline-3">
<h3 id="differences-define-set-bang"><span class="section-number-3">2.3.</span> Differences between <code class="src src-scheme">define</code> and <code class="src src-scheme">set!</code></h3>
<div class="outline-text-3" id="text-differences-define-set-bang">
<p>
While <code class="src src-scheme">define</code> can be used in many but not all contexts, <code class="src src-scheme">set!</code> can be used in any context (but really should not).
</p>

<p>
One important difference is, that <code class="src src-scheme">set!</code> can change values of bindings outside of the scope of the context it is used in. It depends on the binding it changes the value of to already exist (at least in GNU Guile it does), then changes the value forever. <code class="src src-scheme">define</code> works differently. It introduces a new binding that can shadow bindings from outer scopes, but once the scope the <code class="src src-scheme">define</code> is used in is left, the previously shadowed binding becomes visibile again.
</p>
</div>
</div>

<div id="outline-container-remembering-things" class="outline-3">
<h3 id="remembering-things"><span class="section-number-3">2.4.</span> Making procedures remember things</h3>
<div class="outline-text-3" id="text-remembering-things">
<p>
<code class="src src-scheme">set!</code> can be used to make procedures remember things. For example:
</p>

<div class="org-src-container">
<pre class="src src-scheme" id="orgdef1218">(define memory 'still-empty)
(define rememberer
  (λ (. something-to-remember)
    (when (not (null? something-to-remember))
      (set! memory something-to-remember))
    (cons something-to-remember
          (cons memory '()))))
</pre>
</div>

<div class="org-src-container">
<pre class="src src-scheme" id="org51a3dac">
(simple-format #t "~a\n" (rememberer 'something-heartwarming))
(simple-format #t "memory contains: ~a\n" memory)
(newline)

(simple-format #t "~a\n" (rememberer 'another-great-recollection))
(simple-format #t "memory contains: ~a\n" memory)
(newline)

(simple-format #t "~a\n" (rememberer))
(simple-format #t "memory still contains: ~a\n" memory)
</pre>
</div>

<pre class="example" id="org108b01a">
((something-heartwarming) (something-heartwarming))
memory contains: (something-heartwarming)

((another-great-recollection) (another-great-recollection))
memory contains: (another-great-recollection)

(() (another-great-recollection))
memory still contains: (another-great-recollection)
</pre>
</div>

<div id="outline-container-assignment-warning" class="outline-4">
<h4 id="assignment-warning"><span class="section-number-4">2.4.1.</span> A warning</h4>
<div class="outline-text-4" id="text-assignment-warning">
<p>
Note however, that this kind of usage of <code class="src src-scheme">set!</code> changes the fundamental character of our definitions. Instead of always returning the same result for the same input, our procedure definitions can now — depending on their memorized things — return different results even though the input is the same. As such they are no longer akin to mathematical functions, which has hugely negative implications for their usage.
</p>

<p>
For example there can be complications, when a binding is changed from more than 1 place in the code, especially when concurrency is involved. Procedures might return unexpected results, due to some other part of the code assigning a new value, changing the value a binding is associated with. This might not seem so dramatic initially, but wait until you want to run code concurrently &#x2026; Then suddenly code cannot simply run concurrently, but needs to be changed to be still correct. Either the whole algorithm implemented has to be changed, or some kind of mutex needs to be introduced, to avoid concurrent code executions messing up each others results. If possible one should avoid the need to change the code.
</p>
</div>
</div>
</div>
</div>
</div>
<div id="postamble" class="status">
<p class="date">Date: 2023-02-26 Sun 00:00</p>
<p class="author">Author: Zelphir Kaltstahl</p>
<p class="date">Created: 2023-11-26 Sun 17:13</p>
<p class="validation"><a href="https://validator.w3.org/check?uri=referer">Validate</a></p>
</div>
</body>
</html>