# News aggregator

### Would anyone be interested in information about the (u)LC?

I'm not sure if posts about the *untyped* lambda calculus are welcome here (and, given the adoration for types, I always feel like I'm offending someone when I talk about it). Some have told me it is still relevant to Haskell since it shows up reasonably often (DSLs, type-level programming, etc) and I agree, but I don't want to be disruptive. I've been programming a lot in the ULC lately and have been discovering some pretty interesting things that I couldn't find elsewhere and wouldn't mind sharing, but given the almost non-existent interest, I wonder if it is even worth the effort to create a blog and so on. Thoughts?

[link] [5 comments]

### Created a Yesod sight, suggestions welcome, please.

This is a website I created using Haskell and Yesod. I am a relative newbie to this language, and I am looking for some constructive criticism for my site. The source code is available here:

Also, please note that I have a DNS entry through dyndns.org, and as such, I cannot get a well-signed certificate. So I signed my own certificate. If you do not trust that, I totally understand. I am also kind of new to hosting web servers and all that.

submitted by Coojerman[link] [1 comment]

### Somehow encapsulating identical first argument to several functions?

I have this situation that I wonder if there is a way to make smarter / neater.

I have these functions:

data Something a = ... etc.

funcA:: Something a -> b -> c

funcA = ...etc.

funcB:: Something a -> b -> c ->d

funcB firstArg x y = funcA firstArg ... etc.

funcC:: Something a ->b ->c->d

funcC firstArg x y = funcB firstArg ... etc. . . .

funcZ:: Something a -> b->c->d->e

funcZ firstArg x y z = funcY firstArg ... etc.

Is there a neat way to do this so I don't need to include the "Something a" in the type signature ? In the end I'm just passing it down from funcZ to funcA...

submitted by asswaxer[link] [5 comments]

### Using lenses to write a compiler front-end?

Hey all,

I've been slowly learning about lenses and the various associated constructs. In parallel, I'm studying compiler front-ends - lexing, parsing, type-checking.

One interesting aspect of the design of a compiler front-end is that it needs to "bubble up" information back to the programmer. If there is a type error, I can't just throw an internal error; I need to go "backwards" through the parser and lexer to get the line number, column number and length of the expression that caused the error, all so I can contextualize the type error to it.

I'm wondering which abstraction best captures this. I feel like a well-engineered front-end in this manner could make static analysis, source highlighting, etc. vastly easier.

submitted by PM_ME_UR_OBSIDIAN[link] [10 comments]

### Sound of Text - A web application written by a Haskell novice

Starting with the most important bits:

Link to site: http://soundoftext.com

Link to Github: https://github.com/ncpierson/soundoftext

I read up on different Haskell web frameworks and I chose **Snap**. I didn't try the others, but I don't regret my decision. If you are a beginner, I would highly recommend the Snap Framework. It wasn't *too* magical.

The site already has a few hundred active visitors. I initially built this site over a year ago in PHP. However, I rewrote it in Haskell and I wanted to let *somebody* know who might find that interesting.

If you have any questions, please let me know. If you want to review my code, that would be great.

It's currently running on the smallest DigitalOcean node available. I had a few hiccups with installing Cabal, but I can explain that, as well.

I hope you enjoy my site!

submitted by RedditWithBorders[link] [17 comments]

### Thoughts on -XLambdaDo syntax

At ZuriHac I've been starting with a toy parser and the following recurring pattern made me think of \do as a syntactic sugar for pattern matching under the do:

\str -> do ('*' : rest) <- return str ...Analogously to \case one could abbreviate this as

\do ('*' : rest)Clearly this uses the pattern-match fail mechanism transparently, which is arguably a plus... I wonder if others have seen similar use-cases too?

submitted by heisenbug[link] [41 comments]

### Thoughts on a proposed package management strategy?

The server would come up with "sync-states". A sync-state is a set of packages that are known to work together.

Sync-states would be determined like this; when a new version of a package is uploaded all packages that require that package are recompiled and their test-suites run. Then if the compile/testing is successful a new sync-state is produced.

When uploading a package the developer would first sync to the latest sync-state and ensure it works with that before publishing. Similarly when someone goes to install a package a sync is performed first and then the package is installed.

I think this would vastly simplify things as every package would be using the same versions of dependencies and they would be known to compile and test successfully. Also every developer and user would be using similar versions of the software.

Syncing to the latest state would not be that bad. I just deleted and reinstalled all the packages I require. There were about 150 of them and it took less than a half-hour to reinstall them and my machine is not great.

submitted by zandekar[link] [35 comments]

### Closed Type Families: separate instance groups?

### Why can QuasiQuoters only be used to generate top-level declarations?

There's probably a good reason, but it bugs me that this is valid:

[qq| thing :: Custom -> DSL |] thing = ......while this is not:

other = thing where [qq| thing :: Custom -> DSL |] thing = ......but this is:

other = thing where thing :: [qq| Custom -> DSL |] thing = ...(Originally posted to /r/haskellquestions, but this didn't get any responses there so I thought I'd try the bigger subreddit.)

submitted by spindakin[link] [10 comments]

### What is the difference between an Algebraic Data Type and an Abstract Data Type?

I am struggling to understand the difference between those two concepts. To me they look pretty much the same, AlgDT allow type composition but so do AbsDT right?

For example I can compose ints and chars in an abstract data type:

struct coordinates { int x; int y; char data_point_name[5]; };One powerful feature of AlgDT that really impressed was that I was able to define the set of natural numbers recursively:

data Nat = Z | S Natwhere Z is 0 and S the successor function. That is something that I could not do using 'struct' but does it make the different between AlgDTs and AbsDTs a fundamental one?

I know that I am confusing something and that there is a flaw in my understanding but I don't know what! Thank you for reading.

submitted by fictiveaaron[link] [42 comments]

### Proposal: Shorter Import Syntax

### haskellers' view of closures? How is this stuff an improvement on OOP?

Touring around other languages like javascript, some of these functional-ish languages seem to make a big deal of closures as part of the functional paradigm.

To me it looks like OOP by another name - passing state and associated method around as a bundle. In fact, I think in the C++ world, STL took pains to characterize lambdas+captures as "stamping out classes" and not "anonymous functions".

The only thing that's slightly better than vanilla OOP is that it seems to default to a many-1 data to function coupling, whereas with OOP you have many-to-many data to function coupling. All in all closures feel a bit like OOP-in-sheep's clothing.

How do haskellers view closures? Maybe there's a win that I'm selling short here?

submitted by klaxion[link] [36 comments]

### Magnus Therning: Oh no! Success

This can’t possibly be good for Haskell…

We chose Haskell and the FP Complete stack because we knew the complexity of the problem required a new approach. The result was that we built better software faster than ever, and delivered it defect-free into a production environment where it has proven robust and high-performance

### Haskell success story mentioned in press release from OTAS Technology, a market analysis company.

### Brent Yorgey: Crystal Ball Connection Patterns via Species and Generating Functions

A couple weeks ago, Denise posted Puzzle: Crystal Ball Connection Patterns on her blog, Let’s Play Math. I had fun playing with it and thought I would demonstrate how to apply some high-powered combinatorial techniques to it (probably not what Denise had in mind!).

The setup is that there are (distinct) friends who can talk to each other on the phone. Only two people can talk at a time (no conference calls). The question is to determine how many different “configurations” there are. Not everyone has to talk, so a configuration consists of some subset of the friends arranged in (unordered) conversational pairs.

*Warning: spoilers ahead*! If you’d like to play around with this yourself (and it is indeed a nice, accessible combinatorics problem to play with), stop reading now. My goal in this post is to have fun applying some advanced tools to this (relatively) simple problem.

Let’s start by visualizing some configurations. In her post, Denise illustrated the complete set of configurations for , which I will visualize like this:

Notice how I’ve arranged them: in the first row is the unique configuration where no one is talking (yes, that counts). In the second row are the six possible configurations with just a single conversation. The last row has the three possible configurations with two conversations.

One good approach at this point would be to derive some recurrences. This problem does indeed admit a nice recurrence, but I will let you ponder it. Instead, let’s see if we can just “brute-force” our way to a general formula, using our combinatorial wits. Later I will demonstrate a much more principled, mechanical way to *derive* a general formula.

Let’s start by coming up with a formula for , the number of configurations with people and conversations. The number of ways of choosing pairs out of a total of is the multinomial coefficient . However, that overcounts things: it actually distinguishes the first pair, second pair, and so on, but we don’t want to have any ordering on the pairs. So we have to divide by , the number of distinct orderings of the pairs. Thus,

Let’s do a few sanity checks. First, when , we have . We can also try some other small numbers we’ve already enumerated by hand: for example, , and . So this seems to work.

For people, there can be at most conversations. So, the total number of configurations is going to be

.

We can use this to compute for the first few values of :

At this point we could look up the sequence 1,1,2,4,10,26,76 on the OEIS and find out all sorts of fun things: *e.g.* that we are also counting self-inverse permutations, *i.e.* involutions, that these numbers are also called “restricted Stirling numbers of the second kind”, some recurrence relations, *etc.*, as well as enough references to keep us busy reading for a whole year.

We can describe configurations as elements of the combinatorial species . That is, a configuration is an unordered set () of () things (), where each thing can either be an unordered pair () of people talking on the phone, or () a single person () who is not talking.

We can now use the Haskell species library to automatically generate some counts and see whether they agree with our manual enumerations. First, some boilerplate setup:

ghci> :set -XNoImplicitPrelude ghci> :m +NumericPrelude ghci> :m +Math.Combinatorics.SpeciesNow we define the species of configurations:

ghci> let configurations = set `o` (set `ofSizeExactly` 2 + singleton)We can ask the library to count the number of configurations for different :

ghci> take 10 (labelled configurations) [1,1,2,4,10,26,76,232,764,2620]Oh good, those numbers look familiar! Now, I wonder how many configurations there are for ?

ghci> labelled configurations !! 100 24053347438333478953622433243028232812964119825419485684849162710512551427284402176Yikes!

We can also use the library to generate exhaustive lists of configurations, and draw them using diagrams. For example, here are all configurations for . (If you want to see the code used to generate this diagram, you can find it here.)

And just for fun, let’s draw all configurations for :

Whee!

A general formula, via generating functionsFinally, I want to show how to use the species definition given above and the theory of generating functions to (somewhat) mechanically *derive* a general formula for the number of configurations. (Hopefully it will end up being equivalent to the formula we came up with near the beginning of the post!) Of course, this is also what the species library is doing, but only numerically—we will do things *symbolically*.

First, note that we are counting labelled configurations (the friends are all distinct), so we want to consider exponential generating functions (egfs). Recall that the egf for a species is given by

,

that is, a (possibly infinite) formal power series where the coefficient of is the number of distinct labelled -structures of size . In our case, we need

,

since there is exactly one set structure of any size, and

,

which is just the restriction of to only the term. Of course, we also have . Putting this together, we calculate

Ultimately, we want something of the form , so we’ll need to collect up like powers of . To do that, we can do a bit of reindexing. Right now, the double sum is adding up a bunch of terms that can be thought of as making a triangle:

Each ordered pair in the triangle corresponds to a single term being added. Each column corresponds to a particular value of , with increasing to the right. Within each column, goes from up to .

The powers of in our double sum are given by . If we draw in lines showing terms that have the same power of , it looks like this:

So let’s choose a new variable , defined by . We can see that we will have terms for every . We will also keep the variable for our other index, and substitute to get rid of . In other words, instead of adding up the triangle by columns, we are going to add it up by diagonals.

Previously we had ; substituting for that now turns into . Adding to both sides and dividing by yields (we can round down since is an integer). Looking at the diagram above, this makes sense: the height of each diagonal line is indeed half its index. Rewriting our indices of summation and substituting for , we now have:

And hey, look at that! The coefficient of is exactly what we previously came up with for . Math works!

### Haskell source-browsing nirvana?

I'm using an awkward mix of hasktags, dash and hoogle. I wonder if anyone has achieved my dream in any editor: It would work like hasktags except it could use context like imports and qualifications to find the correct definition, jumping across the project source into sources for installed packages including ghc base.

submitted by rdfox[link] [6 comments]