May 2016 - Haskell-Cafe

ANNOUNCE: accelerate-typelits
by Martin Heuschober 21 May '16

21 May '16

I want to announce my first haskell project big/clean enough so I consider it possibly useful to others - accelerate-typelits is a library that provides vectors/matrices in a typesafe way - i.e. The dimension of the entities are stored on type level as (Nats). There is basic vector/matrix functionality, documentation and tests for those functions (mostly properties). If I have time I will provide some basic examples and a bit more complicated example within the next week. It is available on hackage https://hackage.haskell.org/package/accelerate-typelits as well as on github https://github.com/epsilonhalbe/accelerate-typelits. I would be happy to get some feedback. - Martin

2 4

Modeling space for a MUD - revisited.
by Michael Litchard 21 May '16

21 May '16

This is a continuation of a conversation started in the following two links. https://groups.google.com/forum/#!searchin/haskell-cafe/michael$20litchard|… https://groups.google.com/forum/#!searchin/haskell-cafe/michael$20litchard|… I am trying to model a 3-D space for a mudlike. Here's the criteria I have so far: (1) Objects in space will be either ships that can move or stationary things like non-moving game-controlled ships, space-stations , moons and planets. (2) Objects will not have spatial extent (3) Space is non-continuous (4) Collision happens only when one object is stationary or each moving objects are moving directly toward each other, on the same line. (5) Movement happens by setting a destination vector and a speed. There's no steering exactly, but you can change destination while moving, slow down or stop suddenly. (6) Octree looks like the data structure I want to use for modeling. I'm looking at http://hackage.haskell.org/package/Octree as best library for my application, if I am right about how to go about updating. I'm not sure I am. I think I can use the octree to track things in space, rather than having a node for each point. At most there will be say, 200 objects in space, therefore at most 200 nodes in the tree. So I am visualizing the following steps: (1) Begin with a [(Vector3 <http://hackage.haskell.org/package/Octree-0.5.4.2/docs/Data-Octree.html#t:V…>, a)]. This includes stationary objects and ships already in space. (2) If a new ship entered this space, add it to end of list. (3) make Octree a from above list (4) ships move by setting destination vector and then speed, calculate next Vector3 they will be at next tick (5) Make a new [(Vector3 <http://hackage.haskell.org/package/Octree-0.5.4.2/docs/Data-Octree.html#t:V…>, a)] (6) Go to (1) The first problem with this is in creating a new Octree from a list, when I would rather just recreate the new tree with a subtree of the nodes that changed. The library I am considering does not offer that operation. Maybe this is not a real problem considering the maximum objects in space will be 200. There may be other problems with my thinking here. I look to haskell-cafe for any insight it may offer.

1 0

Re: [Haskell-cafe] ANNOUNCE: accelerate-typelits
by Johannes Waldmann 20 May '16

20 May '16

> .. a library that provides vectors/matrices in a typesafe way Nice! But what does it have to do with accelarate :-) I mean, we could also use this somewhere in Data.Array? Else, it's re-invented all over the place - and poorly, e.g., https://github.com/jwaldmann/ersatz/blob/master/tests/Z001.hs#L51 - J.W.

1 0

What's your favorite flavor of Iterator type
by Silvio Frischknecht 20 May '16

20 May '16

Hello, We know about Foldable, but sometimes you just want more functionality like: give me the rest of the string! Or a function to build pieces back together. I've been experimenting a bit and come up with 6 flavors of Iterators that do the same thing. Of course they all work for containers like ByteStrings, Text. 1) Haskell98 version (I like) data Iterator98 list ele = Iterator98 { next98 :: Maybe (ele, Iterator98 list ele), ... rest98 :: list, concat98 :: [list] -> list } -- How we can create an Iterator98 listIter98 :: [a] -> Iterator98 [a] a -- How the sum type looks sum98 :: (Num n) => Iterator98 listN n -> n Performance: *3 I'll also usually give the type of the constructor and sum functions. I also benchmarked the sum functions for [] and compared them to the best sum function I could come up with (which is significantly faster than the sum in Prelude!!! because it's strict. Whoever came up with the idea of making it non-strict, must have been drunk at the time :)). I like how handy and simple typed the Haskell98 version is. There are absolutely no superfluous Types or Contexts. However, *3 is quite a heavy penalty and it might even get worse when more functions are added. 2) Haskell98 Explicit (ambivalent) data IteratorExplicit98 iter list ele = IteratorExplicit98 { iterExplicit98 :: iter, nextExplicit98 :: iter -> Maybe (ele, iter) ... restExplicit98 :: iter -> list } listIterExplicit98 :: [a] -> IteratorExplicit98 [a] [a] a sumExplicit98 :: (Num n) => IteratorExplicit98 it list n -> n Performance: *1 It is explicit and it is still quite nice to use. There is however always that extra argument. Note: `iter` and `list` could potentially be different (in all examples). They are in Haskell however usually the same. Performance could be different, if you create and destroy a lot of data of type IteratorExplicit98. However, that won't usually be the case. 3) TypeFamilies (I don't like) class IteratorTF i where type ListTF i type ElemTF i nextTF :: i -> Maybe (ElemTF i, i) ... restTF :: i -> ListTF i instance IteratorTF2Class [ele] ele where ... sumTF :: (Num n, IteratorTF it, ElemTF it ~ n) => it -> n Performance: *1 I used to like type families. But now I'm a bit fed up with ~ contexts. This would be the "Rust" version. Interesting point: List and Elem functions could be separated into two classes. I.e. Note that no list type exists in the type of "sum". 4) TypeFamilies2 (ambivalent) class IteratorTF2Class list ele where data IteratorTF2 list ele nextTF2 :: IteratorTF2 list ele -> Maybe (ele, IteratorTF2 list ele) ... restTF2 :: IteratorTF2 list ele -> list instance IteratorTF2Class [ele] ele where data IteratorTF2 [ele] ele = ListIterTF2 [ele] sumTF2 :: (Num n, IteratorTF2Class list n) => IteratorTF2 list n -> n Performance: *1 Better than the last. However, IteratorTF2Class, IteratorTF2 are two Type-ish things where one would be preferred. This is my preferred method where all functions are carried in the type. 5) MultiParameterTypeClasses and Functional Dependencies (ambivalent) class IteratorMPTC iter list ele | iter -> list, iter -> ele where nextMPTC :: iter -> Maybe (ele, iter) ... restMPTC :: iter -> list instance IteratorMPTC [a] [a] a where sumMPTC :: (Num n, IteratorMPTC it list n) => it -> n Performance: *1 About the same as 3). The user will still be exposed to various individual types ":: it". That is not as bad as it is in "Rust", since (as already stated) in Haskell usually "list == it". This is similar to the parsec approach. class (Monad m) => Stream iter m ele | iter -> ele Parsec has no "rest" function so the "list" type is not needed. But they have an additional monad type. 6) Existential Quantification (my favorite) data IteratorEQ list ele = forall iter . IteratorEQ { iterEQ :: iter, nextEQ :: iter -> Maybe (ele, iter) ... restEQ :: iter -> list } listIterEQ :: [a] -> IteratorEQ [a] a sumEQ :: (Num n) => IteratorEQ list n -> n Performance: *1 Looks as nice as Haskell98 and is as fast as Haskell98Explicit. Btw. This is probably how It would be done in "C" with iter = void*. Additional thoughts: * Do we really need the "list" type. Couldn't we simply return iterators instead of the original "list" type. In 3) and 5), they will *usually* be the same anyway. * In 3) and 5) the typeclasses could be split to separate ele and list. * On the other hand combining Iterators will be very annoying for 3) and 5) data ZipIterator ... instance IteratorMPTC (ZipIterator (?) (elem, elem')) ? (elem, elem') where zip :: (IteratorMPTC iter list elem, IteratorMPTC iter' list' elem') -> ZipIterator ? (elem, elem') Which is your favorite? Why? Did I forget any good ones? Cheers Silvio

2 1

ANNOUNCE: Sifflet 2.3.0 - recursion learning aid / visual programming language
by gdweber＠iue.edu 20 May '16

20 May '16

Sifflet 2.3.0 is now available on Hackage. This release brings Sifflet up to date, so it compiles with GHC 7.10.3, newer versions of depended-on libraries, and builds in a cabal sandbox. Sifflet is the visual, functional programming language and support system for students learning about recursion. Sifflet programmers define functions by drawing diagrams, and the Sifflet interpreter uses the diagrams to show how function calls are evaluated. The Sifflet library (formerly sifflet-lib package) is reintegrated into, and deprecated in favor of, the sifflet package. A test suite is added. Personal Note ------------- It's been about 18 months since I've been able to work on this project or do any serious Haskell development. A lot has changed in the Haskell world -- a lot of catching up to do! It feels good getting back to Haskell again. About Sifflet ------------- Sifflet is a visual, functional programming language intended as an aid for learning about recursion. * A picture explains Sifflet better than words: please see the screenshot showing how to evaluate 3!: http://pages.iu.edu/~gdweber/software/sifflet/home.html * Features: - Visual editor. - Visual tracer/debugger which shows how recursive and other function calls are evaluated. To support active learning and avoid screen clutter, Sifflet displays only as much of the computation as the user requests. - Carefully crafted tutorial with 44 pictures, about 26 pages if printed. - Number, string, and list data types. - Small collection of primitive functions. - Runnable examples of compound functions. - Sifflet functions can be exported to Scheme, Python 3, and Haskell. References ---------- * Download: http://hackage.haskell.org/package/sifflet * Home page: http://pages.iu.edu/~gdweber/software/sifflet/home.html * Sifflet Tutorial: http://pages.iu.edu/~gdweber/software/sifflet/doc/tutorial.html * Change log: http://pages.iu.edu/~gdweber/software/sifflet/ChangeLog.html -- Gregory D. Weber, Ph. D. http://pages.iu.edu/~gdweber/ Associate Professor of Informatics Tel (765) 973-8420 Indiana University East FAX (765) 973-8550

1 0

How about a special syntax for generalised (= MonadPlus) comprehension?
by Alexey Muranov 19 May '16

19 May '16

If i understand correctly, the main reason that generalised comprehension was removed from Haskell 98 must have been that its syntax "collides" with the syntax for lists. Indeed, if ``` [x^2 | x <- msum (map return [0..10]), x `mod` 2 == 1] ``` is made ad-hoc polymorphic, then so probably should `[]` and `[1,2,3]`. Moreover, for consistency, the meaning of `[]` as the list type constructor (like in `[]Int` or `[Int]`), should probably be changed to denote an arbitrary instance of `MonadPlus` :). My question is: why not to have a special syntax for `MonadPlus` comprehension? For example: ``` {| x + y | x <- Just 1, y <- Just 2 |} ``` or ``` [* x + y | x <- Just 1, y <- Just 2 *] ``` Then matching analogs of `[]` and `[1,2,3]` could be made: ``` {||} :: Maybe Int -- Nothing {| Just 1, Just 2, Just 3 |} :: Maybe Int -- Just 1 ``` Alexey.

2 3

ANNOUNCE: Haskell Communities and Activities Report (30th ed., May 2016)
by Mihai Maruseac 19 May '16

19 May '16

On behalf of all the contributors, we are pleased to announce that the Haskell Communities and Activities Report (30th edition, May 2016) is now available, in PDF and HTML formats: http://haskell.org/communities/05-2016/report.pdf http://haskell.org/communities/05-2016/html/report.html All previous editions of HCAR can be accessed on the wiki at https://wiki.haskell.org/Haskell_Communities_and_Activities_Report Many thanks go to all the people that contributed to this report, both directly, by sending in descriptions, and indirectly, by doing all the interesting things that are reported. We hope you will find it as interesting a read as we did. If you have not encountered the Haskell Communities and Activities Reports before, you may like to know that the first of these reports was published in November 2001. Their goal is to improve the communication between the increasingly diverse groups, projects, and individuals working on, with, or inspired by Haskell. The idea behind these reports is simple: Every six months, a call goes out to all of you enjoying Haskell to contribute brief summaries of your own area of work. Many of you respond (eagerly, unprompted, and sometimes in time for the actual deadline) to the call. The editors collect all the contributions into a single report and feed that back to the community. When we try for the next update, six months from now, you might want to report on your own work, project, research area or group as well. So, please put the following into your diaries now: ======================================== End of September 2016: target deadline for contributions to the November 2016 edition of the HCAR Report ======================================== Unfortunately, many Haskellers working on interesting projects are so busy with their work that they seem to have lost the time to follow the Haskell related mailing lists and newsgroups, and have trouble even finding time to report on their work. If you are a member, user or friend of a project so burdened, please find someone willing to make time to report and ask them to "register" with the editors for a simple e-mail reminder in November (you could point us to them as well, and we can then politely ask if they want to contribute, but it might work better if you do the initial asking). Of course, they will still have to find the ten to fifteen minutes to draw up their report, but maybe we can increase our coverage of all that is going on in the community. Feel free to circulate this announcement further in order to reach people who might otherwise not see it. Enjoy! -- Mihai Maruseac (MM) "If you can't solve a problem, then there's an easier problem you can solve: find it." -- George Polya

2 1

Is there a way to query the availability of an extension? Or could we?
by David Feuer 18 May '16

18 May '16

We have __GLASGOW_HASKELL__ to tell us what GHC version we're running (if we're running GHC), and Cabal sets up MIN_VERSION_blah macros and (when applicable) the __HADDOCK_VERSION__ macro. But what if we're running some other compiler? It seems rather painful to have to write code that enables or disables various extensions based on what version N of compiler C happens to support. Not to mention that this is even a pain when just dealing with GHC, since it involves digging through release notes or waiting to see how Travis throws up. Is there some better way? If not, could we add one? __Have_ScopedTypeVariables__ could tell us if the ScopedTypeVariables extension is available. Then instead of saying "We need ScopedTypeVariables" when we can (painfully) do without, we can just use it precisely when we have it.

3 3

All combinations in order.
by Christian Brolin 17 May '16

17 May '16

Hmm, I tried to post this via google groups but it was rejected. So I try to mail the list instead. Sorry for any duplicates. Hi list! How to transform a list of streams of elements into a stream of lists of elements such that all combinations of exactly one element of each input stream is present? I.e. something like this: | |type Streama =[a] |tr ::[Streame]->Stream[e] tr = sequence | But I want the order of the output lists so the ones with early elements come first. The above starts with the first elements from each stream but does not treat the streams fairly. All the elements of the last stream are used before the next element of the second last stream is used, i.e. | > tr [[1..3], [1..2], [1..3]] [[1,1,1],[1,1,2],[1,1,3],[1,2,1]..... | I don't want the third element of one stream before I have seen all the combinations of the first two elements of each stream and so on. In this case I want something like this: | [[1,1,1], [1,1,2], [1,2,1], [2,1,1], [1,2,2], [2,1,2], [2,2,1], [2,2,2], [1,1,3].... | Also [2,1,1] comes before [1,2,2] because the former contains two first element and one second element while the latter contains only one first element and two second elements. The number of streams are fairly low but the sequences can be very long (almost infinte :) and I want the first results without having to go though a full stream. Also the streams may vary in length so one stream may ran out of elements before the others. If that happens, the non-empty streams should contrbute fairly with new elements, i.e: | > sequence_ $ map print $ tr [[1..2], [3..5]] -- two times three equals to six combinations [1,3] -- 1: first and first [1,4] -- 2: first and second [2,3] -- 3: second and first [2,4] -- 4: second and second [1,5] -- 5: first and third [2,5] -- 6: second and third | Note, I'm not just interested to handle infinite streams (nor infinite number of streams) using some diagonal algorithm. I have looked at the Omega library. But it doesn't return the combinations in wanted order. If someone still wonder about the output ordering, the following program may help: | importData.List(sort,sortBy) type Streama =[a] tr ::Orde =>[Streame]->Stream[e] tr =sortBy myOrder .sequence wheremyOrder ::Orde =>[e]->[e]->Ordering myOrder xs ys =compare (reverse $ sort xs)(reverse $ sort ys) main =sequence_ $ map print$ tr [[1..3],[1..2],[1..3],[1..4]] | But this of course is not a valid solution since it inspects every combinations before producing any output. Attached the sample output.

2 1

representing institutions in haskell
by rick 17 May '16

17 May '16

Has anyone here taken an interest in representing institutions [1] in Haskell? Institutions originated in work on CLEAR [2] which was the first algebraic specification language with rigorous semantics. Institutions take some time to explain, or unravel if you follow the reference, but they come with a convenient slogan : "Truth is invariant under change of notation." The stretch goal of institutions is transforming logics while preserving satisfaction. They are conceived in terms of categorical abstractions, so it's natural to represent them in categories. I hope some folks here find institutions a useful domain to apply their work on categories. I've attached two samples in Haskell that uses some standard libraries : Arrow, Monad, Category and Dual. The first sample, ri-0, outlines the essentials. The category of signatures, constructions in the categories, signature morphisms, sentences, models and the satisfaction condition. Using plain old Nat reduces the complexity of the exposition. I provide a constructive witness for satisfaction of the morphism from conjunction to disjunction. You may recognize that I borrow some Bird/Hinze notation on Functors like mapSign. And you find some experiments with Quickcheck and Yampa. Ri-0 runs from main, but just computes the witness to the satisfaction condition. The second sample, ri-1, builds on ri-0. Rather than Nat, I use Either to inject disjunction into the exposition. The exposition becomes more complex, but the increased complexity is justified because maintaining satisfaction under change on notation is central to institutions. The functions prodSum takes conjunction to disjunction and sumProd takes disjunction to conjunction. I owe a citation to @BartoszMilewski and his work on categories for programmers where I first saw these functions. The satisfaction condition and witness appear more complex in ri-1, but its really just the substitution of the signature morphism on product and sum rather than plain old Nat as in ri-0. I also plan a better write up, but before I do I expect to learn much from an email exchange with interested folks here. Thanks for taking a look at this material. 1. https://cseweb.ucsd.edu/~goguen/pps/ins.ps 2. http://hopl.info/showlanguage.prx?exp=945 -- Rick

1 0