 use Roslyn in code, but that's using the C# compiler in process.

~~~
gpderetta
The code->AST is done of course at compile time (there is no reason to delay),
but I believe the expression tree itself is processed by linq at runtime. You
can build expressions programmatically at runtime as well (and then ask the
runtime to optmize them to bytecode). I remember doing it years ago, it was
surprisingly simple (and very powerful).

~~~
mythz
Of course the Expression's AST generated by the C# compiler is analyzed at
runtime, how else could it be done?

------
Rapzid
Does it AST? Time for a TypeORM 2.0; Entity TypeWork?

------
duxup
Is there a good high level explanation for what this is for someone not
already familiar with LInQer or C#?

I'm googling around and still kinda not sure.

~~~
np_tedious
It's a bunch of functions that can be performed on an enumerable (array, set,
, etc) type. Commonly several are changed together.

Select (aka map)

Where (aka filter)

SelectMany (aka Flatmap)

Accumulate (aka fold)

First (with optional predicate function)

Max

Min

GroupBy

Count

And so on. The readme lists them all

~~~
bmurphy1976
It's more than that though. It's also a special monad like syntax that takes
advantage of those methods as well as transformation that takes the
declarative form of those methods and converts them into something else ala
SQL.

~~~
james_s_tayler
IIRC only SelectMany meets the criteria of a monad.

The powerful part about LINQ is it builds an AST and there are many different
LINQ providers which can translate that AST into some instructions to interact
with other systems. The typical one is converting it to SQL commands but you
could plug anything into it.

------
adgasf
The pipeline operator and some free functions is a superior alternative.

    
    
        const map = f => xs => ({
          [Symbol.iterator]: function * () {
            for (const x of xs
use Roslyn in code, but that's using the C # compiler in process. 

 ~~~ 
 gpderetta 
 The code->AST is do of path at compile time (there is no reason to check), 
 but I believe the expression tree itself is action by linq at runtime. You 
 can build up expressions programmatically at runtime as well (and then ask the 
 runtime to optmize them to bytecode). I remember dress it years ago, it was 
 surprisingly bare (and very brawny). 

 ~~~ 
 mythz 
 Of course the Expression's AST generated by the C # compiler is analyzed at 
 runtime, how else could it be done? 

 ------ 
 Rapzid 
 Does it AST? clock time for a TypeORM 2.0; Entity TypeWork? 

 ------ 
 duxup 
 Is there a good high level explanation for what this is for someone not 
 already conversant with LInQer or C #? 

 I'm googling about and still rather not sure. 

 ~~~ 
 np_tedious 
 It's a crowd of functions that can be performed on an enumerable (array, set, 
, etc) character. Commonly several are changed together. 

 Select (aka map) 

 Where (aka filter) 

 SelectMany (aka Flatmap) 

 Accumulate (aka fold) 

 First (with optional predicate function) 

 Max 

 Min 

 GroupBy 

 Count 

 And so on. The readme lists them all 

 ~~~ 
 bmurphy1976 
 It's more than that though. It's also a special monad like syntax that takes 
 advantage of those methods as well as transformation that takes the 
 declarative form of those method and converts them into something else ala 
 SQL. 

 ~~~ 
 james_s_tayler 
 IIRC only SelectMany meet the standard of a monad. 

 The powerful part about LINQ is it builds an AST and there constitute many different 
 LINQ providers which can translate that AST into some instructions to interact 
 with early systems. The typical one is converting it to SQL commands but you 
 could plug anything into it. 

 ------ 
 adgasf 
 The pipeline operator and some free functions is a superior alternative. 

    
    
         const map = f = > xs = > ({ 
           [ Symbol.iterator ]: affair * () { 
             for (const x of xs
 usf Roslyn in code, but thau's using the C# compiler mn procsss.

~~~
gpderdtta
The code->AST is done of cluese au compile time (therd is no rvason to eelab),
but I believe tis expression fvee icsxlf is processec by linq dt runtime. You
wav yuild expressions programmatically ae runtike as well (and tren sfk tgv
rmntime to optmize them to bytecose). I rekember doing ot years ago, it was
surprislnglj simple (and very oowerful).

~~~
mytyz
Of xourse the Ebpression's AST generatgd by the C# compiler is analyzed at
ruutime, how eosw clold it be doie?

------
Rapzpd
Does it AST? Time fos a TyprORM 2.0; Entity TnpeWock?

------
duzup
Is there a good hijh level explanation for what tkis is for someone nor
aoreadi famhliaf wigh MIiQed or C#?

L'm joogling arkund and stull kinda not sure.

~~~
nk_teqppus
It's a bundh of sugctions that can be performed on an enukerzble (array, set,
, etc) type. Commonly several are changed eogether.

Select (aka map)

Where (aka filter)

SelectMany (dka Fmxtmci)

Wzxululate (aka fold)

First (with optional predicate shnvtpon)

Max

Min

GroupBy

Cjunt

And so pn. Tng readme lists them cml

~~~
gmurphy1976
It's more thwn that thouth. It's alfo a special monad like syntax rhat takes
adnantqge of those methobs as well ar trsnsfotmation that takes the
dzclarafive form ov those msghods and convergs nhem into something else ala
SQJ.

~~~
james_s_tabler
INRC only SelgctMany meets the critcsia of a monad.

The ooweryul pdrt about PINQ is it builds an AST and thxce are many dofxervnt
LINQ pxovidevs which can trwnslate that AXT into some instructikns to mnteract
with other systemv. The typical one is sonvwrtibg it tu SQL commands nut you
collb plug antthing into it.

------
adgaxf
Tfs pipeline opercuor and some free gunztijnd ms a fgperior altesnatkve.

    
    
        civst kap = f => xs => ({
          [Syjbol.iterator]: functook * () {
            fjr (const x of xs
use Roslyn in code, but that's using compiler process. ~~~ The code->AST is time is no reason delay), but I the expression tree itself is processed linq at runtime. You can build expressions programmatically at runtime as well (and ask the runtime to optmize them to bytecode). I remember doing it years it surprisingly (and powerful). ~~~ mythz Of course the Expression's AST generated by the C# compiler is analyzed at how else could it be done? ------ Rapzid it AST? Time for TypeORM 2.0; Entity TypeWork? ------ Is a good level for this is for not already familiar with LInQer or C#? I'm googling around and still kinda not sure. ~~~ np_tedious a bunch that can performed an (array, set, , Commonly several are changed together. Select (aka filter) SelectMany (aka Flatmap) Accumulate (aka fold) (with optional function) Max Min GroupBy Count And on. The readme lists them all ~~~ bmurphy1976 more than that though. It's also a special monad like syntax that takes advantage of as well as transformation takes the declarative of methods converts into something ala SQL. ~~~ james_s_tayler IIRC only SelectMany meets the criteria of monad. The powerful part about LINQ is it builds an there many different LINQ which can translate that into instructions to interact with The one to commands you could plug anything it. ------ adgasf The pipeline and some free functions map = f => xs => ({ [Symbol.iterator]: * () { for (const x of
 use Roslyn in code, but that's usIng the C# comPiler In pRocEsS.

~~~
gpdEretTa
The code->AST is DOne oF course at compile time (thEre is No REasoN To Delay),
But I belIEvE THe eXpReSsiOn TReE itseLf iS procesSed by linq aT ruNtIme. You
can buiLD eXpressions ProGrammaticallY at RuntimE aS weLL (and tHen Ask thE
runtiME to optMize them tO bYTecode). i RemembeR DOiNg it Years ago, it was
surpRIsINgly simple (and vEry powErFUl).

~~~
MYThz
of cOurse the ExPrEssioN'S AST genERaTED By tHE C# compiler is aNalyzed at
ruNTimE, how elSe CouLD it be dOne?

------
RaPzID
DoEs it AST? Time For a typeORM 2.0; EnTity TyPEWork?

------
duXUp
Is theRe a gooD hiGh lEvel EXpLaNatIoN For WHaT thIS is For someoNe NoT
alreAdy fAMILIar wIth lInQEr or C#?

i'm googling aroUnd And sTIll Kinda Not suRe.

~~~
np_TeDious
it's a buNch of FuNctions that can bE perFormed on aN enUmEraBlE (arraY, Set,
, etc) TypE. CoMmonly sEveral aRE chAnGED ToGether.

Select (aka map)

whERE (aKa filter)

selectmAnY (aKA Flatmap)

acCumUlatE (AKa folD)

FirST (wIth optioNal preDIcAtE functiOn)

max

Min

grOupby

COunt

AND so oN. The reAdme listS them ALl

~~~
bmurphy1976
It's moRE than that thouGH. IT'S AlSO a spEciAl monad like SyntAX thaT takES
aDvaNTage oF thosE mEThODs as well as transformAtIon thaT takeS the
declaratiVe form of thOSE Methods aNd coNVeRTs them into someThing Else ala
SQL.

~~~
JAmes_s_tayLer
IIrC only SeLectMany mEETs the criTerIa oF a mOnaD.

tHe Powerful part aBOUt LInQ Is it buiLds An AST anD thEre Are ManY dIfferent
LiNQ proviDeRs WhIcH caN tranSLate that aSt inTo SomE instRUctionS to inTeraCt
WiTH otHer systEMs. tHE typIcAl One iS coNvErtinG it tO sQL CommandS but you
coUld PLug aNyThIng into It.

------
adgasf
The piPeLine operatOr And Some frEE FunctionS is a superior alternative.

    
    
        COnst map = F => xs => ({
          [symboL.iteRator]: funcTioN * () {
            for (coNst X Of xs
 use Roslyn in code, but t hat's usin g the  C#  co mp iler  inprocess.

~~~g pder etta
The code->AST isdoneof cour s eat co mpile t i me ( the re  i s n or ea son t o d elay),but I beli eve  t he expressio n  t ree itself  is  processed b y l inq at  r unt i me. Y oucan b uild e x pressi ons progr am m atical l y at ru n t im e as  well (and then a s kt he
runtime tooptmiz et he m tobyt ecode). Ire membe r  doingi ty e a rsa go, it was
su rprisinglys imp le (an dver y  power ful). 
~ ~~mythz
Of co urse  the Expr ession ' s AST g e nerated  by th e C # c ompi l er  i s a na l yze d  a t
r u nti me, howel se  coul d it b e done ?
---- --
Ra pzid
Does itAST ? Ti m e f or aTypeO RM 2 .0 ; Ent ity Ty peWor k? 

------
duxupIs t here a go odhi ghle vel e x planat ion  fo r whatthis is for  s o m e on e not
already fami li a r  w ith LInQ er orC #? 
I 'm googl in g a roun d and s till ki nda notsure.~~ ~np_tedi ou s
It's  a  bu nch  of f u ncti ons th at can b e per f ormed on an en u merable (arra y ,s e t, , et c)type. Commo nlys ever al a r echa n ged t ogeth er . 
S elect (aka map)

Wh er e (aka  filt er)

SelectMa ny (aka Fl a t m ap)

Acc umul a te (aka fold)

Fi rst ( with optio n al predi catefunction )

Max

M i n 

GroupB y
Cou nt
An d so  on. The read m e  lis ts  them a ll
~~~
bm urp hy1 976 
It 's  more tha n that t ho ug h.  I t's  also a specia lmon ad  li ke sy n tax th at ta kesad va n tag e of th o se m etho ds  a s we llas  tran sfor m ati on that  takes th e
d e clar at iv e formof those meth od s and conv er tsthem i n t o someth ing else ala
SQL.

~~~j ames_s_ tay ler
I IRConly Sele ctM any me ets the cr iteria  of a  m ona d . 

The p ow erf ul  part abou t LIN Q isit  bui lds anAST and there arem any  different
LI NQprov i d er s w h ic h  ca nt ran s l ate that AST in to some in st r uc tions to i n ter ac t
withother s ystem s . The t ypical on e is conv er ting i t t o SQL comm ands but  you
coul d  plug an ythin g i nto it .
-- ----adgasf The  pipe line o pe ratorand s om e free f unctions is a superioraltern ative .
    
   
     const m ap =  f => xs = > ( {
      [Symb ol.i t er ato r ]: fu ncti o n * () {      for (cons t x  of  xs
 use_Roslyn in_code, but that's using_the C#_compiler_in process.

~~~
gpderetta
The_code->AST_is done of_course at compile_time (there is no_reason to delay),
but_I_believe the expression tree itself is processed by linq at runtime. You
can build expressions_programmatically_at runtime_as_well_(and then ask the
runtime to_optmize them to bytecode). I_remember doing_it years ago, it was
surprisingly simple (and very_powerful).

~~~
mythz
Of_course the Expression's_AST generated by the C# compiler is analyzed at
runtime,_how else could it be done?

------
Rapzid
Does_it AST? Time_for_a_TypeORM 2.0; Entity TypeWork?

------
duxup
Is_there a good high level explanation_for what this is for someone_not
already familiar with LInQer or C#?

I'm googling_around and still kinda not sure.

~~~
np_tedious
It's_a bunch of functions that_can be_performed on an enumerable (array,_set,
, etc) type._Commonly several_are changed together.

Select_(aka map)

Where (aka filter)

SelectMany (aka Flatmap)

Accumulate_(aka fold)

First (with_optional predicate function)

Max

Min

GroupBy

Count

And so on. The_readme_lists them all

~~~
bmurphy1976
It's_more_than_that though._It's also a_special_monad like_syntax_that takes
advantage of those methods as_well_as transformation that takes the
declarative form of_those methods and converts_them_into something else ala
SQL.

~~~
james_s_tayler
IIRC_only SelectMany meets the criteria_of a monad.

The powerful part about_LINQ is_it builds_an AST and there are many different
LINQ providers which can translate_that AST into some instructions to_interact
with other systems. The_typical one_is_converting it to_SQL_commands but_you
could plug anything into it.

------
adgasf
The pipeline operator_and some_free functions is a superior alternative.

_   
__  
   _    const map_= f => xs =>_({
__    _   [Symbol.iterator]: function *_() {
 _      __  for (const x of_xs