a quick story #python #history #emotions

print("hello world!")

hello its my python story, it all started with a little projects but i don't have them so i created FunnyTools library at Feb 18th 2024, i created some upgrades and forget it for processing(https://processing.org/) and after processing i started new project named pSansLang it was a programing language.

for FunnyTools you can just go see github page exept this functon LOXRIY that returns list with number of x-es that number is floor(x/y).

so into pSansLang i still working on it, its too big
for explaning so read the text in the end of post
if shorten its for making tabs (that compact tables that i too created) do something. (exept, its not) its creative paradigm of programing (that... i created😐) is you have a very brainfucking commands and BIG set of creating commands (like def, class, cycle, operator, and on) and you need to make programmer make with this 'creating commands' a set of comfortable for him commands, so yea.

anyways, 'end of post':

sans documentaision

hello, this is documentation for sanslang
sanslang is lang for management .tab's files

first is datatypes
<>, () and ||

type <> is type for booleans
type () is type for num's and strokes
type || is <> and ()

second is vars

<a> = true
(b) = "a"

so, first, name of variable in her type like, var a is boolean because her in <>
and then you know

third is cells

cell <A1> = true 

cell is designation of cell, not variable, fist in name is column, he is letters second is line, is num's, and all is in type
and then you know

ok, we get types, yes,we do that

now functions

func unc<x,y> -> {
    //code
}

func is start for functions, next is name of function, and arguments in her types, the -> {} is code designation if is one comand you can not(and can) put {}

it will be like that

unc<arg,arg>

so, do you now what unites ruby, snap! and sanslang?
if you awnser is none unites it, leave out of here
because anwser is HE CAN CREATE CYCLES
yes, you heard it true, cycles
p.s. not only cycles but and constructions cycles is if in code of cycle hawe goto-label

now cycles

cycle af<x,y> [end else] drep -> {
    //code
}

cycle is keycode, then name, and arguments, you can solve all arguments with args or construction.args. the [] is array of additional constructions the construction is have type !end or end and name arguments not necessarily, next is pass we sort it out later

it will be like that

af<arg,arg> -> {
    //code
} else -> {
    //code
} 

now passes

pass drep -> {
    //code
}

pass is keycode, second is key for adding to cycle we dont need key for use them, he cant be used not in cycle, he dont need indicate arguments

it will be like that

:args: -> {
    //code
}

or

:args: -> //code

we did it, yes

now the commands

where|a| //label
goto|a|
eval(b)

mulif <boolean, boolean, boolean ...> -> {
    boolean, boolean, boolean /while length of args there <= legth args of construction, checks if args of construcktions = args there/ -> {//code} // not only one
}

from filename import * 
from filename import NameOfCommand
from filename import * without NameOfCommand

and

hello its sans doc for :: functions

its the functions with :: type
there is cant be ≥2 args

first are end functions

next::
end::

the end is for end the function, cycle (IN), cycle (OUT)

like that

func lol|| -> {
    // some code
    end:: // ends functon
} // ends the functon like "void" (with no return)

or

cycle a<> [] None -> {
    // some code
    end:: // ends functon
} // ends the functon like "void" (with no return)

//or (OUT)

a<> -> {
    end:: 
} // end too

next is for just jump next goto||

where|a|
next:: // jump there -----↴
print("something wrong")// |
goto|a| //-----------------↵

now break and broke

the break breaks next goto()
but it executes all between broke and goto() in correct order

what|a|
break:: //breaks this -------------------------↴
print("if its not execute, something wrong") // |
goto|a|// --------------------------------------↵

and broke breaks break
like that

what|a|
break:: //breaks this ---------------------------↴
broke:: // broke break --------------------------X
print("if its not execute, something wrong")
goto|a|

and return

return set's a return value
like that

func lol<> -> {
    return:64:// return's 64
    end::
}