fix: handle the TermEx->OptTermEx injection in Statix

Also move the signature of the semantic sort TYPE into its own
  file to facilitate sharing between Statix and Stratego.
  (Currently it is shared via symbolic link, but that may cause
  problems down the line; if/when it does, will have to look at
  physically copying the file into src-gen via an "Additional
  build step" using either Stratego or Ant.

  Also documents using Statix types from Stratego.

.drone.yml

@@ -29,18 +29,7 @@ steps:
       - java -jar /drone/lib/spt/org.metaborg.spt.cmd/target/org.metaborg.spt.cmd* -l . -s /drone/lib/spt/org.metaborg.meta.lang.spt -t tests
       - mkdir -p lib
       - curl -o lib/sunshine.jar -L 'http://artifacts.metaborg.org/service/local/artifact/maven/redirect?r=snapshots&g=org.metaborg&a=org.metaborg.sunshine2&v=LATEST'
-  - name: setup_gen
-    image: gcc
-    volumes:
-      - name: m2
-        path: /root/.m2
-    commands:
-      - git clone https://github.com/facebook/nailgun.git
-      - cd nailgun
-      - make
-      - cd ../bin
-      - ln -s ../nailgun/nailgun-client/target/ng .
-      - cd ..
+      - bin/fosgen tests/emit_sum.fos
   - name: extract_tests
     image: xonsh/xonsh
     commands:
@@ -52,8 +41,7 @@ steps:
         path: /drone/lib
       - name: m2
         path: /root/.m2
-    commands:  # Note we first make sure that fosgen is working
-      - bin/fosgen -d tests/emit_sum.fos
+    commands:
       - bin/generate_test_code
   - name: python_tests
     image: python:slim
@@ -67,13 +55,6 @@ steps:
     image: haskell
     commands:
       - bin/run_tests runghc hs
-  - name: ocaml_tests
-    image: ocaml/opam
-    commands:
-      - ls -als tests/extracted
-      - opam init
-      - eval $(opam env)
-      - bin/run_tests ocaml ml
 
 volumes:
   - name: lib

.gitignore

@@ -12,16 +12,10 @@
 
 .pydevproject
 
-a.out
-
 *.aterm
 /site
-bin/ng
 tests/extracted/*
 tests/*.js
 tests/*.py
 tests/*.hs
-tests/*.ml
-tests/*.cmi
-tests/*.cmo
 adhoc*

bin/extract_tests.xsh

@@ -13,16 +13,12 @@ DESTINATION = 'tests/extracted'
 # Extension for extracted files:
 EXT = 'fos'
 
-# Extension for desired input:
-INP = 'in'
-
 # Extension for expectations:
 EXP = 'expect'
 
 for path in TEST_LIST:
   destdir = pf"{DESTINATION}/{path.stem}"
   mkdir -p @(destdir)
-  chmod ugo+rwx @(destdir)
   contents = path.read_text()
   tests = re.split(r'test\s*(.+?)\s*\[\[.*?\n', contents)[1:]
   testit = iter(tests)
@@ -37,11 +33,6 @@ for path in TEST_LIST:
     expath = destdir / f"{name}.{EXT}"
     expath.write_text(example)
     echo Wrote @(expath)
-    im = re.search(r'/\*\*\s+accepts.*?\n([\s\S]*?)\*\*/', details[em.end():])
-    if im:
-      ipath = destdir / f"{name}.{INP}"
-      ipath.write_text(im[1])
-      echo "  ...and" @(ipath)
     xm = re.search(r'/\*\*\s+writes.*?\n([\s\S]*?)\*\*/', details[em.end():])
     if xm:
       xpath = destdir / f"{name}.{EXP}"

bin/fosgen

@@ -5,7 +5,6 @@ erro() { printf "%s\n" "$*" >&2; }
 
 ##### Set defaults:
 SUPPRESS_ERR=YES
-USE_NAILGUN=YES
 LANGUAGE=Python
 
 ##### Extract command line options:
@@ -15,23 +14,18 @@ do
     -h|--help)
       echo
       echo "Usage:"
-      echo "  fosgen [-d] [-j] [-l LANGUAGE] FILE"
+      echo "  fosgen [-d] [-l LANGUAGE] FILE"
       echo
       echo "Writes to standard output the code generated from the fostr"
       echo "program in FILE, targeting the specified LANGUAGE (which"
       echo "defaults to Python)."
       echo
       echo "The -d option writes diagnostic output to standard error."
-      echo "The -j option uses the Spoofax Sunshine JAR directly, rather"
-      echo "than via nailgun."
       exit
       ;;
     -d)
       SUPPRESS_ERR=''
       ;;
-    -j)
-      USE_NAILGUN=''
-      ;;
     -l)
       shift
       LANGUAGE="$1"
@@ -73,17 +67,5 @@ then
   exec 2>/dev/null
 fi
 
-if [[ $USE_NAILGUN ]]
-then
-  if [[ $SUPPRESS_ERR ]]
-  then
-    $BINDIR/let_sun_shine
-  else
-    $BINDIR/let_sun_shine noisy
-  fi
-  $BINDIR/ng sunshine transform -p $PROJDIR -n $LANGUAGE -i $PROGRAM
-  exit $?
-fi
-
 java -jar $SUNJAR transform -p $PROJDIR -l $PROJDIR -l $MVN_REPO -n $LANGUAGE -i $PROGRAM
 exit $?

bin/generate_test_code

@@ -4,7 +4,7 @@ failed=0
 
 for dir in tests/extracted/*; do
   for file in $dir/*.fos; do
-    for language in Python Javascript Haskell OCaml; do
+    for language in Python Javascript Haskell; do
       echo bin/fosgen -l ${language%.*} $file ...
       bin/fosgen -l $language $file
       if [[ $? -ne 0 ]]; then

bin/let_sun_shine

@@ -1,40 +0,0 @@
-#!/bin/bash
-
-# Helper for fosgen, not intended to be used directly
-# With an argument, print diagnostic output
-
-BINDIR=$(dirname $BASH_SOURCE)
-
-if $BINDIR/ng sunshine --help
-then
-  if [[ $1 ]]
-  then
-    echo "sun already shining."
-  fi
-else
-  if [[ $1 ]]
-  then
-    echo "disperse the clouds."
-  fi
-  SUNJAR="$BINDIR/../lib/sunshine.jar"
-  PROJDIR="$BINDIR/.."
-  if [[ ! $MVN_REPO ]]; then
-    MVN_REPO="$HOME/.m2/repository"
-  fi
-  if [[ ! -d $MVN_REPO ]]; then
-    MVN_REPO="/root/.m2/repository"
-  fi
-  if [[ ! -d $MVN_REPO ]]; then
-    echo "Cannot find your Maven repository. Please set environment variable"
-    echo "MVN_REPO to its full path and re-run."
-    exit 1
-  fi
-  if [[ $1 ]]
-  then 
-    java -jar $SUNJAR server & 
-  else
-    java -jar $SUNJAR server >/dev/null 2>&1 &
-  fi
-  sleep 5
-  $BINDIR/ng sunshine load -l $PROJDIR -l $MVN_REPO
-fi

bin/run_tests

@@ -9,14 +9,8 @@ diffed=0
 for dir in tests/extracted/*; do
   for file in $dir/*.$ext; do
     ((total++))
-    if [[ -f ${file%.*}.in ]]; then
-       cat ${file%.*}.in | $command $file > $file.out
-       result=$?
-    else
     $command $file > $file.out
-       result=$?
-    fi
-    if [[ $result -ne 0 ]]; then
+    if [[ $? -ne 0 ]]; then
       echo ERROR: $command $file failed.
       ((failed++))
     else

editor/Generation.esv

@@ -4,4 +4,3 @@ menus
     action: "Python"     = to-python
     action: "Javascript" = to-javascript
     action: "Haskell"    = to-haskell
-    action: "OCaml"      = to-ocaml

mkdocs.yml

@@ -9,7 +9,7 @@ plugins:
 - search
 - semiliterate:
     ignore_folders: [target, lib]
-    exclude_extensions: ['.o', '.hi', '.cmi', '.cmo']
+    exclude_extensions: ['.o', '.hi']
     extract_standard_markdown:
       terminate: <!-- /md -->
 theme:

syntax/fostr.sdf3

@@ -39,25 +39,17 @@ context-free syntax
 
   Ex.Int       = INT
   Ex.LitString = STRING_LITERAL
-  Ex.EscString = STRING
   Ex.Stream    = <stream>
   Ex.Sum       = <<Ex> +  <Ex>> {left}
-  Ex.Concat    = <<Ex> ++ <Ex>> {left}
   Ex.Gets      = [[Ex] << [Ex]] {left}
-  Ex.DefGets   = [<<< [Ex]]
   Ex.To        = [[Ex] >> [Ex]] {left}
-  Ex.DefTo     = [[Ex] >>>]
-  Ex.Emits     = <<Ex>!>
-  Ex.DefEmits  = <!!>
 
   Ex           = <(<Ex>)> {bracket}
 
 context-free priorities
 
   Ex.To
-  > Ex.DefTo
-  > {Ex.Sum Ex.Concat}
-  > Ex.DefGets
+  > Ex.Sum
   > Ex.Gets,
 
   // prevent cycle: no singletons

tests/basic.spt

@@ -16,21 +16,15 @@ Title: A whirlwind tour of fostr
 
 ## Whirlwind tour
 
-There seems only to be one way to start a tour like this. So here goes:
+fostr is just in its infancy, so it's not yet even ready for
+Hello, World. The best we can offer now is this little snippet
+that writes the sum of the ASCII codes for 'H', 'W', and '!' to standard output:
 ```fostr
 **/
 
-/** md */ test hello_world [[
-<<< 'Hello, world!'
-]] /* **/
-parse to TopLevel(DefGets(LitString("'Hello, world!'")))
-/** writes
-Hello, world!**/
-
-// Prior proto-hello-world, no longer in the tour.
-test emit_sum [[
+/** md */ test emit_sum [[
 stream << 72 + 87 + 33
-]]
+]] /* **/
 parse to TopLevel(Gets(Stream(), Sum(Sum(Int("72"), Int("87")), Int("33"))))
 /** writes
 192**/
@@ -39,7 +33,7 @@ parse to TopLevel(Gets(Stream(), Sum(Sum(Int("72"), Int("87")), Int("33"))))
 ```
 
 At the moment, there are only two ways to run a file containing fostr code
-(you can find the above in `tests/hw.fos`). They both start by
+(you can find the above in `tests/emit_sum.fos`). They both start by
 cloning this fostr project. Then, either:
 
 1. Open the project in Eclipse and build it, visit your program file,
@@ -52,70 +46,30 @@ cloning this fostr project. Then, either:
    
 For example, this snippet generates the following Python:
 ```python
-{! ../tests/hw.py extract:
+{! ../tests/emit_sum.py extract:
   start: 'Stdio\s='
 !}
 ```
-It generates nearly identical code in
-this simple example for Javascript (just with `"Hello, world!"`
-in place of `r'Hello, world!'`), although it generates a different
-preamble defining Stdio for each language. (Currently, Haskell and OCaml
-code generation are also supported.)
-
-There's not much to break down in such a tiny program as this, but let's do
-it. The prefix operator `<<<` could be read as "the default stream receives...",
-and unsurprisingly in a main program the default stream is standard input and
-output. And `'Hello, world!'` is a literal string constant; what you see is
-what you get. The only detail to know is that such constants must occur
-within a single line of your source file. So depending on how you
-ran the program and how closely you looked at its output,
-you may have noticed this program does not write a newline at the end
-of its message. Nothing is ever implicitly sent to a stream. So if you want
-newlines, you should switch to a (double-quoted) string that allows
-the usual array of escape sequences:
-
-```fostr
-**/
-
-/** md */ test hello_esc_world [[
-<<< "Hello,\t\tworld!\n\n"
-]] /* **/
-parse to TopLevel(DefGets(EscString("\"Hello,\t\tworld!\n\n\"")))
-/** writes
-Hello,		world!
-
-**/
-
-/** md
-```
-(We threw in two of each so you could clearly see them in the output if
-you run this program.)
+(which writes "192" to standard output); it also generates identical code in
+this simple example for
+Javascript, although it generates a different preamble defining Stdio in each
+case. (Haskell code generation is also currently supported.)
 
 ### Everything has a value
 
 As mentioned in the [Introduction](../README.md), everything in a fostr
 program (including the entire program itself) is an expression and has
-a value. So what's the value of that expression above? Well, for convenience,
-the value of a stream receiving an item is (generally) just the stream back
-again. That way we can use the general (left-associative)
-`_stream_ << _value_` operator to chain insertions into a stream:
+a value. So what's the value of that expression above? Well, appropriately
+enough, `stream` is our
+first example of a stream, and for convenience, the value of a stream
+receiving an item is (usually) just the stream back again. The `<<` operator
+is also left-associative, so that way we can chain insertions into a stream:
 ```fostr
 **/
 
-/** md */ test state_obvious [[
-<<< 'Two and ' << 2 << ' make ' << 2+2 << ".\n"
-]] /* **/
-parse to TopLevel(
-  Gets(Gets(Gets(Gets(DefGets(LitString("'Two and '")),Int("2")),
-                 LitString("' make '")),Sum(Int("2"),Int("2"))),
-       EscString("\".\n\"")))
-/** writes
-Two and 2 make 4.
-**/
-
-test emit_twice [[
+/** md */ test emit_twice [[
 stream << 72 + 87 + 33 << 291
-]]
+]] /* **/
 parse to TopLevel(
   Gets(Gets(Stream(), Sum(Sum(Int("72"), Int("87")), Int("33"))), Int("291")))
 /** writes
@@ -123,28 +77,24 @@ parse to TopLevel(
 
 /** md
 ```
+Running this program produces a nice palindromic output: "192291".
 
 And because sometimes you want to emphasize the value and propagate that
 instead of the stream, you can also write these expressions "the other way"
-with `>>>` for sending to the default stream or `>>` in general; these forms
-(generally) return the value sent, so the following writes "824":
+with `>>`; both forms return the first argument, so the following writes "824":
 ```fostr
 **/
 
 /** md */ test enters_twice [[
-(7 + 8 >> stream + 9) >>>
+(7 + 8 >> stream + 9) >> stream
 ]] /* **/
 parse to TopLevel(
-  DefTo(Sum(Sum(Int("7"), To(Int("8"), Stream())), Int("9"))))
+  To(Sum(Sum(Int("7"), To(Int("8"), Stream())), Int("9")), Stream()))
 /** writes
 824**/
 
 /** md
 ```
-Two things are worth noting here: the default stream can always be referred to
-directly via the identifier `stream`, and the precedences of `<<` and `>>` are
-different so that generally full expressions go to a stream with `<<` but
-just individual terms are sent with `>>`.
 
 ### Layout in fostr
 
@@ -154,13 +104,13 @@ lines are indented from the start of the initial line:
 **/
 
 /** md */ test receive_enter_break [[
-<<<
+stream <<
   7
-  + 8 >>>
+  + 8 >> stream
   + 9
 ]] /* **/
 parse to TopLevel(
-  DefGets(Sum(Sum(Int("7"), DefTo(Int("8"))), Int("9"))))
+  Gets(Stream(), Sum(Sum(Int("7"), To(Int("8"), Stream())), Int("9"))))
 /** writes
 824**/
 
@@ -171,8 +121,8 @@ parse to TopLevel(
 **/
 
 /** md */ test enter_receive_bad_continuation [[
-(7 + 8 >>> + 9)
->> (<<< 9 + 2)
+(7 + 8 >> stream + 9)
+>> (stream << 9 + 2)
 ]] /* **/
 parse fails
 
@@ -195,17 +145,16 @@ lines are evaluated in sequence. For example, the program
 **/
 
 /** md */ test emit_thrice [[
-  <<< 72 + 87
-  <<< 88
+  stream << 72 + 87
+  stream << 88
     + 96
-  99 + 12
-       >>>
-
+  99 + 12 >>
+          stream
 ]] /* **/
 parse to TopLevel(Sequence([
-  DefGets(Sum(Int("72"), Int("87"))),
-  DefGets(Sum(Int("88"), Int("96"))),
-  Sum(Int("99"), DefTo(Int("12")))
+  Gets(Stream(), Sum(Int("72"), Int("87"))),
+  Gets(Stream(), Sum(Int("88"), Int("96"))),
+  Sum(Int("99"), To(Int("12"), Stream()))
 ]))
 /** writes
 15918412**/
@@ -220,10 +169,10 @@ in sequence align at the left; e.g., the following fails to parse:
 **/
 
 /** md */ test emit_thrice_bad_alignment [[
-  <<< 72 + 87
-<<< 88
+  stream << 72 + 87
+stream << 88
     + 96
-  99 + 12 >>>
+  99 + 12 >> stream
 ]] /* **/
 parse fails
 
@@ -238,23 +187,23 @@ are so terminated. So the following is OK:
 **/
 
 /** md */ test emit_several [[
-  <<< 1 + 2; 3 >>>
-  (4 + 5) >>>; stream << 6;
-  <<< 7
-  <<< 8
+  stream << 1 + 2; 3 >> stream
+  (4 + 5) >> stream; stream << 6;
+  stream << 7
+  stream << 8
     + (9+10);
-  11 + 12 >>>; 13 >>>
-                  >>>
+  11 + 12 >> stream; 13 >> stream
+                        >> stream
 ]] /* **/
 parse to TopLevel(Sequence([
-  ISequence(Prior([Terminate(DefGets(Sum(Int("1"), Int("2"))))]),
-            DefTo(Int("3"))),
-  ISequence(Prior([Terminate(DefTo(Sum(Int("4"), Int("5"))))]),
+  ISequence(Prior([Terminate(Gets(Stream(), Sum(Int("1"), Int("2"))))]),
+            To(Int("3"), Stream())),
+  ISequence(Prior([Terminate(To(Sum(Int("4"), Int("5")), Stream()))]),
             Terminate(Gets(Stream(), Int("6")))),
-  DefGets(Int("7")),
-  Terminate(DefGets(Sum(Int("8"), Sum(Int("9"), Int("10"))))),
-  ISequence(Prior([Terminate(Sum(Int("11"), DefTo(Int("12"))))]),
-            DefTo(DefTo(Int("13"))))
+  Gets(Stream(), Int("7")),
+  Terminate(Gets(Stream(), Sum(Int("8"), Sum(Int("9"), Int("10"))))),
+  ISequence(Prior([Terminate(Sum(Int("11"), To(Int("12"), Stream())))]),
+            To(To(Int("13"), Stream()), Stream()))
 ]))
 /** writes
 3396727121313**/
@@ -282,49 +231,3 @@ run desugar-fostr to TopLevel(Sequence([
   Terminate(Sum(Int("11"), To(Int("12"), Stream()))),
   To(To(Int("13"), Stream()), Stream())
 ]))
-
-test emit_several_default [[
-<<< 1 + 2; 3 >>>
-(4 + 5) >>> >> stream; stream << 6;
-<<< 7 << 75
-<<< 8
-  + (9+10);
-11 + 12 >>>; 13 >>>
-                >>>
-]] parse succeeds
-/** writes
-3399677527121313**/
-
-/** md
-### Streams are bidirectional
-
-So far we have only sent items to a stream. But we can extract them from
-streams as well, with the `!` postfix operator. `!!` all by itself abbreviates
-`stream!`, i.e., extraction from the standard stream. For example,
-
-```fostr
-**/
-
-/** md */ test custom_hw [[
-<<< "What is your name?\n"
-<<< 'Hello, ' ++ !!
-]] /* **/
-parse to TopLevel(Sequence([
-  DefGets(EscString("\"What is your name?\n\"")),
-  DefGets(Concat(LitString("'Hello, '"),DefEmits()))
-]))
-/** accepts
-Kilroy
-**/
-/** writes
-What is your name?
-Hello, Kilroy
-**/
-
-/** md
-```
-
-queries users for their name and then writes a customized greeting. It also
-illustrates the use of `++` for string concatenation, as opposed to `+` for
-(numerical) addition.
-**/

tests/emit_several.fos

@@ -1,7 +1,7 @@
-<<< 1 + 2; 3 >>>
-(4 + 5) >>> >> stream; stream << 6;
-<<< 7 << 75
-<<< 8
+stream << 1 + 2; 3 >> stream
+(4 + 5) >> stream; stream << 6;
+stream << 7 
+stream << 8
   + (9+10);
-11 + 12 >>>; 13 >>>
-                >>>
+11 + 12 >> stream; 13 >> stream
+                      >> stream

tests/hw.fos

@@ -1 +1 @@
-<<< 'Hello, world!'
+stream << 'Hello,	world!'

tests/hw2.fos

@@ -1 +0,0 @@
-<<< "Hello,\t\tworld!\n\n"

trans/desugar.str

@@ -15,10 +15,7 @@ rules
 
   seqFlatten: Sequence(l) -> Sequence(<mapconcat(?Sequence(<id>) <+ ![<id>])>l)
   
-  defStream:  DefGets(x)  -> Gets(Stream(), x)
-  defStream:  DefTo(x)    -> To(x, Stream())
-  defStream:  DefEmits()  -> Emits(Stream())
-
 strategies
 
-  desugar-fostr = bottomup(try(defStream <+ deISe <+ seqFlatten))
+  desugar-fostr = bottomup(try(deISe <+ seqFlatten))
+ 

trans/fostr.str

@@ -6,7 +6,6 @@ imports
   pp
   outline
   analysis
-  ocaml
   haskell
   javascript
   python

trans/haskell.str

@@ -10,7 +10,7 @@ rules
         rule.
      C) We will use bottomup-para to traverse the full AST with the
         transformation from A so that we have access to the original expression
-        (and can get the Statix-associated type when we need to).
+        (and get get the Statix-associated type when we need to).
         Hence the transformation in (A) must actually take a pair of
         an (original) term and a term with value strings at each child,
         and be certain to return a value string.
@@ -19,11 +19,9 @@ rules
      returning the final value.
    */
 
-  hs: (_, TopLevel(val)) -> $[-- Preamble from fostr
-  import System.IO
+  hs: (_, TopLevel(val)) -> $[import System.IO
   data IOStream = StdIO
 
-  -- Danger: These currently assume the stream is StdIO
   gets :: Show b => a -> b -> IO a
   gets s d = do
     putStr(show d)
@@ -34,19 +32,13 @@ rules
     putStr(d)
     return s
 
-  emit s = do
-    l <- getLine
-    return (l ++ "\n")
-
   main = do
     [<Preactions>()]return [val]]
 
   hs: (_, Stream())     -> "StdIO"
   hs: (_, Int(x))       -> x
   hs: (_, LitString(x)) -> <haskLitString>x
-  hs: (_, EscString(x)) -> x
   hs: (_, Sum(x, y))    -> $[([x] + [y])]
-  hs: (_, Concat(x, y)) -> $[([x] ++ [y])]
 
   hs: (Gets(_, xn), Gets(s, x)) -> v
     with v := <newname>"_fostr_get"
@@ -58,10 +50,6 @@ rules
   hs_gets: (s, xn, x ) -> $[[s] [<hs_getOp>xn] [x]]
   hs_getOp = get-type; (?STRING() < !"`getsStr`" + !"`gets`")
 
-  hs: (_, Emits(s)) -> v
-    with v := <newname>"_fostr_emitted"
-       ; <add-preactions>[$[[v] <- emit [s]]]
-
   hs: (_, Terminate(x)) -> $[[x];;]
   hs: (_, Sequence(l))  -> <last>l
   /* One drawback of using paramorphism is we have to handle lists

trans/javascript.str

@@ -2,42 +2,21 @@ module javascript
 imports libstrategolib signatures/- util
 
 rules
-  js: TopLevel(x) -> $[// Fostr preamble
-  const _fostr_readline = require('readline');
-  const _fostr_events = require('events');
-  const _fostr_rl = _fostr_readline.createInterface({input: process.stdin});
-  const Stdio = {
+  js: TopLevel(x) -> $[const Stdio = {
     gets: v => { process.stdout.write(String(v)); return Stdio; },
-    emit: async () => {
-            const [line] = await _fostr_events.once(_fostr_rl, 'line');
-            return line + "\n"; }
   }
   function to(data, strm) {
     strm.gets(data);
     return data;
   }
-
-  const _fostr_body = async () => {
-  // End of preamble
-
-    [x]
-
-  // Fostr coda
-    _fostr_rl.close()
-  }
-  _fostr_body();
-  ]
-    with line := "[line]"
+  [x]]
 
   js: Stream()     -> $[Stdio]
   js: Int(x)       -> x
   js: LitString(x) -> <javaLitString>x
-  js: EscString(x) -> x
-  js: Sum(x, y)    -> $[[x] + [y]]
-  js: Concat(x, y) -> $[[x] + [y]]
+  js: Sum(x,y)     -> $[[x] + [y]]
   js: Gets(x, y)   -> $[[x].gets([y])]
   js: To(x, y)     -> $[to([x],[y])]
-  js: Emits(x)     -> $[(await [x].emit())]
   js: Terminate(x) -> x
   js: Sequence(l)  -> <join(|";\n")>l
 

trans/ocaml.str

@@ -1,66 +0,0 @@
-module ocaml
-imports libstrategolib signatures/- util signature/TYPE analysis
-
-/* Note will use bottomup-para to traverse the full AST so that
-   we have access to the original expression (and can get the
-   Statix-associated type when we need to).
-   
-   This means that every one of our local rules must take a pair
-   of an original term and a term with every child replaced by
-   its generated code.
- */
-
-rules
-  ml: (_, TopLevel(x)) -> $[(* fostr preamble *)
-  type stream = { getS: string -> stream; emitS: unit -> string }
-  let rec stdio = {
-    getS = (fun s -> print_string s; stdio);
-    emitS = (fun () -> (read_line ()) ^ "\n");
-  };;
-  (* End of preamble *)
-
-  [x]]
-
-  ml: (_, Stream())     -> $[stdio]
-  ml: (_, Int(x))       -> x
-  ml: (_, LitString(x)) -> $[{|[<un-single-quote>x]|}]
-  ml: (_, EscString(x)) -> x
-  ml: (_, Sum(x, y))    -> $[[x] + [y]]
-  ml: (_, Concat(x, y)) -> $[[x] ^ [y]]
-
-  ml: (Gets(_,yn), Gets(x, y))
-    -> $[([x]).getS ([<ml_str>(yn,y)])]
-  ml: (To(xn,_),   To(x, y))
-    -> $[let _fto = ([x]) in (ignore (([y]).getS ([<ml_str>(xn,"_fto")])); _fto)]
-  ml: (_, Emits(s))     -> $[[s].emitS ()]
-
-  ml: (_, Terminate(x)) -> x
-  ml: (_, Sequence(l))  -> <ml_seq>l
-  
-  ml_seq: [x] -> x
-  ml_seq: [x | xs ] -> $[ignore ([x]);
-[<ml_seq>xs]]
-
-  /* One drawback of using paramorphism is we have to handle lists
-     explicitly:
-   */
-  ml: (_, []) -> []
-  ml: (_, [x | xs]) -> [x | xs]
-
-  /* Another drawback of using paramorphism is at the very leaves we have
-     to undouble the tuple:
-   */
-  ml: (x, x) -> x where <is-string>x
-
-  ml_str: (node, code) -> $[[<ml_string_cast>node]([code])]
-
-strategies
-
-  ml_string_cast = get-type; (?INT() < !"string_of_int" + !"")
-
-  ocaml = bottomup-para(try(ml))
-
-  // Interface ocaml code generation with editor services and file system
-  to-ocaml: (selected, _, _, path, project-path) -> (filename, result)
-    with filename := <guarantee-extension(|"ml")> path
-       ; result   := <ocaml> selected

trans/python.str

@@ -2,31 +2,23 @@ module python
 imports libstrategolib signatures/- util
 rules
 
-  py: TopLevel(x) -> $[## Fostr preamble
-  import sys
+  py: TopLevel(x) -> $[import sys
   class StdioC:
     def gets(self, v):
       print(v, file=sys.stdout, end='')
       return self
-    def emit(self):
-      return input() + "\n" # Python inconsistently strips when using input
   def to(data,strm):
     strm.gets(data)
     return data
   Stdio = StdioC()
-  ## End of preamble
-
   [x]]
 
   py: Stream()     -> $[Stdio]
   py: Int(x)       -> x
   py: LitString(x) -> $[r[x]]
-  py: EscString(x) -> x
   py: Sum(x,y)     -> $[[x] + [y]]
-  py: Concat(x,y)  -> $[[x] + [y]]
   py: Gets(x, y)   -> $[[x].gets([y])]
   py: To(x, y)     -> $[to([x],[y])]
-  py: Emits(x)     -> $[[x].emit()]
   py: Terminate(x) -> $[[x];]
   py: Sequence(l)  -> <join(|"\n")>l
 

trans/statics.stx

@@ -184,19 +184,16 @@ constructor was trivial:
 
 Now typing literals is straightforward:
 ```statix
-{! "\git docs/statix_works:trans/statics.stx" extract:
-  start: '(.*ty_Ex.Int.*\s*)'
-  stop: '/. ../'
-!}
-```
   **/
 
+  /** md */
   ty_Ex(Int(_))       = INT().
   ty_Ex(LitString(_)) = STRING().
-  ty_Ex(EscString(_)) = STRING().
   ty_Ex(e@Stream())   = STREAM().
+  /* **/
 
   /** md
+```
 
 Finally we get to the binary operators, and here we use the pattern found in
 recent versions of the
@@ -222,13 +219,6 @@ This pattern lets us specify error messages.
     type_Ex(e2) == STREAM() | error $[Items may only be sent to Streams.]@e2.
   /* **/
 
-  ty_Ex(Concat(e1, e2)) = STRING() :-
-    type_Ex(e1) == STRING() | error $[Expression [e1] not String in concat.]@e1,
-    type_Ex(e2) == STRING() | error $[Expression [e2] not String in concat.]@e2.
-
-  ty_Ex(Emits(e)) = STRING() :- // At the moment, only stream is stdio
-    type_Ex(e) == STREAM() | error $[Only Streams may emit items.]@e.
-
   /** md
 ```