djedr

This gist expands on this Hacker News reply.

---

The official Jevko spec is meant to be fully generic, but in fact if you don't care about that then you can use this simplifed grammar to start (ABNF + RegExp):

tree = *sub text
sub  = text '[' tree ']'
text = /[^\[\]]*/

djedr

This was originally a short reply to a toot by @rauschma@fosstodon.org, but it kinda grew.

Let me first quote the original toot:

Interesting difference when creating #JavaScript numbers:

Before number literals, plus and minus are unary operators (that coerce to number) and not part of the literal: https://tc39.es/ecma262/#sec-literals-numeric-literals

> +5 >

djedr

const smartQueryString = ((strs, ...params) => {
  let ret = ''
  for (let i = 0; i < strs.length - 1; ++i) {
    const str = strs[i]
    const param = params[i]
    // or whatever escaping method is appropriate
    ret += str + encodeURIComponent(param)
  }
  return ret
})

djedr

This is as part of a comment on a post on Hacker News "Ron: Rusty Object Notation".

The following examples from https://github.com/ron-rs/ron

GameConfig( // optional struct name
    window_size: (800, 600),
    window_title: "PAC-MAN",
    fullscreen: false,
    

djedr

The main tricks I came up with in LAST are precisely basing it on quaternary and making up S-optimization. The former allows for streamlining of the basic BLC interpreter design (the 4 paths that handle the basic term elements are simplified), while the latter capitalizes on that by reducing repetition (nb. making the whole thing more efficient). I spent quite a bit of time working out and automating S-optimimization -- which is certainly the most interesting aspect of LAST and what sets it apart from RFNHS3 or other LC variants. I think it's pretty neat.

So of course if we get rid of the quaternary input, we'll immediately lose the advantage.

I noticed that using two separate tokens for variable handling allows BLC to interpret LAST in only 193 bits.

I think you can get that down to 181 bits, assuming 1:1 translation of S-deoptimized version of the LAST self-interpreter into BLC syntax (so not a valid BLC program, because the assumed input is different). Anyway 193 bits is also nice and I like how it's

djedr

// run this script with
//
//     node --experimental-network-imports easyjevko.js
//
// on Node.js or
//
//     deno run --allow-net easyjevko.js
//
// on Deno

djedr

Value = Subvalues Suffix
Subvalue = Prefix "[" Value "]"

Subvalues = *Subvalue
Suffix = *Char
Prefix = *Char

Char = Escape / %x0-5a / %x5c / %x5e-5f / %x61-10ffff
Escape = "`" ("`" / "[" / "]")

djedr

// A simplistic parser for an imaginary XSV format -- a simplified, configurable variant of CSV
// where the first 3 characters specify (in order): 
// 1. the escape character (a backslash "\" in the example below)
// 2. the column separator (a comma "," in the example below)
// 3. the row separator (a newline character "\n" in the example below)
const parseXsv = (input) => {
  console.assert(input.length >= 3)
  const escape = input[0]
  const columnSeparator = input[1]
  const rowSeparator = input[2]

djedr

Static types and JavaScript

2017-03-08

Dariusz Jędrzejczak

http://djedr.github.io

This is a quick overview and comparison of TypeScript and Flow compiled from different sources (see links throughout and at the end of this document).

djedr

General-purpose text preprocessing with the C preprocessor. Featuring JavaScript.

2017-02-15 Dariusz Jędrzejczak

http://djedr.github.io

---

Outline