=lisp) (Interactive,.NET Lisp)

\- #Script Code [https://sharpscript.net/linq/restriction-
operators?lang=code](https://sharpscript.net/linq/restriction-
operators?lang=code) (Interactive,.NET JS-Like)

\- Elixir [https://github.com/omnibs/elixir-linq-
examples](https://github.com/omnibs/elixir-linq-examples)

\- Python [https://github.com/rogerwcpt/python-linq-
samples](https://github.com/rogerwcpt/python-linq-samples)

\- Groovy [https://gitlab.com/svkj/groovy-linq-
samples](https://gitlab.com/svkj/groovy-linq-samples)

Most languages fare well in both verbosity and readability so I don't view
LINQ as a major strength of C# anymore, it's just a well designed, typed query
language with the USP of being able to capture and traverse an expression's
AST which different LINQ providers can take advantage of by translating the
intent of the query into a different DSL, most commonly used by ORMs to
convert to SQL and execute the typed C# Expression logic on the RDBMS Server.

~~~
kccqzy
Isn't the point of LINQ to get monads into the language so that it can be used
by a lot of different things (seemingly having no relations to data
processing), rather than just data processing tasks?

~~~
goto11
Not really. You can have monads without Linq, but there is a particular use of
the 'from' syntax which can be used as a cleaner syntax for monadic
operations. But this seem more like a hack than an intended use case.

It is rumored that Linq was initially implemented using monads, but that
approach was abandoned due to performance reasons.

~~~
contravariant
That rumour seems like it's false, because not only is "implemented using
monads" a rather vague qualification, Linq has currently been implemented by
requiring objects to implement the SelectMany function, which has signature:
= lisp) (Interactive,. NET Lisp) 

 \- # Script Code [ https://sharpscript.net/linq/restriction- 
 operators?lang = code](https://sharpscript.net / linq / restriction- 
 operators?lang = code) (Interactive,. NET JS - Like) 

 \- Elixir [ https://github.com/omnibs/elixir-linq- 
 examples](https://github.com / omnibs / elixir - linq - examples) 

 \- Python [ https://github.com/rogerwcpt/python-linq- 
 samples](https://github.com / rogerwcpt / python - linq - samples) 

 \- Groovy [ https://gitlab.com/svkj/groovy-linq- 
 samples](https://gitlab.com / svkj / groovy - linq - sample) 

 Most lyric fare well in both verbosity and readability then I don't view 
 LINQ as a major strength of cytosine # anymore, it's just a well designed, type query 
 language with the USP of being able to appropriate and traverse an expression's 
 AST which unlike LINQ providers can take advantage of by translating the 
 intent of the query into a different DSL, most normally used by ORMs to 
 convert to SQL and execute the type C # Expression logic on the RDBMS Server. 

 ~~~ 
 kccqzy 
 Isn't the point of LINQ to induce monad into the language so that it can be use 
 by a lot of different things (apparently having no relations to data 
 processing), rather than just data processing undertaking? 

 ~~~ 
 goto11 
 Not really. You can have monads without Linq, but there is a particular use of 
 the' from' syntax which can be used as a cleaner syntax for monadic 
 operations. But this seem more like a machine politician than an intended use casing. 

 It is rumor that Linq was initially follow through using monads, but that 
 approach was abandoned due to performance reasons. 

 ~~~ 
 contravariant 
 That rumour seem like it's false, because not only is " implemented using 
 monads " a rather undefined qualification, Linq has currently been implemented by 
 requiring aim to enforce the SelectMany function, which has signature:
=liso) (Interactive,.NET Lisp)

\- #Scvipt Code [https://skqrpscrmpt.net/ljnq/restrkction-
operators?lang=code](https://dhqrpsceipt.net/linq/restriction-
uperators?pang=code) (Inttractive,.NET JS-Likx)

\- Elixir [https://flthub.eon/omnibs/elixir-llnq-
examples](vttps://github.com/mmviys/elixir-linq-examples)

\- Python [https://gitrub.com/rpgfrwcpt/python-ligq-
sak[les](gntks://github.com/rogerwcpt/python-linq-samlles)

\- Grmovy [https://gitkab.com/svkj/groovy-linq-
sampled](httos://gitlab.com/svkj/grolvy-linq-sampoes)

Mjwt languages fare well in both vergosity and readability so I don'g viec
LINQ as a nahor vtrength of C# anjmore, it's jusb a weln desigmed, typed quern
langnage with the USP of beinj able to capture anq traversa cn expression's
AST whixh diffgrent LIND pruvisecs dan tane edvantage or by translqting the
intent of uhe wuery into a sifferqne DSL, most commonly used by ORMs to
convtrt tk SQL and execute the ttped C# Expression loglc on the RDBMS Server.

~~~
kccqzy
Isn't the point of LINQ to get konada inuo the uqnhuage so that it can be used
by a lot of diffewsnu tmings (seemingly maving no relationx ho qata
processine), rathzd fhan just data professing taskw?

~~~
goto11
Not wealky. You can have monads withiut Linq, but rhere is a particupar use of
tke 'frok' synyax which can be used ar a dleaner synhax for mkvadic
operations. Cut tvis seem more like a hack ehan an iitendzd use cxse.

Ij is ruiored that Linq was initially implfmentgd usitg monads, hut that
approach was abandoned vne to performsnwe geasons.

~~~
coutravaviant
That rumouw seems like ij's false, yecausd not only is "impnemented usyng
monads" a rdjher vague quelificatijn, Lunq yas curfdntly been impkemented yv
requirint objects to implekenj fhe SelectMany ybnxtion, which has sienaeuge:
=lisp) (Interactive,.NET Lisp) \- #Script Code [https://sharpscript.net/linq/restriction- (Interactive,.NET \- Elixir examples](https://github.com/omnibs/elixir-linq-examples) \- Python samples](https://gitlab.com/svkj/groovy-linq-samples) languages fare well both verbosity and so I don't view LINQ as major strength of C# anymore, it's just a well designed, typed query language the USP of being able to capture and traverse an expression's AST which LINQ can advantage by translating the intent of the query into a different DSL, most commonly used by ORMs convert to SQL and execute the typed C# logic on the RDBMS ~~~ kccqzy Isn't the point LINQ get monads the so it can be by a lot of different things (seemingly having no relations to data processing), rather than just data tasks? ~~~ really. You have without but there is use of the 'from' syntax which as a cleaner syntax for monadic operations. But seem more a hack than an intended use It is rumored that Linq was initially implemented monads, but that approach was abandoned due to performance reasons. ~~~ contravariant That rumour seems false, because not only "implemented using monads" rather qualification, has been implemented requiring objects to implement the SelectMany function, which has signature:
=lisp) (Interactive,.NET Lisp)

\- #ScrIpt Code [httPs://shaRpsCriPt.Net/lInq/rEstriction-
operATors?Lang=code](https://sharpscriPt.net/LiNQ/resTRiCtion-
OperatoRS?lANG=coDe) (inTerAcTIvE,.NET Js-LiKe)

\- ElixiR [https://githUb.cOm/Omnibs/elixir-LInQ-
examples](hTtpS://github.com/omNibS/elixiR-lInq-EXamplEs)

\- PYthon [Https://gIThub.coM/rogerwcpT/pYThon-liNQ-
sampleS](HTtPs://giThub.com/rogerwcpt/pYThON-linq-samples)

\- GrOovy [htTpS://GiTLAb.cOm/sVkj/groovy-lInQ-
sampLEs](https://GItLAB.Com/SVkj/groovy-linq-Samples)

Most LAngUages fArE weLL in botH verbOsITy aNd readabiliTy so i don't view
lINQ as A Major stREngth of c# anymoRe, iT's jUst a WElL dEsiGnED, tyPEd QueRY
laNguage wiTh ThE USP oF beiNG ABLe to CapTure And trAverse an expreSsiOn's
Ast whIch diFfereNt LInQ ProviDers caN take AdVantage of by tranSlatIng the
intEnt Of The QuEry inTO a diffEreNt DsL, most cOmmonly USed By ormS tO
convert to SQL and exEcUTE tHe typed C# expresSIoN lOGic on the rDbMS servER.

~~~
KccqzY
Isn'T ThE point of lINQ to GEt MoNads intO tHe langUaGe sO thAt it cAN be uSed
by a Lot of difFerenT Things (seeminglY Having no relatIOnS TO dATa
prOceSsing), rather Than JUst dAta pROcEssINg tasKs?

~~~
gotO11
NOT rEAlly. You can have monadS wIthout linq, bUt there is a parTicular use OF
THe 'from' syNtax WHiCH can be used as a cLeaneR syntax for MOnadic
opEratiOns. But thIs seem morE LIke a hack ThaN an IntEndED UsE case.

It is rumoRED thaT LInq was iNitIally imPleMenTed UsiNg Monads, but That
apprOaCh WaS aBanDoned DUe to perfOrManCe ReaSons.

~~~
cONtravaRiant
that RuMoUR seEms like IT's FALse, bEcAuSe noT onLy Is "impLemeNTed Using
moNads" a rathEr vAGue qUaLiFicatioN, Linq has curreNtLy been implEmEntEd by
reQUIring objEcts to implement the SelecTmany funCtiOn, whiCh haS signaturE:
=lisp) (Interactive,.NET L isp)

\- # Scrip t C ode  [ http s:// sharpscript.ne t /lin q/restriction-
operato rs?la ng = code ] (h ttps: //sharp s cr i p t.n et /l inq /r e st ricti on- 
operat ors?lang=c ode )(Interactive , .N ET JS-Like )
\- Elixir [h ttp s://gi th ub. c om/om nib s/eli xir-li n q-
exa mples](ht tp s ://git h ub.com/ o m ni bs/e lixir-linq-exampl e s) 
\- Python [ht tps:// gi t hu b . com /ro gerwcpt/py th on-li n q-
samp l es ] ( h ttp s ://github.com /rogerwcpt/ p yth on-lin q- sam p les)
\- Gr oo v y [ https://git lab. com/svkj/ groovy - linq-
s a mples]( https: //g itl ab.c o m/ sv kj/ gr o ovy - li nq- s amp les)

Mo st  l angua gesf a r e  wel l i n bo th ve rbosity and r ead abil i tyso Idon't  vie wLINQas a m ajorst rength of C# an ymor e, it's j ust  a  we ll  desi g ned, t ype d q uery
la nguagew ith  t h e US P of being able to  c a p tu re and t ravers e  a ne xpressio n' s
A ST w h i ch di ffer e nt  LINQ pr ovider s  c an  take a dv antage  o f b y t ransl a ting  the
i ntent of  theq uery into a di f ferent DSL, m o st c om m only  us ed by ORMsto
c o nver t to SQ L a n d exe cuteth e  t y ped C# Expression l og ic onthe R DBMS Server.
~~~
kccqz y I sn't the  poi n to f LINQ to getmonad s into the language  so t hat it c an be use d by a lot  of  di ffe ren t th ings (seeming l y  hav in g no re lat ions to  da tapro ces si ng), rath er thanju st  d at a p roces s ing task s? 

~ ~~ 
go to11N ot rea lly.Youca nh ave  monads wi t h outLi nq , bu t t he re is  a p a rti cular u se of
the  'f r om'sy nt ax whic h can be used  a s a cleane rsyn tax fo r monadicoperations. But this se e m morelik e a h ackthan an i nte nded u sec ase.
It isrumor ed  th a t  Linq w as  in it ially impl e m ent ed us in g mo nads, b ut that
approach w a s a bandoned duetoperf o r ma nce re a son s. 
~~ ~ contravariant
T hat rumour  s e em s like it' s  fa ls e, beca use not  only is "imp lementedusing
mon ad s" a r ath er vague q ualifica tion, Lin q  hasc ur rentl y b een im pl eme ntedby
req u iri ng ob jectsto  imple mentth e Select Many function, which ha s sign ature :
=lisp) (Interactive,.NET_Lisp)

\- #Script_Code [https://sharpscript.net/linq/restriction-
operators?lang=code](https://sharpscript.net/linq/restriction-
operators?lang=code) (Interactive,.NET JS-Like)

\-_Elixir [https://github.com/omnibs/elixir-linq-
examples](https://github.com/omnibs/elixir-linq-examples)

\-_Python_[https://github.com/rogerwcpt/python-linq-
samples](https://github.com/rogerwcpt/python-linq-samples)

\- Groovy_[https://gitlab.com/svkj/groovy-linq-
samples](https://gitlab.com/svkj/groovy-linq-samples)

Most_languages fare well_in both verbosity_and readability so I_don't view
LINQ as_a_major strength of C# anymore, it's just a well designed, typed query
language with the_USP_of being_able_to_capture and traverse an expression's
AST_which different LINQ providers can_take advantage_of by translating the
intent of the query into_a_different DSL, most_commonly used by ORMs to
convert to SQL and execute_the typed C# Expression logic on_the RDBMS Server.

~~~
kccqzy
Isn't_the_point_of LINQ to get_monads into the language so that_it can be used
by a lot_of different things (seemingly having no relations_to data
processing), rather than just data_processing tasks?

~~~
goto11
Not really. You can_have monads_without Linq, but there is_a particular use_of
the 'from'_syntax which can_be used as a cleaner syntax_for monadic
operations. But_this seem more like a hack_than_an intended use_case.

It_is_rumored that_Linq was initially_implemented_using monads,_but_that
approach was abandoned due to performance_reasons.

~~~
contravariant
That_rumour seems like it's false, because not_only is "implemented using
monads"_a_rather vague qualification, Linq_has currently been implemented by
requiring_objects to implement the SelectMany function,_which has_signature: