Composed

Test1 = Point2D,X,Y 1,2;
Test2 = Summation,List'Number' [[[Nothing,3],2],1];
Test3 = STD,List'Number' [[[[Nothing,4],3],2],1];
Test4 = String,Number 12345;
Test5 = Number,String "12345";
Test6 = Factorial,Number 10;

X is Number
Y is Number
Point2D is X, Y

IsLessThan5 is Number:
   [value, 5] > Compare'Number' {
       less: value
   } > Number

Summation is Sum
Sum from Number(n), Sum(s):
    [
        n,
        s > Number
    ] > Sum
Summation from List'Number'(l):
   [
       l,
       [0,0] > Sum
   ] > Foldl'Sum' > Sum > Summation

Average is Number
Average from Sum(s), Count(c):
    [
        s > Number,
        c > Number
    ] > Quotient > Number > Average

Average from List'Number'(l):
    [
        l > Summation > Sum,
        l > Count
    ] > Average

STD is Number
STD from List'Number'(l):
    [
        [
            l,
            l > Average > Number
        ] > Map'Difference' > Map'Number' > Map'Square' > Map'Number' > List'Number' > Summation > Sum > Number,
        [
            l > Count > Number,
            1
        ] > Difference > Number
    ] > Quotient > Number > SquareRoot > Number > STD
    
String from Number(n):
    mod: [n, 10] > Modulus > Number
    quo: [
            [
                n,
                mod
            ] > Difference > Number,
            10
         ] > Quotient > Number
    
    check9: [mod, 9] > Compare'Character'{equal: "9" } > Character
    check8: [mod, 8] > Compare'Character'{equal: "8" less: check9 greater:check9 } > Character
    check7: [mod, 7] > Compare'Character'{equal: "7" less: check8 greater:check8 } > Character
    check6: [mod, 6] > Compare'Character'{equal: "6" less: check7 greater:check7 } > Character
    check5: [mod, 5] > Compare'Character'{equal: "5" less: check6 greater:check6 } > Character
    check4: [mod, 4] > Compare'Character'{equal: "4" less: check5 greater:check5 } > Character
    check3: [mod, 3] > Compare'Character'{equal: "3" less: check4 greater:check4 } > Character
    check2: [mod, 2] > Compare'Character'{equal: "2" less: check3 greater:check3 } > Character
    check1: [mod, 1] > Compare'Character'{equal: "1" less: check2 greater:check2 } > Character
    check0: [mod, 0] > Compare'Character'{equal: "0" less: check1 greater:check1 } > Character

[n, 0] > Compare'String' {
        greater: [check0, quo > String] > AppendedString > String
        less: [check0, quo > String] > AppendedString > String
    } > String
    
    
NumberString is String
Number from String(s):
    [
        s > List'Character',
        0 > NumberStringFold
    ] > Foldl'NumberStringFold' > NumberStringFold > Number
NumberStringFold is Number
NumberStringFold from Character(c), NumberStringFold(n):

check9: [c, "9"] > Compare'Number'{equal: 9 } > Number
    check8: [c, "8"] > Compare'Number'{equal: 8 less: check9 greater:check9 } > Number
    check7: [c, "7"] > Compare'Number'{equal: 7 less: check8 greater:check8 } > Number
    check6: [c, "6"] > Compare'Number'{equal: 6 less: check7 greater:check7 } > Number
    check5: [c, "5"] > Compare'Number'{equal: 5 less: check6 greater:check6 } > Number
    check4: [c, "4"] > Compare'Number'{equal: 4 less: check5 greater:check5 } > Number
    check3: [c, "3"] > Compare'Number'{equal: 3 less: check4 greater:check4 } > Number
    check2: [c, "2"] > Compare'Number'{equal: 2 less: check3 greater:check3 } > Number
    check1: [c, "1"] > Compare'Number'{equal: 1 less: check2 greater:check2 } > Number
    check0: [c, "0"] > Compare'Number'{equal: 0 less: check1 greater:check1 } > Number
    
    [
        [n > Number, 10] > Product > Number,
        check0
    ] > Sum > Number > NumberStringFold
    
Factorial is Number:
    [value, 0] > Compare'Number' {
        equal: 1
        less: 1
        greater: [
                    value,
                    [
                        value,
                        1
                    ] > Difference > Number > Factorial > Number
                 ] > Product > Number
    }

Conversion>Number,Sum
Element>0
Param>0
Extract>0

Conversion>Sum,Number
Data Structure>1

Conversion>Sum,Number,Number
ENTER>
IGNORE>(
Param>0
IGNORE> + 
Param>1
IGNORE>)
EXIT>

Conversion>Number,Difference
Element>0
Param>0
Extract>0

Conversion>Difference,Number
Data Structure>1

Conversion>Difference,Number,Number
ENTER>
IGNORE>(
Param>0
IGNORE> - 
Param>1
IGNORE>)
EXIT>

Conversion>Quotient,Number
Data Structure>1

Conversion>Number,Quotient
Element>0
Param>0
Extract>0

Conversion>Quotient,Number,Number
ENTER>
IGNORE>(
Param>0
IGNORE> / 
Param>1
IGNORE>)
EXIT>

Conversion>Modulus,Number
Data Structure>1

Conversion>Number,Modulus
Element>0
Param>0
Extract>0

Conversion>Modulus,Number,Number
ENTER>
IGNORE>(
Param>0
IGNORE> % 
Param>1
IGNORE>)
EXIT>

Conversion>Product,Number
Data Structure>1

Conversion>Number,Product
Element>0
Param>0
Extract>0

Conversion>Product,Number,Number
ENTER>
IGNORE>(
Param>0
IGNORE> * 
Param>1
IGNORE>)
EXIT>

Conversion>Number,Square
Element>0
Param>0
Extract>0

Specification>Square,Number
ENTER>
IGNORE>(
Param>0
IGNORE> * 
Param>0
IGNORE>)
EXIT>

Conversion>Number,SquareRoot
Element>0
Param>0
Extract>0

Specification>SquareRoot,Number
ENTER>
IGNORE>Math.sqrt(
Param>0
IGNORE>)
EXIT>

Conversion>[A],Nothing
Nothing>

Conversion>[A]Compare,[A]
Data Structure>1

Conversion>[A],[A]Compare
Element>0
Param>0
Extract>0

Conversion>[A]Compare,Character,Character
ENTER
Param>0
IGNORE> < 
Param>1
IGNORE> ? 
Ask>less
IGNORE> : (
Param>0
IGNORE> == 
Param>1
IGNORE> ? 
Ask>equal
IGNORE> : 
Ask>greater
IGNORE>)
EXIT>

Conversion>[A]Compare,Number,Number
ENTER>
Param>0
IGNORE> < 
Param>1
IGNORE> ? 
Ask>less
IGNORE> : (
Param>0
IGNORE> == 
Param>1
IGNORE> ? 
Ask>equal
IGNORE> : 
Ask>greater
IGNORE>)
EXIT>

Conversion>[A],[A]Exists
Element>0
Param>0
Extract>0

Specification>[B]Exists,[A]
ENTER>
IGNORE>(
Param>0
IGNORE> !== "Nothing" ? 
Ask>yes
IGNORE> : 
Ask>no
IGNORE>)
EXIT>

Output Window