hask | Haskell language features and standard libraries | Functional Programming library

From what you have described it looks like you also want to break your string when a line ends. To do this add a carriage return as one of delimiting cases in the following manner-

You can not print a value of type Eval Int since that is defined as ReaderT Env Maybe Int. Printing a value in that type would essentially amount to printing a function Env -> Maybe Int, and functions can't be printed.

Consider calling the function using

First, yes.

For example, we all know that a monoid can be defined to be a single-object category with

• arrows to be elements
• the single object has no meaning
• composition to be operator ((<>) in Haskell)
• id arrow to be the identity (mempty in Haskell).

And a homomorphism between two monoids becomes a functor between two categories in this sense.

Now, say, type A and B are both monoids; A functor between them is just a homomorphic function f :: A -> B that maps each A to B, preserving the composition.

But, wait, f :: A -> B is not even a Functor (note that I use the monospaced typeface here)!

No, it is not a Functor in Haskell, but it still is a functor in mathematical sense.

So, to emphasize, I state it again: "Non-endo" functors ARE used in programming, and probably even more often than endofunctors.

The point here is that category theory is a highly abstract theory - It provides notions for abstracting concrete objects. We can define these notions to mean different things in different contexts.

And Hask (or Set, or subcategories of Set) is just one of these infinite definitions, which makes

• arrows to be functions
• objects to be types (or, sets)
• composition to be function composition (.)
• id arrow to be the id function.

Compare this "categorical universe" definition with the "categorical monoid" definition above - congrats, you've known two different takes on categories now!

To conclude, remember that category theory itself is just some abstractions. Abstractions themselves have no meaning and no use at all. We connect them to real things, and only in this way they can bring us convenience. Understand abstract concepts through concrete examples, but NEVER simplify these concepts themselves to anything concrete (Like, never simplify functors to merely the functors between "categorical universes" (e.g. Hask, Set, etc)!).

P.S. If you ask "Is there a functor that sends Hask to another category in Haskell?" then the answer can be yes or no. For example, you can define a category Hask * Hask to contain any two types' cartesian product, and a functor data Diag a = Diag a a, fmap f x = Diag (f x) (f x) that sends each type A to its square A * A. However, Hask * Hask is still a subcategory of Hask, so we may say this is an endofunctor too.

You can use the field and <> combinators to extend a Context (homeCtx in this case) with the contents of the lists under some tags. Here, I've renamed the tags body and body2 to posts and bibs because body is a tag with a special meaning in Hakyll. Remember to also rename the tags in templates/index.html.

I would like to know why we decided to concentrate on curry and uncurry as Curry’s methods. Is it because pretty much everyone who knows Haskell also knows these functions?

As the library author I can answer that with confidence and the answer is yes: it is because curry and uncurry are well-established part of the Haskell vernacular. constrained-categories was never intended to radically change Haskell and/or make it more mathematically solid in some sense, but rather to subtly generalise the existing class hierarchies – mostly to allow defining functors etc. that couldn't be given Prelude.Functor instances.

Whether Curry could be formalised in terms of local smallness I frankly don't know. I'm also not sure whether that and other “maths foundations” aspects can even be meaningfully discussed in the context of a Haskell library. ^{_{Somewhat off-topic rant ahead}} It's just a fact that Haskell is a non-total language, and yes, that means just about any axiom can be thwarted by some undefined attack. But I also don't really see that as a problem. Many people seem to think of Haskell as a sort of uncanny valley: too restrictive for use in real-world applications, yet nothing can be proved properly. I see it exactly the other way around: Haskell has a sufficiently powerful type system to be able to express the mathematical ideas that are useful for real-world applications, without getting its value semantics caught up too deep in the underlying foundations to be practical to actually use in the real world. (I.e., you don't constantly spend weeks proving some “obviously it's true that...” theorem. I'm looking at you, Coq...)
Instead of writing 100% rigorous proofs, we narrow down the types as best as possible and then use QuickCheck to see whether something typically works as the maths would demand.

Don't get me wrong, I think formalising the foundations is important too and dependently-typed total languages are great, but all that is somewhat missing the point of where Haskell's potential really lies. At least it's not where I aim my Haskell development, including constrained-categories. If somebody who's deeper into the pure maths wants to chime in, I'm delighted to hear about it.

(x,y) is already a concrete tuple type, containing two concrete (albeit unknown) types x and y. A functor, or bifunctor, meanwhile is supposed to be parametric, i.e. in case of the tuple instance you'd want the contained types to be left open as parameters, which are then filled in with various different concrete types when the methods are used.

I.e., you basically want a type-level lambda

You can write this with a lambda expression as:

So my issue was not knowing how to evaluate RBinary because it requires three arguments but we are only given one, cond. I played around in GHCI and figured out that I could just treat cond as a three argument expression if I pass it to eval instead of evalCond. This evaluates correctly and as an added benefit, I can remove evalCond though I will keep it if it becomes necessary later on. The code to fix it was:

I'm not sure using foldl1 would help you much here. In the "Write Yourself a Scheme" wikibook, the foldl1 function is used for the very specific purpose of applying "binary" functions like + and - to lists of arguments that might be of length > 2. In Lisp, (+ 1 2 3) means the same thing as the Haskell expression: