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::
}
Top comments (0)