• LISP (thread)
  
• LISP's dialects (the above LISP thread covers all of these):
  
  • Common Lisp (https://common-lisp.net)
    
  • Clojure (http://clojure.org/)
    
  • Scheme (http://www.schemers.org/)
    
  • Racket (http://racket-lang.org/) (Thanks duck monster)
    
• Haskell (https://www.haskell.org/)
  
• Erlang (http://www.erlang.org/) (thread)
  
• OCaml (http://ocaml.org/)
  
• Scala (http://www.scala-lang.org/) (thread)
  
• F# (http://fsharp.org/)
  
• Elixir (http://elixir-lang.org/)
  

• How to Design Programs and Structure and Interpretation of Computer Programs: These are two very famous books on how to design programs, both using LISP dialects (Racket for the former and Scheme for the latter). Highly recommended. Many people consider HtDP to be a more-accessible and modern version of SICP. There is also a work-in-progress version of SICP using Lisp-Flavored-Erlang. (Thanks giogadi and MononcQc)
  

• Learn You A Haskell: This book is written in a somewhat snarky tone, which turns some people off, but it's a pretty good introduction to Haskell. In particular, I like the sections where the author lists a series of useful functions for manipulating whatever he has just introduced.
  
• Real World Haskell: This book is somewhat more serious and practical than LYAH, and covers a few more useful libraries. It is also an excellent read.
  
• Haskell Programming From First Principles: An up-to-date introduction to Haskell, still in early access. Recommended by Charlie Mopps
  

• The Haskell Wiki
  
• Hoogle: A Haskell search engine, which can be searched by function signature (which is really useful!)
  
• Hackage: This is the Haskell package archive.
  
• Typeclassopedia: This is a really good resource for figuring out some of the weirder Haskell Typeclasses. (Thanks HappyHippo)
  
• What I Wish I Knew When Learning Haskell: Another really good learning resource. (Thanks HappyHippo)
  
• Eric Lippert's Monad Tutorial: Monad tutorial recommended by DimpledChad.
  
• UPenn's CIS194: An excellent series of lectures on Haskell, recommended by KaneTW.
  
• BiteMyApp/LearnHaskell: Haskell guide recommended by KaneTW.
  
• Category Theory by Tom LaGatta: A video lecture on category theory recommended by RobertKerans
  

• Try F#: Try F# in your browser!
  
• F# For Fun and Profit: A website with a thorough "Why F#?" series, well worth looking through to get a sense of what's available in F#.
  
• F# Foundation: A pretty good directory of F# resources.
  

• Websharper: Write webapps in 100% F#. F# on the server, HTML combinators to generate HTML, and an F#->JS transpiler (although it can work with normal HTML templates if you so desire)
  
• Visual F# Power Tools: While Visual Studio supports F# by default, it's kind of half-assed. This extension makes it a bit more fully-assed and generally improves quality of life quite a bit.
  

render : (Int, Int) -> Element
render (x, y) = Graphics.Element.show (x, y)

-- Mouse.position is a built-in input Signal in Elm of type "Signal (Int, Int)"
main : Signal Element
main = Signal.map render Mouse.position

-- MODEL (Where you define the data structures that will be used to represent your program's state)

type alias Model = { ... }


-- UPDATE (Where you define the possible actions, map input Signals to these actions, 
--         and write one or more state machines that define how your program state updates on each action)

type Action = Reset | ...

update : Action -> Model -> Model
update action model =
  case action of
    Reset -> ...
    ...


-- VIEW (Where you define how to visually display your program model. 
--       In Elm, you don't define visual transitions as such, rather 
--       you define what the entire output should look like given any possible model)

-- view can also be Model -> Element
view : Model -> Html 
view =
  ...

• Tetris attack, written in Elm by giogadi
  
• (Your stuff here!)
  

VikingofRock fucked around with this message at 05:03 on Jan 2, 2016

• If you pass ">>=" the result of "return(x)" and a function "f", you must get back the same thing as you would passing "x" directly to "f".
  
• If you pass ">>=" a Monad<T> and the function "return", you must get back the original Monad<T>.
  
• ">>=" must be associative.
  

flatten : Tree a -> List a
flatten tree = 
    case tree of
      Empty -> []
      Node value left right -> 
          flatten left ++ (value :: flatten right)

VikingofRock fucked around with this message at 23:52 on Dec 30, 2015