💐 Repl Driven Development: /Editor Integrated REPLs for all languages/ 🔁

;; Press “control and x, then control and e” to run the following code
(message-box "hello world")

;; C-x C-p now evaluates arbitrary Python code
(repl-driven-development [C-x C-p] "python3")

import os                       # ⇒ Module OS imported
f"Hello, {os.environ['USER']}!"  # ⇒ “Hello, musa!”

# Ensure we have some GUI capabilities installed; press “C-x C-e”:
# (async-shell-command "brew install python-tk")

import turtle
it = turtle.Turtle()  # This opens a new window

# The following fragment was “discovered” by trying things out repeatedly with “C-x C-p”.
for i in range(10):
    it.pencolor("green" if i % 2 == 0 else "red")
    it.pensize(i / 2)
    it.circle(i * 10)


# Note for Python, the above “for” loop is “complete” if we also send the extra
# newline after it.

/** Alter the contents of a JSON file as if it were a JavaScript object.
 *
 * - `path : string` is a filepath to a `.json` file.
 * - `callback : function` is a (possibly async) function that mutates a given JS object.
 * - `newFile : boolean` indicates whether this is a completely new file, in which case `callback` is provided with an empty object.
 *
 * Trying to access a JSON file that does not exist, when not enabling `newFile`, will result in an error.
 *
 * Write the JSON file, and format it nicely.
 *
 * ### Example use
 * ```
 * // Add a new `WOAH` key to the configuration file.
 * withJSON("~/myConfig.json", data => data.WOAH = 12)
 * ```
 *
 * ### Warning! ---Also Design Decision Discussion
 *
 * A purely functional approach would require `callback` to have the shape `data => {...; return data}`.
 * However, we anticipate that most uses will be to update a field of `data` and so `callback` will
 * have the shape `data => {data.x = y; return data}` and we want to reduce the ceremony: We work with mutable references,
 * so that `data => data.x = y` is a sufficient shape for `callback`. However, this comes at the cost that we cannot
 * wholesale alter a JSON file ---which is an acceptable tradeoff, since this is likely a rare use case.
 *
 * ```
 * withJSON(`~/myfile.json`, data => data = {x: 1, y: 2})      // BAD! Will not alter the underyling JSON file.
 * withJSON(`~/myfile.json`, data => {data.x = 1; data.y = 2}) // GOOD!
 * ```
 *
 * A program should not just compute, it should also motivate, justify & discuss.
 * This human nature makes it easier to follow, detect errors, use elsewhere, or extend.
 * After all, the larger part of the life of a piece of software is maintenance.
 *
 * Flawed programs with good discussion may be of more use in the development of related correct code,
 * than working code that has no explanation.
 */
function withJSON(file, callback, newFile) {
  file = file.replace(/~/g, process.env.HOME)
  try {
    let data = newFile ? {} : JSON.parse(fs.readFileSync(file))
    callback(data)
    fs.writeFileSync(file, JSON.stringify(data, null, 2))
  } catch (error) {
    console.error(`🤯 Oh no! ${error}`)
    console.error(callback.toString())
    process.exit(0)
  }
}

/** Run a shell command and provide its result as a string; or crash when there's an error.
 * This is intentionally synchronous; i.e., everything stops until the command is done executing.
 *
 * @param {string} command - A Unix bash incantation to be executed.
 * @param {boolean} ignore - Whether to actually avoid doing any execution; useful for testing/experimentation.
 * @returns {string} The textual stdout result of executing the given command.
 *
 * - TODO: Consider switching to ShellJS.
 * - Why ShellJS? https://julialang.org/blog/2012/03/shelling-out-sucks/
 * - See also `Executing shell commands from Node.js`, https://2ality.com/2022/07/nodejs-child-process.html
 *
 * ### Examples
 * ```
 * // Who is the current user?
 * console.log( shell('whoami') )
 *
 * // Make me smile!
 * console.log( shell('fortune') )
 *
 * // See your Git credentials: Name, email, editor, etc.
 * shell("git config --list")
 *
 * // Crashes if the provided command does not exist
 * shell(`nonexistentprogram`); console.log(`You wont see this msg!`) // Boom!
 *
 * // Pass non-falsy second argument to invoke as a dry-run only
 * shell(`nonexistentprogram`, true); console.log(`You WILL see this msg!`)
 * ```
 *
 * Consider a program to be written primarily to explain to another human what it is that we want the computer to do,
 * how it is to happen, and why we can believe that we have achievied our aim.
 * (The “another human” might be you in a few months time when the details have escaped your mind.)
 */
function shell(command, ignore) {
  return ignore
    ? `\n🤖 This is a DRY RUN, so I haven't done anything but I would have:\n🧪🧪🧪\n${command}\n🧪🧪🧪`
    : require('child_process').execSync(command).toString().trim()
}

/** NodeJS dislikes `~` in file paths, so this helper lets you read files with `~` in their path.
 * @param {string} path - The (possibily relative) path to a file
 * @returns {string} The contents of the file located at the given path
 */
function readFile(path) {
  return fs.readFileSync(path.replace(/~/, process.env.HOME))
}

var axios = require('axios')
var { name, blog, bio } = (await axios.get('https://api.github.com/users/alhassy')).data

execCmd("whoami")  // ==> "musa\n"

// Source: https://stackoverflow.com/a/20624914/3550444
public static String execCmd(String cmd) throws java.io.IOException {
    java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

record Person(String name) { }
var me = new Person("Musa"); // New instance.
 // Can operate on it, using a functional *variable* or a *method*
Function<Person, String> speak = p -> p.name() + " says HELLO!"
String greet(Person p) { return "Hello, I'm " + p.name(); }


// Redefining our data-type
record Person(int age) { }
//
// ⇒
//  record Person(int age) { }
// |  replaced record Person
// |    update replaced variable me which cannot be referenced until this error is corrected:
// |      incompatible types: java.lang.String cannot be converted to int
// |      var me = new Person("Musa");


// ⇒ As such, since “me” cannot be updated to be an instance of the reformulated data-type, it is kicked out of scope!
me    // ⇒ No such variable is declared!
speak // ⇒ No such *variable* is declared!
greet // ⇒ No problem, but can only run it if you define a  Person::name  instance method! 😲

greet(new Person(12)) // ⇒ Attempted to call method greet(Person) which cannot be
                      // invoked until method name() is declared

;; C-x C-j now evaluates arbitrary JavaScript code
(repl-driven-development [C-x C-j] "node -i")

1 + 2                                     // ⮕ 3

1 + '2'                                   // ⮕ '12'

let me = {name: 'Jasim'}; Object.keys(me) // ⮕ ['name']

me.doesNotExist('whoops')                 // ⮕ Uncaught TypeError

// First get stuff with C-x C-e:
// (async-shell-command "npm install -g express axios")

let app = require('express')()
let clicked = 1
app.get('/hi', (req, res) => res.send(`Hello World × ${clicked++}`))

let server = app.listen(3000)
// Now visit   http://localhost:3000/hi   a bunch of times!

// Better yet, see the output programmatically...
let axios = require('axios')
// Press C-x C-j a bunch of times on the following expression ♥‿♥
console.log((await axios.get('http://localhost:3000/hi')).data)

// Consider closing the server when you're done with it.
server.close()

;; C-x C-p now evaluates arbitrary Python code
(repl-driven-development [C-x C-p] "python3 -i")

1 + 2             # ⮕ 3

hello = 'world!'  # (No output; this is an effectful operation)

print(hello)      # ⮕ world!

2 + 'hi'          # 🚫 TypeError: unsupported operand type(s) for +

(repl-driven-development [C-x C-j] "jshell --enable-preview" :prompt "jshell>")

// Ensure you're not fullscreen, and you'll see a dialog window appear.
import javax.swing.*;
JOptionPane.showMessageDialog(new JFrame(), "Super nice!");

sealed interface Maybe {
    record None() implements Maybe {}
    record Just(int x) implements Maybe {}
}

var thisPrettyPrintsNicelyInTheREPL = new Maybe.Just(3);

new Maybe.Just(3).equals(new Maybe.Just(3)) // yay

;; C-x C-k now evaluates arbitrary Clojure code
(repl-driven-development [C-x C-k] "clojure" :prompt "user=>")

(+ 1 2) ;; ⮕ 3

(defn square [x] (* x x)) ;; ⮕ #'user/square
(square 3) ;; ⮕ 9

;; C-x C-h now evaluates arbitrary Haskell code
(repl-driven-development [C-x C-h] "ghci" :prompt "ghci>")

-- Sum of the first 100 squares
sum [ x ** 2 | x <- [1..100]] -- ⇒ 338350.0

-- The positive evens at-most 12
[x | x <- [1..12], x `mod` 2 == 0] -- [2,4,6,8,10,12]

-- Define a function...
myLast = head . reverse

-- Then use it...
myLast [1, 2, 3] -- ⇒ 3

1 + _A  -- ⇒ Found hole: _A::a; it :: forall {a}. Num a = a

;; C-x C-a now evaluates arbitrary Arend code
(repl-driven-development [C-x C-a]
                         (format "java -jar %s -i"
                                 (f-expand "~/Downloads/Arend.jar")))

1 Nat.+ 1 -- ⇒ 2
:type 4  -- ⇒ Fin 5

-- Declare a constant
\\func f => 1
:type f -- ⇒ Nat
f -- ⇒ 1

-- Declare a polymorphic identity function, then use it
\\func id {A : \\Type} (a : A) => a
id 12  -- ⇒ 12

-- Arend has “typed holes”
1 Nat.+ {?}  -- ⇒ Nat.+{?}: Goal: Expectedtype: Nat

;; C-x C-p now evaluates arbitrary PureScript code
(repl-driven-development [C-x C-p] "spago repl")

import Prelude

-- Define a function
add1 = (\x -> x + 1)

-- Use the function
add1 2    -- ⇒ 3

-- Experiment with a typed hole
1 + ?A  -- ⇒ Hole ?A has the inferred type Int

;; C-x C-i now evaluates arbitrary Idris code
(repl-driven-development [C-x C-i] "idris2")

-- Like Lisp, Idris uses “the” for type annotations
the Nat 4  -- ⇒ 4 : Nat

with List sum [1,2,3] -- ⇒ 6

-- defining a new type (REPL specific notation)
:let data Foo : Type where Bar : Foo

:t Bar -- ⇒ Foo

-- Experiment with a typed hole [Same notation as Haskell]
1 + ?A -- prim__add_Integer 1 ?A

;; C-x C-i now evaluates arbitrary Racket code
(repl-driven-development [C-x C-r] "racket -I slideshow")

(define (series mk) (hc-append 4 (mk 5) (mk 10) (mk 20)))

;; Shows 3 circles of increasing radius, in an external window
(show-pict (series circle))