Snippet Zone

Concatenative JavaScript

```
const vars = {}
```
```
 
```
```
const as = s => v => vars[s] = v
```
```
 
```
```
const def = s => v => {
```
```
  vars[s] = v
```
```
}
```
```
 
```
```
const set = (last, prop, val) => {
```
```
  last[prop] = val
```
```
}
```
```
 
```
```
const put = (last, prop, val) => {
```
```
  last[prop] = val
```
```
  return last
```
```
}
```
```
 
```
```
const of = k => run.last[k]
```
```
const $ = k => () => vars[k]
```
```
 
```
```
const run = (prog, log) => {
```
```
  run.stack = []
```
```
  let curr
```

  for (let i = 0; i < prog.length; i++) {

```
    let val = prog[i]
```
```
    if (val != null && val === $) { 
```
```
      run.stack.push(val())
```

    } else if (typeof val === 'function') {

```
      let ctx = null
```
```
      if (document.body[val.name]) { 
```
```
        ctx = document.body 
```
```
        val = val.bind(ctx)
```
```
      } else if (document[val.name]) { 
```
```
        ctx = document
```
```
        val = val.bind(ctx)
```
```
      } 
```
```
 
```
```
      if (log) console.log('exec', 
```

        val.name == 'bound ' ? '\u03BB' : val.name, run.stack)

```
 
```
```
      curr = val.apply(ctx, run.stack)
```
```
      if (curr != run.stack) { 
```

        run.stack = curr != null ? [curr] : []

```
        if (typeof curr === 'object') {
```
```
          run.last = curr
```
```
        }
```
```
      }
```
```
    } else {
```

      if (val != null) run.stack.push(val)

```
    }
```
```
  }
```
```
}
```
```
 
```
```
const showStack = () => {
```
```
  console.log('- stack:', run.stack)
```

  console.log('  -> last object', run.last)

```
  return run.stack
```
```
}
```
```
 
```
```
const _ = new Proxy({}, { 
```
```
  get: (o, key) => (() => (...a) => 
```
```
    run.last[key].apply(run.last, a)
```
```
  )()
```
```
})
```
```
 
```
```
// try it out
```
```
 
```
```
run( 
```
```
  [ 'div', 
```
```
    document.createElement, 
```
```
    document.body.appendChild, 
```
```
    as`myDiv`,
```

    'innerHTML', 'mini <b>concatenative</b>', set,

```
    'style', of, 'color', 'green', set,
```
```
 
```

    'just logging the element', $`myDiv`, console.log,

```
 
```
```
    'canvas', document.createElement, 
```
```
    document.body.appendChild, 
```
```
    'width', 500, put,
```
```
    'height', 500, put,
```
```
    def`myCanvas`,
```
```
 
```
```
    '2d',
```
```
    _.getContext,
```
```
    'fillStyle', 'red', set,
```
```
    100, 30, _.translate,
```
```
    0, 0, 10, 100, _.fillRect,
```
```
    20, 0, 10, 100, _.fillRect,
```
```
    .2, _.rotate,
```
```
    -30, 25, 100, 10, _.fillRect,
```
```
    -20, 55, 100, 10, _.fillRect,
```
```
 
```
```
    {}, 
```
```
    'name', 'zevan', put,
```
```
    'age', 82, put,
```
```
    JSON.stringify,
```
```
    as`person`,
```
```
 
```
```
    showStack
```
```
  ]
```
```
)
```
```
console.log(vars);
```

I recently spent some time reading about and playing with the FORTH language. I keep finding myself creating weird vaguely FORTH inspired snippets now… This one processes an array that’s in a concatenative format like this:


[ 'hello world', Date.now(), console.log ]

Arguments are collected on a stack and passed to a function when a function is hit in the array. There are some odd helper functions for setting properties, setting nested properties, running functions with a specific context etc…

Here is GPT4’s mostly correct explanation of what it does

This is a rather unusual piece of JavaScript code that creates a simple “programming language” based on the concept of a stack machine, and runs a “program” in this language. It resembles some sort of DSL (domain-specific language) or script-like construct.

Here are what the main components do:

vars: This is a dictionary that stores variables defined in the program.

as: This is a function that takes a string s and returns a function that takes a value v, storing v in vars under the key s.

def: Similar to as, it defines a variable in vars.

set: This function is used to set the property of an object. It takes the object last, the property name prop, and the value val, and assigns val to the property prop of the object last.

put: Similar to set, it sets the property of an object and returns the updated object.

of: This function gets the property with name k of the last object returned by the program.

$: This function is a getter for variables in vars.

run: This is the main function that runs the program. The program is an array of actions, where an action can be a function, an object with a name of ‘get’ (which pushes the result of calling the function onto the stack), or a value (which is pushed onto the stack).

showStack: This function logs the current state of the stack and the last object returned.

_: This creates a new Proxy object that allows arbitrary methods to be called on the last object returned by the program.

The run function is then called with a list of actions to perform. The actions include creating a div and canvas element, appending them to the body of the document, setting their properties, and drawing on the canvas. It also creates an object with a name and age, converts it to JSON, and stores it in a variable. Finally, it shows the state of the stack and logs all the variables.

July 23, 2023

// arrays // hacks // humor // javascript // meta // obfuscation // oldschool // proxies // speed-coded // speedcoding

Snippet Zone Code Highlighter

I wrote a naive syntax highlighter a few weeks ago. Here it is rendering the code for itself. :

This is not a perfect highlighter, but it was fun to create and I will definitely use it in the Snippet Zone Github repository once I get that set up.

There is some css that goes with the highlighter, it’s pretty boring, but here it is anyway:

```
.hh {
```
```
  white-space: pre-wrap;
```
```
  font-family: monaco, monospace;
```
```
  line-height: 1.5;
```
```
  font-size: .8em;
```
```
  background: rgb(3, 21, 36);
```
```
  color: rgba(156, 221, 254, 1);
```
```
  padding: 1em;
```
```
}
```
```
 
```
```
.hh b {
```
```
  font-weight: normal;
```
```
}
```
```
 
```
```
.hh i {
```
```
  color: #1ad6ae;
```
```
}
```
```
 
```
```
.hh u {
```
```
  color: rgb(255, 195, 252);
```
```
  text-decoration: none;
```
```
}
```
```
 
```
```
.num {
```
```
  color: #b5cea8;
```
```
}
```
```
 
```
```
.str, .str b  {
```
```
  color: #ce9178;
```
```
}
```
```
 
```
```
.par {
```
```
  color: white;
```
```
  font-weight: bold;
```
```
}
```
```
 
```
```
.brk {
```
```
  color: white;
```
```
  font-weight: bold;
```
```
}
```
```
 
```
```
.o {
```
```
  color: rgb(0, 151, 221);
```
```
}
```
```
 
```
```
.obj {
```
```
  color: rgb(52, 206, 47);
```
```
  font-weight: bold !important;
```
```
}
```
```
 
```
```
.w {
```
```
  color: #1ad6ae;
```
```
  font-style: italic;
```
```
}
```
```
 
```
```
.k {
```
```
  color: aqua;
```
```
}
```
```
 
```
```
.cmt {
```
```
  color: gray !important;
```
```
}
```
```
.cmt b {
```
```
  color: gray !important;
```
```
}
```

I have no idea why I used such bad class names there 😛

September 28, 2021

// css // dom // javascript // meta // strings // ui

console.log Hijack

```
const log = console.log;
```

const consoleUI = document.body.appendChild(

```
  document.createElement('div')
```
```
);
```
```
document.body.style.margin = 0;
```
```
Object.assign(consoleUI.style, {
```
```
  position: 'fixed',
```
```
  bottom: 0,
```
```
  width: '100%',
```
```
  height: '30%',
```
```
  maxHeight: '450px',
```
```
  minHeight: '200px',
```
```
  background: 'rgb(68, 68, 81)',
```
```
  overflow: 'scroll'
```
```
});
```
```
function consoleRow(str) {
```

  const row = document.createElement('div');

```
  consoleUI.prepend(row);
```
```
  row.innerText = str;
```
```
  Object.assign(row.style, {
```
```
    padding: '.5em',
```
```
    fontFamily: 'sans-serif',
```
```
    color: 'white',
```

    borderBottom: '1px solid rgba(255, 255, 255, .1)',

```
    whiteSpace: 'pre-wrap'
```
```
  });
```
```
}
```
```
 
```
```
console.log = (...args) => {
```
```
  const formatted = args.map(val => {
```
```
    return typeof val === 'object' ? 
```

      JSON.stringify(val, null, 2) : val;

```
  });
```
```
  consoleRow(formatted.join(' '));
```
```
  log.apply(console, args);
```
```
};
```
```
 
```
```
// test it out
```
```
 
```
```
console.log(1, 2, 3, 4);
```
```
console.log(new Date());
```
```
 
```
```
const someObject = {
```
```
  test: 123,
```
```
  testing: { x: 1, y: 2, z: 3 }
```
```
};
```
```
console.log(someObject);
```
```
 
```
```
console.log(3, 2, 1, 0);
```

I’m thinking about adding a little fake console to the Snippet Zone Quick Editor – just whipped this up as a proof of concept – something like this should work…

August 30, 2021

// css // hacks // javascript // meta // strings // tricks // ui

Concatenative JavaScript

Here is GPT4’s mostly correct explanation of what it does

Snippet Zone Code Highlighter

console.log Hijack

Recent

Archive