Wip022024

a1=LAMBDACALCULUS(
	function lc(){
		return(B(COS,SIN))
	}
);
a1(34)		

a1=LAMBDACALCULUS(
		()=>B(SIN,COS)
)
a1(23)

//b(sin)(cos) etc?

// this works
a1=LAMBDACALCULUS(
    function ()
    {
        return(B(SIN)(COS))
    }
);
a1(45)


a1=LAMBDACALCULUS(
    ()=>B(SIN)(COS)
);
a1(45)

// easier notations
λ=LAMBDACALCULUS;
a1=λ(()=>B(SIN)(COS))
a1(45)


// easier notations
λ=LAMBDACALCULUS;
a1=λ(()=>BLUEBIRD(SIN)(COS))
a1(45)

// easier notations
λ=LAMBDACALCULUS;
a1=λ(function(){return(BLUEBIRD(SIN)(COS))})
a1(45)

// easier notations
λC=LAMBDACALCULUS;
a1=λC(()=>BLUEBIRD(SIN)(COS));
a1(45)


// actual
SIN(COS(45))

SIN(COS(45deg))

// Amar Shah talk on functional combinators etc 
//fog Over Atop Compositions
//Case Convert 
//Unique Mask

Parts(1..100,20)
Parts(1..100,20)

[1..10].zip([11..20])
//seems different from 
Zip([1..10],[11..20])
Shuffle(1..10)
Size(1..10)
Size([1..10])
Tail([1,2,3,4,4,5,5,5])

Equal(1..10,1..10)
Parts(1..10,5)

Pieces("test test etest seret es ",4)
// strings are split and treated as arrays.


//should we combinatorial argument Parts?

Length(1..10) 
a=1..100;
Length(a)

a=[1..100];
Size(a)

// did not work

Explode([1,2,3,])

SIN((1..120)<>deg)

//try aming parts function.
1..10.parts(2..5)
|3,4,5,1..10|.parts(2..5)


Length("t4s"#) 
"This is a test of the EMS"#["s"]

a1="This is a test of the EMS"#[3]
a1="This is a test of the EMS"#[3,2]
a1="This is a test of the EMS"#[3,"s"]
a1="This is a test of the EMS"#[3,/\s/]
a1="This is a test of the EMS"#[3,Length]
a1="This is a test of the EMS"#[3,Length@SIN]
a1="This is a test of the EMS"#




a1=
	λC(
		function ()
		{
			//BLUEBIRD(SIN)(COS));
			return(B(Parts)(Length))
		}
	)
a1(1..100);

// something along these lines.
a1=
	λC(
		function ()
		{
			//BLUEBIRD(SIN)(COS));
			return(B(Parts)(Length))
		}
	)
a1(1..100);

B=A=1..10;
B|==|A

B=A=1..10;
B|x==y|A


MOPWITHEQ(1..10,1..10); // issues as fn returns.

why the following gives true?
ISLAMBDAEQUATION("LT")
MOPWITHEQ(1..10,1..10);

MOPWITHEQ(1..10,1..10);
eq=MOPWITHEQ


𐎲 = MOPWITHEQ;
𐎲(1..10,1..10);


𓈃 = MOPWITHEQ;
Σ(𓈃("RRGW"#,"RGGW"#))

𓃌 
𓃊
𓃍
𓎎


// Pointfree APL Code.
𓈃 = MOPWITHEQ;
(𓈃@Σ)("RRGWRR"#,"RBBWWW"#)


Length("testings fasdf asdf asd sdf")


("testings fasdf asdf asd sdf"#["s"]) ~


𓈰=|3,4,[4]|;
𓈰|*|3443

λC(
()=>
	{
		// Lambda Code Here
	}
)



a1=λC(
	()=>
		{
		return(B(SIN)(COS))
		}
);
a1(45deg)


Chunks(1..100,4)|/|45

1..100.pieces(2..3)

1..100.pieces(2..3,SUM)

1..100.pieces(2..3,[SUM,AVG])

1..100.pieces(2..3,[SUM,AVG],0..1)

1..100.fullpieces(2..3)
(Zip@(Parts.curry(2)))(1..100) // does it work?

1..100|x^2|

//https://www.youtube.com/watch?v=59vAjBS3yZM&t=113

('ssf454562631426'#).buckets()

https://www.youtube.com/watch?v=JELcdZLre3s

// Composition Intuition


1..10|..|1..10

1..10|.|1..10

(1..100)|↧|

(1..100)|↥|
(1..100)|↧|;
(1..100)|↥|;	
(1..100)|↥|50;
(1..100)|<|50	

(1..100)|.+|;
1..100n)|.*|;
(1..100)|./|;
(1..100)|.^|2;
(1..100)|.==|;
(1..100)|.==|(1..100);
(1..100)|.==|
(1..10)|.%|
(1..10)|.^|null
(1..10)|.^| // will use 2 so as not to break old code.

(MS(9)#)|*|
(1..10)#1 breaks right has to be an array or fromtoadv breaks on parsing


(1..10)±

a=-5..10;
∑±a;
∑±a;

// https://www.youtube.com/watch?v=a7CSK7HNEWQ
a=[-2,-3,4,5,-3,4];
∏±a;
	
a=[-2,3,4,5,-3,4];
∏±a;
	



(1..10)#3
(1..10)#
(1..10)#[3]
(1..10)#[0]
(1..10)#0..5
//((1..10)#"shuffle")() // should this work?
	
// #a-z stopped working. now ok.	
(#a-z)#/a/
(#a-z)
(#a-z)#0
(#a-z)#[0,6]
"abcd"#
"abcd"#/c/  
	//split with c
"abcd"#'d'
"abcd"#[1,2]
"abcd"#[2]
"abcd"#[2,1]
"abcdefghijklmnop"#[5,1]
"abcdefghijklmnop"#[5,2]
"abcdefghijklmnop"#[6,2]

cars=
	{
		name:"andrew",
		age:25
		
	};
cars#"name";
cars#["name","age"];
cars#;
cars#/nam/
cars#((x,i)=>25==x)
cars#((x,i)=>"andrew"==x)

cars=
	{
		name:"andrew",
		age:25,
		namaste:true
		
	};
cars#((x,i)=>/nam/) 
// why?

// reciprocal
1..100|1/x|
∏|4|# 
∏|4,2,3,5,1..10|# 
∏|4,2,3,5,1..10|#1