CHANGELOG.txt

󷹇 This file is ordered from old to new

"x ⫰" = "⫰ x" =  abs(x)
"x ⫯" = "⫯ x" = ¯abs(x)

fold now has init modifier
    [3]ſ¹+
    ⯈ 4

ᴍ: now handles strings well
ᴍⁿ: n layered map
    [1⋄2,3⋄4] ᴍ² √
    ⯈ [[1.0, 1.4142135623730951], [1.7320508075688772, 2.0]]
ᴍ⁻ⁿ: layers above any atom
    confusing so like:
        ["some", ["cool", [[["strings"]]]]] ᴍ⁻² ᴙ
        ⯈ ['emos', ['looc', [[['sgnirts']]]]]
        ["some", ["cool", [[["h"]]]]] ᴍ⁻¹ ᔐ.upper
        ⯈ [['S', 'O', 'M', 'E'], [['C', 'O', 'O', 'L'], [[[['H']]]]]]
         i think ᴍ⁻¹ is the same as ᴍ󰂃...?
ᴍ󰂃: also a thing
ꟿⁿ: starmap works the same way
  
Where '⨁' ⫢ operator
  ⨁󰀂ᴬᴾ󰀙    ⟶ ⨁["󰀂ᴬᴾ󰀙"]
  ⨁ᵃ       ⟶ ⨁[a]
  ⨁¹⁺¹     ⟶ ⨁[1+1]
  ⨁¹⁺¹𐞑ᴶ𐞑ˣ ⟶ ⨁[1+1,"J",x]

Keybinded ⥉, 𐞑
Changed binds for ⟥⟤

"egg"⬄"g"
⯈ "e"
needs more work to be more general

made ⟥ and ⟤ work... maybe? i think?

tracebacks show the python code now, terrible monkey things had to be done to do it

added ≺, basically
    1⋄2≺+
    ⯈ 3

* Added hex, binary, and octal parsing
* Random fixes, one tricky peggle bug
* Added some more test cases
We still have the bugs with op swapping and stuff not chaning pres orders

* Added some normalization to some paths
* Trim the caller program from argv

added 
    it just calls a function
    "f " is "f()"

fixed hex lol

Added basic cli mode, tldr "☾" with no args opens it.
refresher is "☾ --refresher"

added install script [linux only rn]

fixed bug with tracebacks
(Need to fix cli mode not showing errors)

ᴍ and ꟿ support ᴰ ᴷ ⱽ for mapping dicts, dict keys, and dict values

added 𝑡 for tuples b/c it was missing for some reason

print flush by default (idk if this changes anything but it don't hurt)

added bindings (and fixed a bug) for special string chars i.e. 𝗻

added ⍭, basically (use special char highlighting PLS):
    ‹a b›⍭ = ['a', 'b']
    ‹k j a b›⍭ = [['k','j'], ['a','b']]

added 𝔦𝔪𝔭(␛s), imports some misc sys related things for ease of use

Working on massive overhaul for compose/font stuff!

AAAAAAAAAAAAAa
ehehehhehe

ⴳ, ⴴ now have a self-returning call method

we now have
    ⨳ 󰻾(22) ≡ 22
    ⨳ 󰻾¹⁴("hiii") ≡ 14

Ϝ: accumulate
ℵᵒᵖᵗⁱᵒⁿᵃˡ􋕟ᵈᵉᶠᵃᵘˡᵗ: attr dict (iter does .items)
ℶᵒᵖᵗⁱᵒⁿᵃˡ􋕟ᵈᵉᶠᵃᵘˡᵗ: attr dict (iter does .values)
󰑅, 󰑅ᴵ: first, first index of
󰑁, 󰑃 : before, after
ƒ  (a1,a2,⬤,j=22,h=⬤): partial function
ƒ: automatically star a function's args
(also 􊽺, which is cool for stuff like ≡)

ᙎᙡᗢᙧ: windowz
ᣆ: apply func if...
$ᵒecho epic subprocess calls󷹹

oh also everything has sub/sup/subsub/subsup/supsub/supsup scripts
oh also font remaking thingy finished check out CONFIGURE.☾ in FontCompose

ok superscripts should now act like exponents when the parsed thing isn't an identifier
⨳ 2² ≡ 4  😊

Added gambling 😊😊😊
     /󱅏/ ᴺ : list of N of the random thing
      /󱅏   = uniform(¯1, 1)/uniform(0, 1)
      /󱅏 n = uniform/randint(0, n)
      /󱅏 𝒾 = uniform/randint(𝑖₀, 𝑖₁)
    x /󱅏 y = uniform/randint(n₀, n₁)
    𝒾      = shuffle
    𝒾    n = n choices

New errorz
    (𝐸   )         raise 𝐸
    (ƒ  𝑥)(⠤𝔸, ⠶𝕂) try ↪ƒ(⠤𝔸, ⠶𝕂), catch ε=(supscript? / any), ↪𝑥
    (ƒ 󰔶  )(⠤𝔸, ⠶𝕂) try ↪ƒ(⠤𝔸, ⠶𝕂), catch ε=(supscript? / any), ↪𝔸₀ or □
    (ƒ 󰔶 𝔤)(⠤𝔸, ⠶𝕂) try ↪ƒ(⠤𝔸, ⠶𝕂), catch ε=(supscript? / any), ↪𝔤(⠤𝔸, ⠶𝕂)
    (ƒ   )(⠤𝔸, ⠶𝕂) try ↪ƒ(⠤𝔸, ⠶𝕂), catch ε=(supscript? / any), ↪ε
    (ƒ  𝔤)(⠤𝔸, ⠶𝕂) try ↪ƒ(⠤𝔸, ⠶𝕂), catch ε=(supscript? / any), ↪𝔤(ε)

a∣b: ✓/✗ if a divides b
a∤b: take a guess

ℇ is now euler's constant

exponents are now fun 5􊽲 = √5
    [󷹇 uses hard-coded list of single char identifiers]

fixed nested ≔ and <op>= calls

Filterz
    (󷹇 󰈳 is like 󰈲 except the checking function is inverted)
    "x 󰈲  ƒ" = [y∀y∈x¿ƒ(y)]
    "x 󰈲􋇔 ƒ" = [𝑓(y)¿ƒ(y)¡y ∀y∈x]
    "x 󰈲 ƒ" = x 󰈲􊽺 ƒ
    "x 󰈲 " = "󰈲  x" = x 󰈲 󰻾
    "x 󰈲􋇔" = "󰈲􋇔 x" = (xᴍ𝑓) 󰈲

Better rangessss
    𝑎, 𝑏, n ⫢ int
    𝒜, ℬ ⫢ iterable
    n=0 by default
        "𝒜 󷸹ⁿ  " = 𝒜₀₊ₙ
        "𝒜 󷸺ⁿ  " = 𝒜􍨄₋ₙ
        "𝒜 󷸻ⁿ  " = 𝒜₀₊ₙ, 𝒜􍨄₋ₙ
    n=1 by default
        "𝒜 󷸻ⁿ ℬ" = [𝒜ₓ ∀ x∈ℬ﹕﹕ₙ]
        "𝒜 󷸸ⁿ  " = (𝒜₀, 𝒜₁﹕􍨄﹕ₙ, 𝒜􍨄)
        𝑎=1 default, 𝑏=󷰾 default
            "𝒜 󷸹ⁿ 𝑏" = 𝒜   ﹕􊴎  ﹕ₙ
            "𝒜 󷸺ⁿ 𝑏" = 𝒜  ₁﹕􊴎₊₁﹕ₙ
            "𝒜 󷸸ⁿ 𝑏" = 𝒜  ₁﹕􊴎  ﹕ₙ
            "𝒜 󷸻ⁿ 𝑏" = 𝒜   ﹕􊴎₊₁﹕ₙ
            "𝑎 󷸹ⁿ 𝒜" = 𝒜􊴍  ﹕  􍨄﹕ₙ
            "𝑎 󷸺ⁿ 𝒜" = 𝒜􊴍₊₁﹕   ﹕ₙ
            "𝑎 󷸸ⁿ 𝒜" = 𝒜􊴍₊₁﹕  􍨄﹕ₙ
            "𝑎 󷸻ⁿ 𝒜" = 𝒜􊴍  ﹕   ﹕ₙ
        𝑎=0 default
            "𝑎 󷸹ⁿ 𝑏" = [⠤range(𝑎  ,𝑏  ,n)]
            "𝑎 󷸺ⁿ 𝑏" = [⠤range(𝑎+1,𝑏+1,n)]
            "𝑎 󷸸ⁿ 𝑏" = [⠤range(𝑎+1,𝑏  ,n)]
            "𝑎 󷸻ⁿ 𝑏" = [⠤range(𝑎  ,𝑏+1,n)]

i have gone off the deep end we now have
    󷱅󷰾 = ¯81
    󷰽󷱎󷱒󷱓󷱏󷱒󷱐󷱓󷱓󷱔 = ¯0xDEADBEEF

attempted to add some implicit multiplication. Most stuff with a a literal number works well, var_spec's work decently (but might be weird in the future), and we don't support strings/regular variables.
    ½󷰽󷱎󷱒󷱓󷱏󷱒󷱐󷱓󷱓󷱔󷺍²󷱀î³ = -13827051355.523182j
    
    (󷹇 implicit mul uses the "␀CAT" order of operations)

added joinz
    "⨝ 𝒜" = "⨝ 𝒜" =   ᐦ.join(𝒜ᴍᔐ)
    "⟕ 𝒜" = "⟕ 𝒜" = 𝗻+ᐦ.join(𝒜ᴍᔐ)
    "⟖ 𝒜" = "⟖ 𝒜" =   ᐦ.join(𝒜ᴍᔐ)+𝗻
    "⟗ 𝒜" = "⟗ 𝒜" = 𝗻+ᐦ.join(𝒜ᴍᔐ)+𝗻
    
    (𝒜 ⨝ⁿ ƒ) =          𝒜₀, ƒ(𝒜₀,𝒜₁), 𝒜₁, ƒ(𝒜₁,𝒜₂), …, 𝒜􍨄
    (𝒜 ⟕ⁿ ƒ) = ƒ(□,𝒜₀), 𝒜₀, ƒ(𝒜₀,𝒜₁), 𝒜₁, ƒ(𝒜₁,𝒜₂), …, 𝒜􍨄
    (𝒜 ⟖ⁿ ƒ) =          𝒜₀, ƒ(𝒜₀,𝒜₁), 𝒜₁, ƒ(𝒜₁,𝒜₂), …, 𝒜􍨄, ƒ(𝒜􍨄,□)
    (𝒜 ⟗ⁿ ƒ) = ƒ(□,𝒜₀), 𝒜₀, ƒ(𝒜₀,𝒜₁), 𝒜₁, ƒ(𝒜₁,𝒜₂), …, 𝒜􍨄, ƒ(𝒜􍨄,□)
    
    (if ƒ is non-callable ƒ=󰻾􊽺)
    ᴸ modifier = don't stringify result / cast result to list
    (󷹇 no ᴸ mod and ƒᐹᔐ ⇒ we string-sum at end)
    
    ⁿ = number of seperators if 𝒜 empty.
        n=0 ⟶ no seperator
          1 ⟶ 1 seperator
          2 ⟶ 2 seperator
        by default, ⟗ ⇒ n=1, n=0 otherwise.  
        (󷹇 sep value = ƒ(□, □))

ℐ efficently iterates non-callable iterable ℐ (returns the iterable)

Bootstrapped the grammar parser, so we can use peggle2 entirely for grammar stuff

Added ᚤ "first-unique", basically:
    ⨳ 1⋄¯2⋄23⋄2    →ᚤ 󰲡x²󰅂 ≡ 1⋄¯2⋄23
    ⨳ 1⋄ 2⋄23⋄¯2⋄1 →ᚤ      ≡ 1⋄2⋄23⋄¯2

Added 󰌷 "chain", basically:
    ⨳ ["abc", ␛h, 1⋄2⋄3]  󰌷       ≡ [␛a,␛b,␛c,␛h,1,2,3]
    ⨳             1⋄2⋄3 → 󰌷 "abc" ≡ [1,2,3,␛a,␛b,␛c]

Added ⬒ and ⬓ (Round up/down), entirely:
    ⨳ 2.2 ⬒ ≡ ⬒ 2.9 ≡ 3
    ⨳ 5.2 ⬓ ≡ ⬓ 5.9 ≡ 5

Added ≕, finally:
    2+2 ≕ x  x=4
    x≔y≔z ⟶ (x := (y := z))
    x≔y≕z ⟶ (z := (x := y))
    x≕y≕z ⟶ (z := (y := x))

Adddered ⊞, basically
    "abc" ⊞ "123" = [[[␛a,␛1],[␛a,␛2],[␛a,␛3]],[[␛b,␛1],[␛b,␛2],[␛b,␛3]],[[␛c,␛1],[␛c,␛2],[␛c,␛3]]]
    "abc" ⊞²      = [[[␛a,␛a],[␛a,␛b],…],   …]

Added the ᐳᑀᐒᐵᐖᐸᑅᐘᑈᐛs, too tired to explain rn basically lambdas cool cousins

Added ᐴ, the mirror of ᐹ
    Also, ᐹ/ᐴ are `isinstance` in the binary case and `type` in the unary case
    ⨳ "egg"ᐹᔐ
    ⨳ intᐴ2
    ⨳ "hi"ᐹᔐᐴ"egg"

󰌷 now has depth supscript modifier, basically
    ⨳ [["l","egg"],["he","we"]] 󰌷¹ ≡ "l"⋄"egg"⋄"he"⋄"we"
    ⨳ [["l","egg"],["he","we"]] 󰌷² ≡ ␛l⋄␛e⋄␛g⋄␛g⋄␛h⋄␛e⋄␛w⋄␛e

○ and ∘ now have ○ⁿ ∘ⁿ version so basically
     (+) ∘²    [1,2]  ≡ [1,2,1,2]
    ((+) ○² 🃌)([5,2]) ≡ 4

Added ⊚,⊜,🟕,🟖 basically
    "ƒ ⊚    n?2": ƒ(ƒ(ƒ…)) n times
    "ƒ ⊚ˢ􊽨􋔛 𝑔  ": ƒ(ƒ(ƒ…)) until 𝑔 true
    "ƒ ⊜ˢ􊽨􋔛 𝑔?󰻾": ƒ(ƒ(ƒ…)) until fixed point under 𝑔
    "ƒ 🟕ˢ􊽨􋔛 𝑔?󰻾": ƒ(ƒ(ƒ…)) until cycle is found.
    "ƒ 🟖ˢ􊽨􋔛 𝑔?󰻾": ƒ(ƒ(ƒ…)) until cycle is found. Include results before cycle.
    󷹇 's' is max loop count, returns □ on fail (change to err?)
    󷹇 these 2nd order funcs will call ƒ with args initally, i.e.
        ⨳ (ᑀ⋅󷰾ᐸ ⊜ ⟥ᑀ²)(100) ≡ 100  calls ƒ 2 times

in cli mode entering just "☾" makes it hot-reload the executable; useful for changing around header

Added 󷹎,󷹍,󷹌, quintessentially
    (󷹎,󷹍,󷹌) ᐵ(0⋄1⋄0⋄0⋄1⋄1⋄1⋄0⋄1)☾
        [[1], [1, 1, 1], [1]]
        [[], 0, [1], 0, [1, 1, 1], 0, [1]]
        [[], 0, [1], 0, [], 0, [1, 1, 1], 0, [1]]
    (󷹎,󷹍,󷹌) ᐵ("abcαβαβxyz", "αβ")☾
        ['abc', 'xyz']
        ['abc', 'αβ', 'xyz']
        ['abc', 'αβ', '', 'αβ', 'xyz']
    (󷹎,󷹍,󷹌) ᐵ("αβαβabcαβαβxyzαβαβ", "αβ")☾
        ['abc', 'xyz']
        ['', 'αβ', 'abc', 'αβ', 'xyz', 'αβ', '']
        ['', 'αβ', '', 'αβ', 'abc', 'αβ', '', 'αβ', 'xyz', 'αβ', '', 'αβ', '']
    "󷹎": no seps
    "󷹍": keep only single runs of sep
    "󷹌": keep all seps
    ⁿ ⟶ number of times
    􋇙 ⟶ force list mode when strings
    "ᔐ 󷹎/󷹍/󷹌 ᔐ": spl by arg 2
    "𝒾 󷹎/󷹍/󷹌 ƒ": spl by ƒ
    "𝒾 󷹎/󷹍/󷹌 𝑜": spl with ƒ = ᑀ≡𝑜
    "𝒾 󷹎/󷹍/󷹌" = "󷹎/󷹍/󷹌 𝒾": spl by falsy
    "󷹎 ᔐ" = "ᔐ 󷹎": spl by whitespace

Added ⭜ and ⭝, ok like basiicaily:
    not bad ternary operator
    "condition ⭜ true-value ⭝ false-value"
    󷹇 "x ⭜ y" is □ when ¬x
    󷹇 presidence level is between ⬅/➡ and ←/→
    "x⭜y⭝z⭜w⭝v" = "x⭜y⭝(z⭜w⭝v)"
    "x⭜y⭜w⭝v" = "x⭜(y⭜w)⭝v"
    "x⭜⬅y⭜w⭝v" = "x⭜(y⭜w⭝v)"

CHANGED/ADDED SYMBOLS:
    󷺥󷺤󷺦󷺒
    Ω ⟶ 󱀘
     Old version exists but deprecated for the following,
       they will be removed in version 1.13.like in 8 hours
    ζ ⟶ 󱑼
    Σ ⟶ ⨁
    Π ⟶ ⨀

For future ref we avoid cluttering up letters/symbols used in math (except implementing their mathematical counterpart). Similar thing applies to common languages

Added ⪡, ⪢ for bitshift left/right

Made 󰸵, 󰸷 work better w/ strings, le essentialz iz:
    ⨳ "joe" 󰸵􋕩ˣʸ􋕩 5 ≡ "xyxyjoe"
    ⨳ "joe" 󰸵     4 ≡ " joe"
    ⨳  [␛a] 󰸵     3 ≡ ✗⋄✗⋄␛a
    ⨳  [␛a] 󰸷¹    3 ≡ ␛a⋄1⋄1
    ⨳  "ab" 󰸷³    4 ≡ "ab33"

Added 󰛔, string replacement for strings, ok, so basically:
    ⨳ "a" 󰛔􋕩ᵃᵇᶜ􋕩 "k"     ≡ "kbc"
    ⨳ ("a" 󰛔 "k")("abc") ≡ "kbc"
    ⨳ (["hi", "h"] 󰛔 ["ih", "j"])("hi") ≡ "ij"
     (last one if multiple) right arg is repeated
    ⨳ (["a","b","c"] 󰛔 "hi")("ab") ≡ "hihi"
    ⨳ (["a","b","c","d"] 󰛔 [12, "k"])("abd") ≡ "12kk"

󱑼 has a longest mode with fill value v as 󱑼ᵛ

added 󷹄, contrain operator, oki so:
    ⨳ 1󷹄²4 ≡ 2
    ⨳ 1󷹄⁷4 ≡ 4
    ⨳ 1󷹄􍨋4 ≡ 1
    ⨳ (1󷹄4)(2) ≡ 2
    ⨳ ␛a󷹄􋂝²␛z ≡ ␛a

added ⩔ and ⩓, basically as useful as an implementation detail but quandasically:
    literally ∨ and ∧ but doesn't short circuit
    i now have a todo item of 󷺥 but no short circuit bruH

oh also 󷺥 now short circuits
oh and nOW i had to do 󷺒

…stupid idiot ۩⩔󷺫⩓󷺬۩

Added 𝌂, beesbeesentially:
    󰤱

if 󰈲/󰈳//󰒼/󰒽/󰤱 has w/ non-ƒ RHS then it checks for equality

idk how i didnt think of this but like if you're mapping and your function returns 󰮈 then its removed from the map

got rid of the `colored` dependency yay

REMOVED: 󰑁 󰑃
ADDED: 󷹓 󷹔 󷹕 󷹖

slightly less stupid caching

NOTE ON CURRENT DEPRECATED:
    … ζ Σ Π
    Sorta deprecated (once off python these may be removed, havent decided)
        ** * / // << >> >= <= !=
        Other python specific stuff but we'll get there when we get there

Added ∾, evajvuahuehae reverses function args.

We can now use ᐹ with 𝗙,𝗜,𝗛

Removed ζ/Σ/Π

added , threadman, biahiuofafu
    superscript is number of threads, default is system cpu count
    otherwise normal map

󷺗: empty style but works inside strings
󰤱 docs
󰤱 docs/tests for ⪢⪡󷹅 new window features
󰤱 docs/test for the ○⍜󰬩󰬫 stuffs
󷹝: 󰤱 docs (mention ᴸ mod)
󷹜: 󰤱 docs
∅: 󰤱 docs
⍁: 󰤱 docs
󷸊󷸋󷸌󷸍󷸉󷸎: 󰤱 docs
󷹁: 󰤱 docs

in `kots.☾` we now have that cd(@) will cd into the caller's current dir

󰤱betterdocs
    󱫩􊽺(𝚲󰔛∘5→►"hi"☾, 󷰾⅕î, 5)→☾
     󰔛􊽺(𝚲"joe"☾, 󷰾⅕, 5)→☾
    # 5 󰔛  sleep 5s
    # ƒ 󰔛/󱫩    ⟶ Timer  wait 1s, call ƒ
    # ƒ 󰔛/󱫩  5 ⟶ Timer  wait 5s, call ƒ
    # ƒ 󰔛/󱫩⁵ 5 ⟶ Timer  (wait 5s, call ƒ)⨯5
    # ƒ 󰔛/󱫩⁵ 󷱂 ⟶ Timer  (call ƒ, wait 5s)⨯4, (call ƒ)

better install script also ugex also why were dice so high

DEPRECATED: 󰑅ᴵ, use 󰑅ᔨ

Added implicit imports, only works for ℍ atm (also kots autoimports)

Implicit multiplication between numbers and strs now is a thing

󰋺 now is smarter, if a folder is in ☾/Library it gets the /main.☾ file. also we check local files and stuff now. also we have __dir__ which pairs with __file__.