Writing

Changelog: Classes are writ­ten to the format file; There should be less "am­bigu­ous op­er­ator" er­rors now; Re­moved the Agda de­pend­ency as it didn't do any­thing with Agda at all. Hack­age, GitHub.

After the first re­lease of my tool on hack­age this re­lease ac­tu­ally is a work­ing pack­age. The pre­vi­ous one didn’t in­stall out of the box. The most im­port­ant changes are: Ad­ded a fil­ter for re­write rules that aren’t “lhs2TeX safe”, e.g. format () = ...; I hard­coded the de­fault format­ting rules for sev­eral of lhs2TeX de­faults, in­clud­ing but not lim­ited to ->, <- and =>. This is not a de­sir­able solu­tion but it suits my pur­poses. You can do lit­eral (nu­meral, char­ac­ter and string) format­ting eas­ily with lhs2TeX it­self with the fol­low­ing dir­ect­ives:

I’m proud to an­nounce the first re­lease of my lhs2TeX-hl tool. For us who fancy us­ing col­ours in our present­a­tions or pa­pers this should now go a whole lot easier. Go to the lhs2TeX-hl homepage!

After some time of strug­gling with MacFuse (+MacFusion) and SSHFS I set out to get some­thing that works nice, is in­teg­rated in OS X nicely and above all, is not sslooow. AFP which is all of this is avail­able for Debian but without sup­port of the new en­cryp­ted pass­word mech­an­ism.

Here are some up­dates on my pre­vi­ous art­icle. Doc­trine meets Code­igniter. Do not for­get to add the fol­low­ing auto­load dir­ect­ive to your hooks/doctrine.php and the doctrine.php cli: spl_autoload_register(ar­ray('Doctrine', 'modelsAutoload'));

Cur­rently there is no pack­age for the Haskell-Platform in Debian stable. How­ever, the source of this plat­form and GHC is avail­able for down­load at ghc and plat­form. How­ever, there are some is­sues to solve when in­stalling the plat­form from source. Mainly you’ll be miss­ing sev­eral pack­ages. The fol­low­ing com­mands worked at my own Debian ma­chine. If you find out that’s some­thing is miss­ing that was ap­par­ently already in­stalled on my ma­chine, don’t hes­it­ate to leave a com­ment.

Non-mutually re­curs­ive and Mu­tu­ally re­curs­ive data­types Wel­come back. In this post we will look at cre­at­ing type algebra's and folds for more com­plic­ated data types. In es­sence, this ex­er­cise will not be any more dif­fi­cult than the pre­vi­ous ones, provided that you stick with the steps. Up in this part, are the non-mutually re­curs­ive data­types and mu­tu­ally re­curs­ive data­types. First up, data struc­tures that are re­curs­ive into other data struc­tures. The folds for these data struc­tures are no more com­plex than their `simpler’ forms. In fact, you could treat them the same, but for clar­ity we will treat them as dis­tinct. If you want to know more about the pre­vi­ous part, it might help your search if you look for the keyword cata­morph­ism.

Nor­mally this er­ror would mean that you have some weird syn­tax er­ror some­where in your yml files. How­ever, if you are sure everything is up to spec be sure to check whether there are any `hidden’ files in the folder. Such files start with a dot and are also read and parsed by the com­mand line gen­er­ator.

Wel­come to this little ex­plan­a­tion on how to de­term­ine the fold of a Haskell data­type. First we’ll look at how we define func­tions over lists, some­thing every­one start­ing with Haskell should be suf­fi­ciently fa­mil­iar with, after which we move on to the data­types. You’ll see dif­fer­ent ways how to cal­cu­late the sum of a list, how to fold over a list, what data­types are and, how to fold over a data­type, spe­cific­ally the BinTree a data­type. Most im­port­antly, I hope you will grow to un­der­stand what a fold is, and why they are so im­port­ant and use­ful when pro­gram­ming Haskell.

In ad­di­tion to my pre­vi­ous post where I dis­cussed the ini­tial setup of your ap­plic­a­tion with CI (CodeIgniter), I’ll use this post to provide a method of set­ting up your en­vir­on­ment for mul­tiple ap­plic­a­tions.