A Fold for Every Occasion We can actually come up with a generic notion of folding which can apply to a whole bunch of different types. That is, we can systematically define a fold function for lists, trees and more. This generic notion of fold corresponds to the catamorphisms @pelotom mentioned in his comment. Recursive … Read more
From the Haskell report, this is the syntax for allowed symbols: a | b means a or b and a<b> means a except b special -> ( | ) | , | ; | [ | ] | `| { | } symbol -> ascSymbol | uniSymbol<special | _ | : | ” | ‘> … Read more
I consider it a half-truth. Haskell has an amazing ability to abstract, and that includes abstraction over imperative ideas. For example, Haskell has no built-in imperative while loop, but we can just write it and now it does: while :: (Monad m) => m Bool -> m () -> m () while cond action = … Read more
Suppose a function has side effects. If we take all the effects it produces as the input and output parameters, then the function is pure to the outside world. So, for an impure function f’ :: Int -> Int we add the RealWorld to the consideration f :: Int -> RealWorld -> (Int, RealWorld) — … Read more
I think you’ve seen elsewhere that your specific problem (creating ordered lists of integers that sum to a given number) is better solved using an alternative algorithm, rather than filtering a huge list of lists of integers. However, getting back to your original issue, it is possible to construct an equivalent of: replicateM p [1..n] … Read more
Sure. newtype UniqueSel a = UniqueSel {runUS :: [Int] -> [([Int], a)]} instance Monad UniqueSel where return a = UniqueSel (\ choices -> [(choices, a)]) m >>= k = UniqueSel (\ choices -> concatMap (\ (choices’, a) -> runUS (k a) choices’) (runUS m choices)) instance MonadPlus UniqueSel where mzero = UniqueSel $ \ _ … Read more
In most functional languages, this would work. However, Haskell is a pure functional language. You are not allowed to do IO in functions, so the function can either be [Int] -> [Int] without performing any IO or [Int] -> IO [Int] with IO The type of dot as inferred by the compiler is dot :: … Read more
Your question leaves a lot of room for interpretation. I’m taking a guess you aren’t accustom to building a whole pipeline of lexing, parsing, maybe type checking, and evaluating. The long answer would involve you defining what language you wish to evaluate (Just integers with ‘+’, perhaps all rationals with ‘+’, ‘-‘ ‘*’, “https://stackoverflow.com/”, or … Read more
This looks more like a buffering than a sequencing problem. What platform are you on? Have you tried forcing unbuffered output? hSetBuffering stdout NoBuffering — from System.IO
You were pretty close with the last one, but you need to add constraints: {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ConstraintKinds #-} import Data.Proxy both :: (c a, c b) => Proxy c -> (forall x. c x => x -> r) -> (a, b) -> (r, r) both Proxy f (x, y) = (f … Read more