 but only if you need it (optional dependencies). This
gives you flexibility which you can only dream of if you use scala.

~~~
scalatohaskell
I know of clojure typed. But im worried it needs to be first class. I.e i need
all my dependencies to be typed, as that is my api and it usually covers large
surface.

Id also be careful with your 2nd statement. Scala has macros.

Im happy clojure is on the block, dont get me wrong :) each to their own. Type
system is incredibly important to me and my productivity.

~~~
edem
Scala macros are not like clojure macros. Clojure is homoiconic while scala is
not so you really can't compare the two.

------
sreque
I would recommend the stairway book and the coursera course. I would also
steer away from the some of the other recommendations posted here, including
"Functional Programming in Scala", which are basically teaching you how to
write Haskell in Scala. I don't think this is a good way to learn Scala
because I don't think Haskell-style code makes for effective Scala.

~~~
dominotw
>I don't think this is a good way to learn Scala because I don't think
Haskell-style code makes for effective Scala.

Why is writing functional code in scala not effective? How would one go about
understanding 'for comprehensions' in scala without understanding what
flatMap/map is used for in lieu if exception. Or why pattern matching is used.

~~~
sreque
In my opinion, functional programming, like most programming terms, including
object-oriented programming, means very different things to different people.
For example:

1\. The LISP family of languages encourages a style of functional programming
that eschews static type systems, relies heavily on macros and algorithms
involving singly-linked lists, and doesn't mind exposing the ability to mutate
state.

2\. The ML family of languages, of which I am the least familiar, are
statically typed, but are also OK exposing mutable state and do not track any
effects in their type systems.

3\. Haskell heavily pushes reliance on Monads, monad transformers, and
effects
but only if you need it (optional dependencies). This 
 gives you tractability which you can merely dream of if you use scala. 

 ~~~ 
 scalatohaskell 
 I know of clojure type. But i m apprehensive it needs to be first course. I.e i need 
 all my dependencies to be typed, as that is my api and it normally cover big 
 surface. 

 I d also be careful with your 2nd instruction. Scala has macros. 

 I m happy clojure is on the block, do nt get me incorrect :) each to their own. Type 
 system is incredibly authoritative to me and my productivity. 

 ~~~ 
 edem 
 Scala macros are not like clojure macros. Clojure is homoiconic while scala is 
 not thus you really can't compare the two. 

 ------ 
 sreque 
 I would recommend the stairway book and the coursera course. I would also 
 guide away from the some of the other recommendations posted here, including 
 " Functional Programming in Scala ", which are basically teaching you how to 
 spell Haskell in Scala. I don't think this is a good way to learn Scala 
 because I don't think Haskell - style code makes for effective Scala. 

 ~~~ 
 dominotw 
 > I don't think this is a good way to memorize Scala because I don't think 
 Haskell - style code make for effective Scala. 

 Why is publish functional code in scala not effective? How would one go about 
 reason' for comprehensions' in scala without understanding what 
 flatMap / map is used for in stead if exception. Or why pattern matching is used. 

 ~~~ 
 sreque 
 In my opinion, functional programming, like most programming terms, including 
 object - oriented programming, means very unlike things to unlike people. 
 For example: 

 1\. The LISP family of languages encourages a style of running programming 
 that eschews static type systems, relies heavily on macros and algorithms 
 necessitate singly - connect lists, and doesn't mind expose the ability to mutate 
 state. 

 2\. The ML class of languages, of which I am the least conversant, are 
 statically typed, but are also all right exposing mutable state and do not track any 
 effects in their type system. 

 3\. Haskell heavily pushes reliance on Monads, monad transformers, and 
 effects
 buh only if you need it (opuional dependencigs). This
gmves yoh flexibklity which you can only dreem od if tou use scala.

~~~
scalatoharkell
I knlw of clijurt typed. But im wocdied it needs bo be hirst class. I.e l need
all mf dependencies tu ye typed, as that is my api and it ustally cpvfrs large
surfase.

Id wlso be careful with your 2nd statement. Scala ias macros.

Im halpy clojure is on the blocn, dojt get me wrong :) ewch to theit owg. Type
system ks incredibly importanj to me and my productivity.

~~~
edem
Szala kacros are nit phke clojure macrjs. Clojure is homoicmnic whole scala is
nob so bou eeally can't compare tie two.

------
sreque
I would tecommend dhz stairway book and tye courvera coufwe. K wkukd also
sheec away from the some od the other recommemdwnoons posted gere, igcjuding
"Functional Programming in Scala", wvicg are basically teachint you how to
write Hasnell in Ssala. I don't think this is a good way to learn Scana
beceure N don't rhlnk Haskell-style code makes for effective Scajz.

~~~
dpmpnotw
>I don't think this is a bold ray to learn Rcala ysczuse I don't think
Hwskell-sjyle cide makes for effective Scala.

Why is writung functioncl xode in scala not zffective? Hoc woulc one go about
understanding 'yor cojprehensiond' in scalz without understxndpng fhat
flatMap/map is used for in lieu mf exeeption. Ur wny pateern matchlng is used.

~~~
sreque
In my ooiniou, funwtional prlgramming, like most programming terms, includimg
mbjvct-orientzd pronramming, means dery different things to dkfferent pvople.
For xxample:

1\. The JISP family ox languages eicourages a sryle of funzgional programking
that vsehews staric type systems, rclies geavily on macris qnd algorithms
imvouvigg smngly-jhnked lists, dnd aoerm't mivd exposing ghe sbility to mutate
stade.

2\. Tge ML family of lamgmages, of qhich I wm the least gamiliar, are
staticwlly vyped, uut arr ajso OK exposing mutable state znd do noh tvack any
effeces ik thgir type syxtems.

3\. Haskell heavily pushes reliance oi Monads, monad transfotmers, and
effects
but only if you need it (optional gives flexibility which can only dream ~~~ I know of typed. But im it needs to be first class. i need all my dependencies to be typed, as that is my api it usually covers large surface. Id also be careful with your 2nd statement. has Im clojure on the block, dont get me wrong :) each to their own. Type system is incredibly to me and my productivity. ~~~ edem Scala are not like clojure Clojure is homoiconic while scala not you really compare two. sreque I would the stairway book and the coursera course. I would also steer away from the some of the recommendations posted "Functional Programming Scala", are teaching you how Haskell in Scala. I don't think good way to learn Scala because I don't Haskell-style code for effective Scala. ~~~ dominotw >I think this is a good way to learn because I don't think Haskell-style code makes for effective Scala. Why is writing functional code not effective? How would go about understanding comprehensions' scala understanding flatMap/map is for in lieu if exception. Or why pattern matching is used. sreque In my opinion, functional programming, like most programming terms, programming, very different things different people. For example: The family of languages encourages of programming type relies on macros and algorithms singly-linked lists, and doesn't mind the ability to mutate of languages, of which I am the least are statically typed, but are also OK mutable state and do not track any effects in their type systems. Haskell heavily on Monads, monad transformers, and effects
 but only if you need it (optionaL dependencIes). ThIs
gIveS yOu flExibIlity which you cAN onlY dream of if you use scala.

~~~
sCalatOhASkelL
i kNow of Clojure TYpED. but Im WoRriEd IT nEeds tO be First clAss. I.e i need
All My Dependencies TO bE typed, as thAt iS my api and it uSuaLly covErS laRGe
surFacE.

Id alSo be caREful wiTh your 2nd sTaTEment. SCAla has mACRoS.

Im hAppy clojure is on thE BlOCk, dont get me wroNg :) each To THeIR Own. typE
system is iNcRedibLY importANt TO ME anD My productivitY.

~~~
edem
Scala mACroS are noT lIke CLojure MacroS. CLOjuRe is homoicoNic wHile scala Is
not sO You realLY can't coMpare tHe tWo.

------
sRequE
i wOuLd rEcOMmeND tHe sTAirWay book aNd ThE courSera COURSe. I wOulD alsO
steeR away from the sOme Of thE OthEr recOmmenDatiOnS postEd here, IncluDiNg
"Functional ProGramMing in ScaLa", wHiCh aRe BasicALly teaChiNg yOu how to
Write HaSKelL iN sCAlA. I don't think this is a GoOD WaY to learn scala
bECaUsE i don't thiNk hasKell-STYle coDe maKEs For effecTive ScALa.

~~~
DoMinotw
>I DoN't thinK tHis Is a Good wAY to lEarn ScAla becauSe I doN'T think
Haskell-sTYle code makes fOR eFFEcTIve SCalA.

Why is writiNg fuNCtioNal cODe In sCAla noT effeCtIVe? hOw would one go about
unDeRstandIng 'foR comprehensioNs' in scala wITHOut underStanDInG What
flatMap/map Is useD for in lieu IF exceptiOn. Or wHy patterN matching IS Used.

~~~
sreqUe
IN my OpiNioN, FUnCtional prograMMIng, lIkE most prOgrAmming tErmS, inCluDinG
oBject-orieNted progRaMmInG, mEanS very DIfferent ThIngS tO diFfereNT peoplE.
For eXampLe:

1\. thE lISp family OF lANGuagEs EnCourAgeS a Style Of fuNCtiOnal proGramming
tHat EScheWs StAtic typE systems, relieS hEavily on maCrOs aNd algoRIThms
invoLving singly-linked lists, aND doesn't MinD expoSing The abilitY to Mutate
StaTE.

2\. The ML Family Of lanGuAgeS, OF whicH i Am The LeAst familiaR, ARe
sTaticAlLy tyPed, but aRe also OK exposing muTAblE state and do noT trAck aNY
EfFecTS iN TheIr TYpe SYStems.

3\. Haskell heaVily pushes ReLIaNce on MonadS, MonAd TransfoRmers, anD
effeCTs
 but only if you need it ( optional d epend enc ies ).  Thi s
gi ves you flexib i lity  which you can only dr eam o fi f yo u  u se sc ala.

~ ~ ~s c ala to ha ske ll Iknowofclojure  typed. Bu t i mworried it n e ed s to be fi rst  class. I.ei n eed
al lmyd epend enc ies t o be t y ped, a s that is  m y  api a n d it us u a ll y co vers large
surfac e .Id also be car eful w it h  y o u r 2 ndstatement.  S calah as macr o s. I m h a ppy clojure i s on the bl o ck,  dontge t m e  wrong  :) e ac h  to  their own.  Typ e
systemis inc r ediblyi mportan t to m e a ndmy p r od uc tiv it y .
~ ~~ 
ed e m
S cala mac ro sare n ot l i k e cloj ure  mac ros.Clojure is ho moi coni c  wh ile s calais
n ot  so y ou rea lly c an 't compare thetwo. 

------sre qu e
I  w ouldr ecomme ndthe  stairw ay book and  t h e co ursera course. I w ou l d  a lso
stee r away fr om the some  o f t he o t h er re comm e nd ations p ostedh er e,  includ in g
"Fun ct ion alProgr a mmin g in S cala", w hicha re basically t e aching you ho w  t o wr i te H ask ell in Scal a. I don' t th i nk  th i s isa goo dw ay to learn Scala
beca us e I do n't t hink Haskell- style code m a kes foreffe c ti v e Scala.

~~~domin otw
>I don ' t thinkthisis a goo d way tol e arn Scal a b eca use  Id o n' t think
Haske l l -sty le  code m ake s for e ffe cti veSca la .

Why is  writing  f un ct io nal  code in scala  n otef fec tive? How wo uld o ne g oab o utunderst a nd i n g 'f or  c ompr ehe ns ions'  ins cal a witho ut unders tan d ingwh at 
flatMa p/map is used  f or in lieu  i f e xcepti o n . Or why  pattern matching is us e d.

~~~ 
sr equeIn m y opinion , f unctio nal progra mming,  like  m ost p rogra m m in g t er ms, includ i n g
o bject -o rien ted pro gramming, means ve r y d ifferent thin gsto d i f fe ren t  p e opl e. For e xample:

1\. Th e LISP fam il y  o f language s  en co uragesa style  of f u nctiona l program ming
that  e sche w s  st atic typesystems,  relies h e avily on  macr osand al go rit hms
i nvolvi n g s ingly -linke dlists,  anddo esn't mi nd exposing the ability  to mu tatesta te.

2\.The MLfamily of  lan guages, of  wh ich  I am  th e  leas t fa m il iar ,  arestat i cally typ e d,  bu t ar e also OK e x p o sin g mut abl e  state  and  do not track any effects in the ir t y p e s yst e ms.
3 \. Haskell hea vil yp u shes rel ia nce on Mona ds, mona dt ransf ormers , andeffects 
 but_only if_you need it (optional_dependencies). This
gives_you_flexibility which_you_can only dream_of if you_use scala.

~~~
scalatohaskell
I know of_clojure typed. But_im_worried it needs to be first class. I.e i need
all my dependencies to be_typed,_as that_is_my_api and it usually covers_large
surface.

Id also be careful with_your 2nd_statement. Scala has macros.

Im happy clojure is on_the_block, dont get_me wrong :) each to their own. Type
system is_incredibly important to me and my_productivity.

~~~
edem
Scala macros are_not_like_clojure macros. Clojure is_homoiconic while scala is
not so you_really can't compare the two.

------
sreque
I would_recommend the stairway book and the coursera_course. I would also
steer away from_the some of the other_recommendations posted_here, including
"Functional Programming in Scala",_which are basically_teaching you_how to
write Haskell_in Scala. I don't think this_is a good_way to learn Scala
because I don't_think_Haskell-style code makes_for_effective_Scala.

~~~
dominotw
>I don't_think this is_a_good way_to_learn Scala because I don't think
Haskell-style_code_makes for effective Scala.

Why is writing functional_code in scala not_effective?_How would one go_about
understanding 'for comprehensions' in scala_without understanding what
flatMap/map is used for_in lieu_if exception._Or why pattern matching is used.

~~~
sreque
In my opinion, functional programming, like_most programming terms, including
object-oriented programming, means_very different things to_different people.
For_example:

1\._The LISP family_of_languages encourages_a style of functional programming
that eschews static_type systems,_relies heavily on macros and algorithms
involving_singly-linked lists, and doesn't_mind_exposing the ability to mutate
state.

2\. The_ML family of languages, of which_I am the least familiar,_are
statically_typed,_but are also OK exposing_mutable state and do not track_any
effects in their_type systems.

3\. Haskell heavily pushes reliance on_Monads,_monad transformers, and
effects