1. Adding Portaudio Support To Hfm (haskell For Machine Learning
2. Adding Portaudio Support To Hfm (haskell For Mac Free
3. Adding Portaudio Support To Hfm (haskell For Mac)

CsoundQt CsoundQt is a free, cross-platform graphical frontend to Csound. It features syntax highlighting, code completion and a graphical widget editor for realtime control of Csound. It comes with many useful code examples, from basic tutorials to complex synthesizers and pieces written in Csound. It also features an integrated Csound language help display. CsoundQt (named QuteCsound until automn 2011) can be used as a code editor tailored for Csound, as it facilitates running and rendering Csound files without the need of typing on the command line using the Run and Render buttons.

Contribute to lotz84/haskell development by creating an account on GitHub. Skip to content. The Haskell Build Tool; Deploying Haskell for Mac projects on OS X and Linux. Adding PortAudio Support to HfM (Haskell for Mac) COMBINATORIAL MUSIC THEORY.

In the widget editor panel, you can create a variety of widgets to control Csound. To link the value from a widget, you first need to set its channel, and then use the Csound opcodes invalue or chnget. To send values to widgets, e.g. For data display, you need to use the outvalue or chnset opcode. CsoundQt also now implements the use of HTML and JavaScript code embedded in the optional element of the CSD file.

If this element is detected, CsoundQt will parse it out as a Web page, compile it, and display it in the 'HTML5 Gui' window. HTML code in this window can control Csound via a selected part of the Csound API that is exposed in JavaScript. This can be used to define custom user interfaces, display video and 3D graphics, generate Csound scores, and much more. See Chapter 12, Section H, Csound and Html for more information. CsoundQt also offers convenient facilities for score editing in a spreadsheet like environment which can be transformed using Python scripting (see also chapter 12C). You will find more detailed information and video tutorials in the CsoundQt home page at. Configuring CsoundQt CsoundQt gives easy access to the most important and to many specific CsoundQt settings via its Configuration Panel.

In particular the 'Run' tab offers many choices which have to be understood and set carefully. The current version of CsoundQt's configuration settings should be found at So the following descriptions may be outdated. To open the configuration panel simply push the 'Configure' button.

The configuration panel comprises 7 tabs. The available configurable parameters in each tab are described below for each tab. Run The settings at the top of the “Run” tab allow the user to define the command-line flags with which Csound is invoked. Buffer Size (-b) This defines the software buffer size (corresponding with the -b flag). If you do not tick, CsoundQt will use the defaults. If you tick to enter an own value, these are some hints:.

Always use power-of-two values. Usually the block size is 1/4 or 1/2 of the software buffer size. If you use live input and output, it is most effective to set the software buffer size to an integer multiple of ksmps ('full duplex audio'). Use smaller values (e.g.

128) for live performance (in particular with live input), as it will reduce the latency. Use larger values (e.g. 1024) for other cases, for instance playing sound files. HW Buffer Size (-B) This defines the hardware buffer size (corresponding with the -B flag). If you do not tick, CsoundQt will use the defaults.

If you tick to enter an own value, these are some hints:. Always use a multiple integer of the software buffer size. A common relation is: Hardware Buffer Size = 4.

Software Buffer Size. The relation between software buffer size and hardware buffer size depends on the audio module.

Use new parser Tick this if you use Csound 5.14 or higher. This option has been introduced during the transition between the old and the new parser, and will disappear in future. Use multicore /Number of threads This option is only available when the new parser is enabled, and corresponds with the -j flag. For instance, ‘-j 2‘ will tell Csound to use 2 parallel processors when possible. You should use this option with care. It may be also worth to state that using multiple threads will not in each case improve the performance. Whether it does or not depends on the structure of the csd file you run.

Dither Switches on dithering (the -dither flag) for the conversion of audio from the internal resolution (now mostly 64 bit double precision float) to the output sample format (see below). Additional command line flags This enables the user to add any additional not listed here. Only use if you know what you are doing! File (offline render) These options determine CsoundQt's behaviour if you render to file (by pushing the Render button or selecting the menu item Control - Render to file).

Use CsoundQt options Tick this to activate the CsoundQT options configured here. Ignore CsOptions Use this to ignore the option embedded in the section of the csd files you are rendering. NOTE that care must be taken to avoid inconsistencies between CsOptions and CsoundQt options. For beginners, it is recommended to tick 'Ignore CsOptions' when the CsoundQT options are enabled. If you are a more experienced user, you can leave this unchecked to allow some additional options like -m128 to reduce Csound's printout. NOTE that if you have checked 'Use CsoundQt options' and have not checked 'Ignore CsOptions', in the case of a conflict between both the CsoundQt options set in the configure panel will have the priority. Ask for filename every time Ask for a filename to render the performance to.

File type / Sample format Use this to set the output file format. Input Filename Corresponds with the -i flag (Input soundfile name). Output Filename Corresponds with the -o flag for defining the output file name to which the sound is written. Realtime Play These options determine CsoundQt's behaviour if you push the Run button (or select the menu item Control - Run Csound). Use CsoundQt options Tick this to activate the CsoundQT options configured here. Ignore CsOptions Use this to ignore the option embedded in the section of the csd files you are running.

NOTE that care must be taken to avoid inconsistencies between CsOptions and CsoundQt options. For beginners, it is recommended to disable CsOptions when the CsoundQT options are enabled. If you are a more experienced user, you can leave this unchecked to allow some additional options like -m128 to reduce Csound's printout.

NOTE that if you have checked 'Use CsoundQt options' and have not checked 'Ignore CsOptions', in the case of a conflict between both the CsoundQt options set in the configure panel will have the priority. RT Audio Module This option is very much dependent on your operating system. In case you experience crashes or have problems with the real time performance, it is worth to try another module. The most common choices on the different operating systems are probably:. For Linux, use alsa or jack. For OSX, use coreaudio or portaudio. For Windows, use portaudio.

Adding Portaudio Support To Hfm (haskell For Machine Learning

Input device This option selects the device you are using for real-time input, for instance from a microphone. (Note that you must have ticked 'Use CsoundQt options' if you want Csound to use your selection.) The usual (and most stable) choice here is adc. In this case Csound will use the device which has been selected as standard by your operating system. If you want to use another device instead, click on the button at the right side. You will find a list of available devices and can choose one of them. Output device This option selects the device you are using for real-time output. (Note that you must have ticked 'Use CsoundQt options' if you want Csound to use your selection.) The usual (and most stable) choice here is dac.

In this case Csound will use the device which has been selected as standard by your operating system. If you want to use another device instead, click on the button at the right side.

You will find a list of available devices and can choose one of them. RT MIDI Module This option is very much dependent on your operating system.

In case you experience problems with MIDI, it is worth to try another module. In case you do not use any MIDI at all, select none to get rid of one possible source of trouble. The most common choices on the different operating systems are probably:. For Linux, use alsa or portmidi. For OSX, use coremidi or portmidi. For Windows, use portmidi. Input device This option selects the device you are using for real-time MIDI input.

(Note that you must have ticked 'Use CsoundQt options' if you want Csound to use your selection.) The usual choice here is a. In this case Csound will use all MIDI devices. In case your RT MIDI Module does not support this option, click on the button at the right side. You will find a list of available devices and can choose one of them.

Output device This option selects the device you are using for real-time MIDI output. (Note that you must have ticked 'Use CsoundQt options' if you want Csound to use your selection.) Jack client nam e This option specifies the name for communicating with a Jack audio client. The default '.'

means 'all' clients. General Run Utilities using: This should be self-explanatory and is only meaningful if you run any of the Csound Utilities like or the FFT analysis tool. Interface language Self-explanatory. Performance tweaks These are very important options in case you use CsoundQt for real-time usage and experience performance problems. No messages to consoles Tick this to disable any printout.

Disable recording and scopes This refers to CsoundQt's internal Record facility and to the Scope widget. Disable realtime score events If you check this, you will not be able to send any live score event, for instance from a Button widget or the Live Event Sheet.

Disable python callback If you do not use CsoundQt's internal Python scripting facility in real-time, you should check this to improve the overall performance. Internal MIDI interface The 'Internal MIDI interface' is the MIDI device from which MIDI control messages are sent directly to the CsoundQt widgets. Have a look, for instance, in the properties of a Slider widget to see the MIDI CC number and the MIDI Channel to be specified. Note that this does not set the input MIDI device for Csound itself (which has be explained above in Run - RT MIDI Module - Input device).

Record sample format Defines the bit depth of the audio file to which CsoundQt records its real-time output, when using the Record button (or the 'record' option from the Control menu). For most cases 32bit float or 24bit formats are recommended. The former is particularly useful as it can hold ‘clipped‘ sample values, which can be later normalised. Console You can choose here how the Csound output console looks like. Control message buffer size If you do not not want to prevent CsoundQt from printing anything to the console at all (see above) but want to reduce this output for performance's sake, you can set here a limit. There are some mixed options at the bottom of this tab: Allow key repeats for sensekey If you press a key on your computer for a long time, the key is repeated. This may or may not be useful for the opcode and can be decided here.

Debug mode for Live Event Sheet Self-explanatory. Allow simultaneous play If checked, it allows you to play more than one csd tab simultansously. Theme Allows you to choose between the traditional ('fun') CsoundQt look, and a more serious ('boring') one. Widgets Enable Widgets If not checked, you cannot use any of CsoundQt's widgets. Save Widgets in csd file Each csd file has a section for widgets and presets. These sections are hidden when you open your csd file in CsoundQt, but are visible in any text editor.

So if you do not have checked this option, you will not see any of your widgets the next time you open your csd. So, only useful if you want to export a csd without the widget tags. Show Widgets on play If checked, the widget panel will pop up each time you push the Play button. Show tooltips for widgets Enables a useful feature which lets you see the channel name of a widget if you stay a moment on it with the computer mouse.

Enable FLTK means a built-in (and somehow outdated) method of using widgets in Csound. As these widgets could conflict with CsoundQt's own widgets, you will usually uncheck this. Run FLTK csds in Terminal This lets you execute csd files which contain FLTK widgets without conflicting with CsoundQt. Store Old Widget Format CsoundQt started in using the file format for widgets from Matt Ingall's 'Mac Csound' for the sake of compatibility. Later it decided to use an own format; mainly for the build-in presets facility.

When you check this option, CsoundQt will save the old Mac Csound widgets format in addition to the new proper CsoundQt widget format. Open properties when creating widgets Usually you will this have ticked, to enter your channel name and other properties when you create a widget. Widgets are an independent window CsoundQt consists of many subwindows except the main Editor panel: the Console, the Help (Manual), the Inspector, and so on. If you check this option, the widget panel will not be considered as one of them, but as independent window. This means that you cannot dock it by double-clicking on the top, like all the other subwindows, but it may have advantages anyhow, depending on your operating system and your configuration. Font scaling / Font offset Affects the way the fonts are shown for instance in a Label widget. Editor Only one option needs some explanation: Autoplay files when launched from file If ticked, a csd file will play immediately when opened.

Environment There are some important settings here, along with some only for developers. We will focus on the options which can be important for all users.

Html Doc directory This refers to the folder containing the Canonical Csound Manual. If you choose View - Help Panel, and see nothing but a message like 'not found!' , you will have to set here the directory for the manual. Click on the browse button on the right side, and choose the folder where it is on your computer. SADIR (Sound Analysis Directory) You can set here the directory in which Csound will seek for analysis files like.pvx files. SSDIR (Sound Sample Directory) This is very useful to set a folder for sound samples, for instance used.

You can then refer to the sample only by name. SFDIR (Sound File Directory) To specify a directory for output files. This is usually be done in the 'Run' tab, as explained above (Output Filename). INCDIR (Include Directory) Specifies a directory for files which all called by the statement. Favorite dir Specifies a directory which will then appear under the menu as 'Favorites'.

Python script dir Usually you will leave this empty so that CsoundQt links to the Python Scripts it comes with. Only specify if you build CsoundQt or want to change the scipts folder. External Programs Should be self-explanatory. 'Dot' is the executable from It is used in CsoundQt for the Code Graph Viewer (View - View Code Graph). Template This tab is useful as it allows the user to define a default template for new CSDs.

Something like this can be a great timesaver:. According to the relevant, the defaults are 256 for Linux, 1024 for OSX and 4096 for Windows. According to the manual, 1024 for Linux, 4096 for OSX and 16384 for Windows. In the explanation of Victor Lazzarini (mail to Joachim Heintz, 19 march 2013): '1.

For portaudio, -B is only used to suggest a latency to the backend, whereas -b is used to set the actual buffersize. For coreaudio, -B is used as the size of the internal circular buffer, and -b is used for the actual IO buffer size. For jack, -B is used to determine the number of buffers used in conjunction with -b, num = (N + M + 1) / M.b is the size of each buffer. For alsa, -B is the size of the buffer size, -b is the period size (a buffer is divided into periods). For pulse, -b is the actual buffersize passed to the device, -B is not used.

In other words, -B is not too significant in 1), not used in 5), but has a part to play in 2), 3) and 4), which is functionally similar.' . This options is only available in CsoundQt 0.7.3 or higher.

For older versions, you must use the command line flag -+rtmidi=coremidi. Or download the manual, if necessary, from sourceforge (currently http://sourceforge.net/projects/csound/files/csound5/csound5.19/manual/).

and perhaps fully grokking these essential constructs before moving on to using them indirectly through all the layers of pretty syntax would have helped me understand all those features better. This is the approach we take in our book, Haskell Programming from First Principles. The book starts with a brief introduction to lambda calculus and builds on what the reader knows incrementally. You can see in our chapter listing: what order we do things in.

Importantly, it's not just show & tell. The book has a lot of exercises and detailed explanation for the concepts covered. I'd worked with and taught quite a few people before starting the book, in addition to maintaining a fairly popular guide for learning Haskell and helping people working through the recommended materials. Further, my coauthor on the book was completely new to programming when she began working with me. What we cover and in how much detail is influenced by working with her, our 10 deep-dive reviewers, and the over 1,300 emails of feedback/questions we've gotten from readers.

What I did in the book is based on that experience and data. If I could've written less and still solved the same problems, I would've. Maybe a future edition will be shorter after we refactor some things.

I'd submit that our book builds from the ground up and covers dramatically more than FPiS, you can see our chapter listing here: Also see my other comment here which mentions the process we used: The book covers so much because wanted it to work for people who 1. Weren't necessarily familiar with FP or at all, or in some cases, programming period.

Would be able to apply Haskell or learn more advanced concepts on their own after working through the book. #2 required covering much more of the intermediate stuff than any of the existing books available. I wrote the book because of the problems detailed in this blog post with the pre-existing materials.

Awesome, thanks for sharing! Here are some other resources to learn Haskell: 1. Learn You a Haskell for Great Good -can read the text for free online 2. UVa Student Taught Haskell Course - 3. Learning Haskell - 4. Haskell Programming - A question for the author - did you review the other learning materials (i.e. Competition or maybe complement(s)) and find discrepancies that made you want to create a better learning resource or were you primarily motivated by how awesome of an experience you had learning Haskell and the desire to share that with others?

Yeah, I’ve read/reviewed most of them. I could give long opinions on each, but overall I would say that I wanted an easy way to get into the language by building instead of endlessly going over all of the intricacies of the language. There is a time for that, but I’d argue it’s after you get in, get the basics, and start playing. I almost called this a “crash course in Haskell” but I didn’t like what “crash” connotes. I just really want to get people into the practicalities of what’s important as quickly as possible. I agree, and that's why we didn't go with 'crash course.'

There's a certain amount of stuff you simply have to work through and know in order to use Haskell, for sure. This course isn't mutually exclusive to something like Haskell Book.

The intention is to provide a comprehensive overview so you can quickly get up to speed, have a sense for what real world programming in Haskell looks like and gain a familiarity with the basic concepts that are used over and over. If, after that, you're motivated to go through a 1000 page book, that will serve you well. I don’t want to spend too much time discussing the concerns I have with other resources other than to say that I think the reason LYAH is popular is because it’s free, not so much because it’s the best resource ever created. There's some guess work in terms of pricing, but it reflects what I think we’ll need in order to justify the considerable time investment in putting something together that is really high quality A lot of the material has been created, but it takes a long time and lot of synthesis - a lot of feedback-receiving and iterating from others who are learning Haskell. I am the only instructor who will be speaking/recording videos, but I’m working with several others to fine tune the course.

And our intention is to provide a lot more resources, not only on functional programming, but on many elements and aspects of what I consider “advanced computing,” or “ongoing developer education.”. Coming from an SML background, one of the things that's always tripped me up about Haskell is that it doesn't have structures, signatures, and functors for grouping code. Instead it has modules, which are not much more than groups of exported functions. For Haskellers coming to SML, there's 'A Crash Course on ML Modules'1 which does a nice job of explaining things in the opposite direction. Are there any resources like this out there that discuss how best to break down and write modular Haskell programs? 1: (update: I realized the original article I linked to wasn't the one I thought it was!). This is an interesting question.

Adding Portaudio Support To Hfm (haskell For Mac Free

As much more of a Haskeller than an MLer I don't tend to feel the 'need' to structure my programs explicitly modularly, and when I do I sort of instinctively use a combination of typeclasses and polymorphic higher-order functions to do so. More basically, just think 'everywhere I would open a module, instead I can take a parameterized record of functions' (and furthermore, if a datatype uniquely determines that record, I can associate a typeclass to that datatype). There are limitations to this, but in fewer circumstances than you'd think - mainly about sort of cross-modularity (aka the expression problem).

There was a very nice discussion on lennart's blog about this in 2008, with a problem posed and some partial solutions (read bottom post to top). Once you end up with a typeclass and associate the methods the unpacking goes away and you're just working in a context parameterized by some typeclass.

I expressed it via that route to help make the connection to modules more clear. (there are occasions when you don't take that last step too, which is why i also sort of pointed towards that route). Lennart's post shows an example where this sort of falls down - but the followup also shows a nice haskelly solution that works, mainly, except when we want to intermix. He also suggests explicit type arguments as a way to make things nicer - those have now landed in GHC:-) the other relevant work in a broader sense that I should mention is regarding effectful contexts where idiomatically you declare a subclass of monad with the relevant operations, then instantiate it via the mtl or some other means, so you can swap out the IO backed 'real' one or various harnesses or add in logging layers, etc. Finally, i guess i should add that as a rule of thumb i've noticed that purity and laziness both help provide ways to give 'modular separation of concerns' directly. In particular, the most obvious thing we can do is just have each function do one thing to a bit of data, and produce a different bit of data and that's innately modular. But when we're interleaving IO (for example with mutable datastructures) and concerned with when computation happens (in a strict setting), then it feels we're paying for this too much because we get big intermediate structures.

But if you get the knack of just using pure lazy structures directly, you can sort of 'amortize out' the computation cost in a nice way and also the space cost (as conceptually some big data structures become produced 'on demand'). Of course if you get it wrong, blammo:-). You can't parametrize type classes over one another in the same way. In practice, this often makes ML style modules much more expressive: for example, I can have a Hashable type class with one implementation per type that is used by a HashSet data type or module, but with MLs there could be a number of modules for the same type implementing the hash function, which can be used to construct the set. This also means things like Monoids or Semigroups greatly benefit, since now you can easily have more than just (+) for ints, for example. You can even use this to derive operations like folds from your base module where you'd never have to apply the arguments to a folder; instead you could do Sum.fold or Product.fold based on the different base modules. I really, really like video tutorials.

I always have problems learning completely new languages because i can't motivate myself to complete the introductionary books. I want to start building things from day one, which is only possible when i am familiar with similar languages. With video-tutorials, i can watch them in the evening because the mental burden is not that great.

I know i will miss things, but i watch them rather quick so i can start hacking after a few days (or 2 weeks max). I normally hit the limits of what i can do quickly, because i did not go through a whole book and completed exercise after exercise, but this is no problem, because i have a basic understanding of various parts and can revisit the appropriate videos or google a bit. I am happy this looks like some decent videos will finally produced for haskell. Optimized pacing and pausing happens naturally when we read, but people nearly always talk way too slowly for me to learn effectively from videos, and pauses are never optimized for my personal needs. It isn't just a waste of time, I just can't learn effectively when the information is presented at the wrong pace. Have you tried using VLC for the bookmarking and frame-by-frame hot keys?

I exclusively use VLC for watching educational videos, so I can tweak the playback speed to my needs, and also jump backwards easily to have material repeated. One day we may have video players that watch our faces and body language to intelligently guess the best pace of playback, and note the sections where we are confused for future study. Yeah, I really like the video speed control for educational videos too. Curious, what speed do you normally use? More than 2x?

Did you know about this app for controlling speed of any HTML5 video element? I've recently started experimenting with uploading videos (math tutorials) to youtube already at 1.5x speed.

I think my lessons become much more interesting, but some people said they really hate the 1.5x speed, and prefer to watch me talk slowly, so I don't know if 1.5x should be the default. Do you know other people who like to watch technical videos at 1.5x and 2x, or are we the exception? I did not know about that HTML5 video speed controller, thank you for sharing that. Curious, what speed do you normally use?

More than 2x? It varies greatly depending on how fast the person talks normally, the difficulty/newness of the subject matter, and the way they phrase their sentences (useless filler words, or densely meaningful?) There are some videos where the person talks fast enough (on a topic new to me, without filler words) for me to listen comfortably at 1.0. At the other extreme if they talk exceptionally slowly, use lots of filler words, and the topic is easy or something I'm familiar with I may push it past 3.0. Also, if I'm reviewing videos I've already studied.

With foreign languages I may slow it down to 0.7 or so. Do you know other people who like to watch technical videos at 1.5x and 2x, or are we the exception? I just assumed everyone does this at some point in time, unless it hadn't occurred to them.

I mean, we all skim books that we've already studied, don't we? Refreshing our memory and looking for things we need to revisit (at normal reading speed)? Wouldn't everyone also want to 'skim' the videos they've already watched instead of re-watching at normal speed? I agree with you, its more efficient. For university i learn from the script and slides (and sometimes books). But i also think its much more exhausting. I play the video tutorials when i am in bed before i sleep (or while sleeping:) ).

They are way more relaxed, i don't have to pay that much attention. For me most of the time its a tradeoff between learning a bit and learning nothing.

I also get excited from watching the videos and can start doing toy-projects. And while books are a good way to get a gasp of the language, it think the only way to really learn a language is to use it. Thats one similarity between programming languages and 'real' foreign languages. The Elm wikipedia page has a good example of it's limitations compared to PureScript/Haskell: Unlike Haskell, Elm has no support for higher-kinded types, and thus cannot provide generic abstractions for many common operations.20 For example, there is no generic map, apply, fold, or filter function. Instead, such names are used prefixed by their module, such as List.map and Dict.map. 1 And from the above source link: You can't define higher-kinded things like Functor/Applicative/Monad/Foldable and do dictionary-passing style for ad-hoc polymorphism in Elm. 2 But personally, I haven't tried Elm yet so I can't comment.

Adding Portaudio Support To Hfm (haskell For Mac)

I'm not sure I want to invest in learning a whole new language/framework just to do front-end work. By learning PureScript I can transfer the same knowledge/experience coding in that language to the backend when using Haskell. Much like Clojurescript and a lesser extent Node.js.

While Elm is limited to front-end use. As a very superficial comparison, PureScript is a lot more similar to Haskell than to Elm.

All three are great languages, but of the three Elm is definitely the simplest and IMHO most beginner-friendly. It's also the least flexible and general.

In many ways, PureScript is actually a better version of Haskell (e.g., with extensible records). But it's currently very focused on front-end development, and it's missing amazing Haskell features like STM. So outside of front-end stuff it's not nearly as practical to use as Haskell. Here are some: - A Haskell library that simplifies access to remote data, such as databases or web-based services. ShellCheck, a static analysis tool for shell scripts - The hledger command-line and web-based accounting tool, a Haskell rewrite of ledger. Adds static typing to JavaScript to improve developer productivity and code quality.

Coq is a formal proof management system. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs. Any kind of project you would do in any other language:) My two favourite are either: - an IRC bot (will get you into threading, network programming etc) or a; - CMS starting with just basic blog functionality (i.e.

Authentication, talking to database to store posts etc) The first can usually be done with just the standard libraries or at least some of the smaller ones, and the latter will get you into web programming and usually involve bigger frameworks, such as Yesod (what I'd go with), Snap, Servant etc. Also, both of those types of projects are pretty well covered tutorial-wise. I'm not proposing that it's better, but it has a different focus.

LYAH is, firstly, very long. Furthermore, it's difficult to get a sense for how real world programming a purely functional programming works from LYAH. You'll learn some of common FP constructs from LYAH, but you'll still be pretty far from being able to write real applications. The goal of this course is to keep the content pretty restricted to the few, main concepts that are used over and over again and to gain experience with practice and real examples. Hope that helps. I still don't quite get it though.

Is being impractical actually a virtue for a strictly typed functional language nowadays? Like 'if it hurts more, you'll learn more' or something? Why would you drive a beginner towards Haskell and make some many 'Haskell for beginners tutorials' instead of OCaml or F# (even Scala fi you're into JVM.) which gives you the same features but slightly more practical (usable records, ability to be impure and imperative when you want etc., some kind of oop-style feature for when they really fit the way you want to model a problem, less 'string madness', no 'forced verbose' syntax with repeating names of things to type them etc.). Plus friendly new cool tools/skins for them:, etc. I agree it seems true, I did learn a lot while struggling to learn Haskell for a bit and hurting in the process, but.

which gives you the same features No they do not. Haskell's powerful typeclass system, advanced (kind) polymorphism, etc. Are not available in those languages. Ocaml doesn't even support proper monads. Laughably, it doesn't even support HKTs! Not sure how Scala and F# fare in that regard. usable records, A reasonable complaint about the core language, but essentially solved by lenses.

ability to be impure and imperative when you want Haskell has the ability to be pure and imperative when you want. You just can't lie about what you're doing. some kind of oop-style feature Which features? string madness I never understood this complaint. Three string types, plus lazy variants, is quite manageable. They are all very well-suited for a particular set of tasks, and I'm thankful the Haskell community doesn't shoehorn too much stuff into a single string type.

Haskell cleanly solves the encoding problem, which many languages kind of sweep under the rug. no 'forced verbose' syntax with repeating names of things to type them No idea what in the world you are talking about. FWIW, Haskell is by far the least verbose language I have ever used. Every token has semantic significance.