Keta

This article is not detailed enough and needs to be expanded. Please help us by adding some more information.

Keta is what happens when you mix the words "Keyboard" and "Tacit" together. The language is partially inspired by the tacit execution of Jelly, after I decided that the tutorial for Jelly was just too complicated. As I sometimes say: if you don't understand it, make your own!

It's a big ol' work in progress thus far, so I'll place some examples here:

Operators shown here are purely for design experimentation and may not reflect the final system of operators

Terminology

Nilad -> A function that doesn't take any inputs. Usually a constant
Single -> A function that only takes a single input
Infix -> A function that takes two arguments: left and right

Left argument -> the expression to the left of a function
Right argument -> the expression to the right of a function

Flow -> A complete line of blocks
Block -> A series of Nilads, Singles and Infixes

Examples

Make me a square!

Keg got 11 bytes on this challenge.

P[DD+s]S3

Expands to:

Shape(Palindromise(Add(Double(Double(input)), Space)), 3)

9 bytes (Keta) vs 11 bytes (Keg) .

Output Distinct Factor Cubiods

Keg didn't participate in this challenge

*R=
F?f^

Pseudo:

function f
    reduce the input via multiplication
    return that result equal to the input

function main
    generate factors of input
    filter list by above flow (f)

Swap good and bad

Keg got 7 bytes on this challenge (first place btw)

-"....

Note that this uses a reverse token flag. But that's what the keg answer does.

6 bytes (Keta) vs 7 bytes (Keg).

N(e(s(t))) a string

Keg got 12 bytes

M\(+\)*!

ININIM
Add(Map(input, "("), Times(")", length(input)))
   

`--mapoffbyone` 8 bytes (Keta) vs 12 bytes (Keg)

DDoouubbllee SSppeeaakk

Keg got 3 bytes

i

Expands to:

interleave(input, input)

1 byte (Keta) vs 3 bytes (Keg)

Chain Rules

This is a list of how patterns are evaluated within Keta (ekg)

Nilads: N n Ñ –> Nilads

Singles: S s Š –> Monads

Infixes: I i Ī –> Dyads

L L* L& –> Left argument – implicit/whatever is to the left

R R* R& –> Right argument – implicit/whatever is to the right

{...} means that the expressions are blocked together

• ND -> N I R
• SN -> S(N)
• Ss -> S(s(R))
• SI -> S(R) I R*
• IN -> L I S
• IS -> L I S(R*)
• Ii -> {L I R} i R*
• SNI -> S(N) I R
• SsN -> S(s(N))
• SsŠ -> S(s(Š(R)))
• SsI -> S(s(R)) I R*
• SIN -> S(R) I N
• SIs -> S(R) I s(R*)
• SIi -> S(R) I {L* i R*}
• INi -> {L I N} i R*
• ISN -> L I S(N)
• ISs -> L I S(s(R*))
• ISi -> {L D S(R*)} i R&
• IiN -> {L I R} i N
• IiS -> {L I R} i S(R*)
• IiĪ -> {{L I R} i R*} Ī R&

Blocks are evaluated using the triplet rules if possible, otherwise the pair rules are used, otherwise things are evaluated as is

External References

Github Repo

Very WIP Reference List

Command | Description | Arity | Left | Right | Pythonish Representation
( ): NOP | NA | NA | NA
(!): Length of right argument | 1 | NA | Iterable | length(right)
   : Factorial of right argument | 1 | NA | Number | factorial(right)
("): Start/close string | 0 | NA | NA | NA
(#): Comment | NA | NA | NA | NA
($): Sort the right argument | 1 | NA | Iterable | sorted(right)
(%): Moduluo of left and right | 2 | Number | Number | left % right
   : Formats a string | 2 | String | String | left.format(right)
(&): Logical and | 2 | Any | Any | left && right
('): Delimit a variable name
((): Start a list | NA | NA | NA | NA
()): End a list | NA | NA | NA | NA
(*): Multiply left and right | 2 | Number | Number | left * right
   : Repeat left by right times | 2 | Iterable | Number | left * right
   : Product of iterables | 2 | Iterable | Iterable | list(itertools.product(left, right))
(+): Add left and right | 2 | Number | Number | left + right
   : Add left and right | 2 | String | String | left + right
   : Append right to left | 2 | List | Any | left.append(right)
(,): Separate list items | 0 | NA | NA | NA
(-): Subtraction | 2 | Number | Number | left - right
(.): Special constants | 0 | NA | NA | NA
(/): Divison | 2 | Number | Number | left / right
(0): Number
(1): Number
(2): Number
(3): Number
(4): Number
(5): Number
(6): Number
(7): Number
(8): Number
(9): Number
(:): Double the input | 1 | NA | Any | [right, right]
(;): Decrement | 1 | NA | Any | right - 1
(<): Less than | 2 | Any | Any | left < right
(=): Equality | 2 | Any | Any | left == right
(>): Greater than | 2 | Any | Any | left > right
(?): Input, eval'd | 0 | NA | NA | keta_eval(input())
(@): String ender
(A): Absolute value | 1 | NA | Number | abs(right)
(B): Binary to base 10 | 1 | NA | Number | int(2, right)
(C): Ceiling | 1 | NA | Number | math.ceil(right)
(D): Double | 1 | NA | Number | right * 2
(E): Eval | 1 | NA | String | keta_eval(right)
(F): Factorise | 1 | NA | Number | find_factors(right)
(G): Genrate range from 0 to right (inclusive) | 1 | NA | Number | range(0, right + 1)
(H): Halve | 1 | NA | Number | right / 2
(I): If statement | 2* | Expression | Block | if(expression, blocks)
(J): Join x by y | 2 | Iterable | String | right.join(left)
(K): Constant library | 1 | NA | Character | constants[right]
(L): List range | 2 | Number | Number | range(left, right + 1)
(M): Map function to iterable | 2 | Iterable | Block | map(right, left)
(N): Negate | 1 | NA | Number | right * -1
(O): One-dimensionify a list (flatten) | 1 | NA | Iterable | [item for sublist in l for item in sublist]
(P): Permutation | 2 | Iterable | Number | itertools.permutations(left, right)
(Q): Quit/terminate program | 0 | NA | NA | exit()
(R): Reduce by block | 2 | Iterable | Block | functools.reduce(right, left)
(S): Square | 2 | Iterable | Number | textwrap.wrap(left, right)
(T): Top of stack | 1 | NA | Iterable | right[0]
(U): Uniquify | 1 | NA | Iterable | unique(right)
(V): Variable set | 2 | String | Any | left = right
(W): While loop | 2 | Expression | Block | While(left, right)
(X): Exclude/remove items | 2 | Iterable | Any | list(filter((right).__ne__, left))
(Y): Loop variable
(Z): Zip | 2 | Iterable | Iterable | zip(left, right)
([): Start a block
(\): Escape the next character
(]): End a block
(^): Exponate
(_): Truthify
(`): String ender
(a): all | 1 | NA | Iterable | all(right)
(b): binary representation | 1 | NA | Any | bin(right)
(c): contains | 2 | Iterable | Any | right in left
(d): divmod | 2 | Number | Number | divmod(left, right)
(e): exec | 1 | NA | String | keta_exec(right)
(f): filter | 2 | Iterable | Block | keta_fitler(left, right)
(g): generate exclusive range | 1 | NA | Number | range(0, right)
(h): hack/stride | 2 | Iterable | Iterable(Number, Number) | left[right[0]:right[1]]
(i): loop variable 
(j): loop variable
(k): loop variable
(l): Lookup/index | 2 | Iterable | Any | left.index(right)
(m): maximum | 2 | Any | Any | max(left, right)
(n): newline | 0 | NA | NA | NA
(o): or | 2 | Any | Any | left or right
(p): print | 1 | NA | Any | print(right)
(q): quoted | 1 | NA | Any | str(right)
(r): repeat | 2 | Number | Block | repeat(right, left)
(s): shape | 2 | Iterable | Number | shape(left, right)
(t): tail of stack | 1 | NA | Iterable | right[-1]
(u): uniquified sorted | 1 | NA | Iterable | sorted(uniquified(right))
(v): variable get | 1 | NA | String | variable_name
(w): wrap | 2 | Iterable | Number | left[::right]
(x): index | 2 | Iterable | Number | left[right]
(y): loop variable
(z): z(s)leep | 1 | NA | Number | time.sleep(right)
({): Start a block
(|): Seperate items
(}): End a block
(~): Random number