Testing for congruence in Haskell

Hello /prog/ Haskell programers users. Is it possible to test for the congruence of expression in Haskell? I know i can say
this a = if (a 12) == 12 then (a 12) else (a 13)
and expect this (\ x -> x + 1) to eval to 14. But is there anyway to test for the equivalence of two (or more) expressons without actually applying either of them? In other words, can haskell do anything with thunks, aide from than apply them?

(\ x -> x) == (\ x -> x) is not an expression. Is there a corrext syntax for this type of thing?
Thanks,

Use Nomads.

You might be able to do that with Template Haskell.

I don't think so, you're not even supposed to know about existence of thunks.

There is no way to know in general if two programs compute the same function.  This is because not all programs actually halt and give an answer and there is no way to know before hand if a program is in that class.  Since there is no way (in general) to know what a program will output without actually running it there is no way to tell if two programs are equivalent.

Not only that, but programs could have infinite domains meaning in order to know they are equivalent you'd have to compare an infinite amount of outputs.

The only way this could possibly work is if you limited your notion of "expressions" to something less than Turing complete and if you only wanted to assert equivalence over a limited domain.

TL;DR no, but maybe if you limited what you actually want.

>>5
Since there is no way (in general) to know what a program will output without actually running it there is no way to tell if two programs are equivalent.
Sure, maybe we can't know for sure, but we can make a pretty good guess. If we see a "for" loops that runs 100,000 times, there's a good chance that the program is in an infinite loop.

The combined powers of SICP can't solve the halting problem?  What a waste of time!

You might be a worthless nigger for using haskell.

>>8
amIANigger :: Maybe Nigger -> Nothing

>>6
Listen, I've heard this before, but for every program you write to determine that a program will halt without actually running it, I can trivially write a program that will crash your program.

>>10
Steve Jobs!?

>>11
More like Steve Tasks

1. Why can I not do (Just 1) >>= succ? How do I get the value out of the Maybe monad?

2. getDirectoryContents "/" >>= return . filter (`notElem` [".", ".."]) What is the point of the >>= return?

Thank you Haskell wizards ^0^

>>13
Enjoy your static typing. Also fromJust.

>>13
Regular datatypes are not fuqin nomads.

>>15
How do I get value out of Just?
How do I get String from keyboard out of IO String?

>>13
What you probably want there is fmap succ (Just 1), though Just 1 >>= return . succ would also work. The function argument to >>= must return a value in the monad, but fmap's does not. Thus, to run a pure function on the value(s) in the monad, we can compose it with return :: b -> m b. Compare:
(>>=) :: Monad m => m a -> (a -> m b) -> m b
fmap :: Functor f => (a -> b) -> f a -> f b

In a monad, it is also possible to use liftM. liftM is different because it requires a monad, not a functor, even though it does the same thing, and also there are versions for other argument counts: liftM2, liftM3, etc. We could also use liftM2 (+) (Just 1) (Just 1).

For the second question we could also use filter (`notElem` [".", ".."]) `fmap` getDirectoryContents "/".

To get the value out of the Maybe monad, use fromJust or maybe.

>>17
Thanks. So why does >>= have to return a value inside of a monad? Just so you can chain them?

>>18
In the case of IO and other monads, it allows chaining, yes. (You couldn't do getDirectoryContents "/" >>= mapM_ putStrLn with fmap/liftM because the lifted function is pure.)

In the case of Maybe, it's still more useful than fmap because you can not only change the values inside the box (like fmap does), but also the type of the box: Just 1 >>= const Nothing. You can transform a Right 1 to a Left "Error!", and so on.

>>18
In the case of the Maybe monad, because >>= may return Nothing and STATIC TYPING JUST KICKED IN YO.

In general, because that's how the type of >>= is constrained ( (>>=) :: m a -> (a -> m b) -> m b ).

Fuck all you idiots
Go back to #haskell
THIS IS /PROG/

loeb :: Functor f => f (f a -> a) -> f a
loeb f = fmap ($ loeb f) f

>>21
Read SICP

Are you GAY?
Are you a NIGGER?
Are you a GAY NIGGER?

If you answered "Yes" to all of the above questions, then GNAA (GAY NIGGER ASSOCIATION OF AMERICA) might be exactly what you've been looking for!