What language to learn after Haskell? -

as first programming language, decided learn haskell. i'm analytic philosophy major, , haskell allowed me , correctly create programs of interest, instance, transducers natural language parsing, theorem provers, , interpreters. although i've been programming 2 , half months, found haskell's semantics , syntax easier learn more traditional imperative languages, , feel comfortable (now) majority of constructs.

programming in haskell sorcery, however, , broaden knowledge of programming. choose new programming language learn, not have enough time pick arbitrary language, drop it, , repeat. thought pose question here, along several stipulations type of language looking for. subjective, intended ease transition haskell.

• strong type system. 1 of favorite parts of programming in haskell writing type declarations. helps structure thoughts individual functions , relationship program whole. makes informally reasoning correctness of program easier. i'm concerned correctness, not efficiency.
• emphasis on recursion rather iteration. use iterative constructs in haskell, implement them recursively. however, easier understand structure of recursive function complicated iterative procedure, when using combinators , higher-order functions maps, folds , bind.
• rewarding learn. haskell rewarding language work in. it's little reading kant. experience several years ago c, however, not. i'm not looking c. language should enforce conceptually interesting paradigm, in entirely subjective opinion, c-likes not.

weighing answers: these notes, of course. i'd reply gave well-formed responses. have been helpful.

1) several responses indicated strong, statically typed language emphasizing recursion means functional language. while want continue working haskell, camccann , larsmans correctly pointed out such language "ease transition much." these comments have been helpful, because not looking write haskell in caml! of proof assistants, coq , agda both interesting. in particular, coq provide solid introduction constructive logic , formal type theory. i've spent little time first-order predicate , modal logic (mendellsohn, enderton, of hinman), have lot of fun coq.

2) others heavily favored lisp (common lisp, scheme , clojure). gather, both common lisp , scheme have excellent introductory material (on lisp , the reasoned schemer, sicp). material in sicp causes me lean towards scheme. in particular, scheme through sicp cover different evaluation strategy, implementation of laziness, , chance focus on topics continuations, interpreters, symbolic computation, , on. finally, others have pointed out, lisp's treatment of code/data entirely new. hence, leaning heavily towards option (2), lisp.

3) third, prolog. prolog has wealth of interesting material, , primary domain 1 i'm interested in. has simple syntax , easy read. can't comment more @ moment, after reading overview of prolog , skimming introductory material, ranks (2). , seems prolog's backtracking being hacked haskell!

4) of mainstream languages, python looks interesting. tim yates makes languages sound appealing. apparently, python taught first-year cs majors; it's either conceptually rich or easy learn. i'd have more research.

thank recommendations! looks lisp (scheme, clojure), prolog, or proof assistant coq or agda main langauages being recommended.

i broaden knowledge of programming. (...) thought pose question here, along several stipulations type of language looking for. subjective, intended ease transition haskell.

strong type system. (...) makes informally reasoning correctness of program easier. i'm concerned correctness, not efficiency.

emphasis on recursion rather iteration. (...)

you may easing transition bit here, i'm afraid. strict type system , purely functional style characteristic of haskell , pretty resembling mainstream programming language require compromising @ least on 1 of these. so, in mind, here few broad suggestions aimed @ retaining most of seem haskell, major shift.

• disregard practicality , go "more haskell haskell": haskell's type system full of holes, due nontermination , other messy compromises. clean mess , add more powerful features , languages coq , agda, function's type contains proof of correctness (you can read function arrow -> logical implication!). these languages have been used mathematical proofs , programs extremely high correctness requirements. coq prominent language of style, agda has more haskell-y feel (as being written in haskell itself).

• disregard types, add more magic: if haskell sorcery, lisp raw, primal magic of creation. lisp-family languages (also including scheme , clojure) have unparalleled flexibility combined extreme minimalism. languages have no syntax, writing code directly in form of tree data structure; metaprogramming in lisp easier non-meta programming in languages.

• compromise bit , move closer mainstream: haskell falls broad family of languages influenced heavily ml, of shift without too difficulty. haskell 1 of strictest when comes correctness guarantees types , use of functional style, others either hybrid styles and/or make pragmatic compromises various reasons. if want exposure oop , access lots of mainstream technology platforms, either scala on jvm or f# on .net have lot in common haskell while providing easy interoperability java , .net platforms. f# supported directly microsoft, has annoying limitations compared haskell , portability issues on non-windows platforms. scala has direct counterparts more of haskell's type system , java's cross-platform potential, has more heavyweight syntax , lacks powerful first-party support f# enjoys.

most of recommendations mentioned in other answers, rationale them offers enlightenment.