December 2021 - Haskell-Cafe

Logging
by Hilco Wijbenga 09 Dec '21

09 Dec '21

Hi all, I just started using "logging" (https://hackage.haskell.org/package/logging) which is based on "fast-logger" (https://hackage.haskell.org/package/fast-logger) It all works fine except that the timestamp in the log message is output as UTC. I would like it to use my local (i.e. system) TZ. I tried setting the TZ environment variable explicitly (before invoking my main) and by setting it in code (System.Environment.setEnv) but it doesn't make any difference. I did not find anything in either API about this so I'm out of ideas. If this is simply impossible, does anyone have a recommendation for another logging package? Cheers, Hilco

11 18

Re Is the Haskell list comprehension just a Cartesian product machine?
by Douglas McIlroy 09 Dec '21

09 Dec '21

> could I explain Haskell list comprehensions as basically just a > Cartesian/cross product machine? Another deviation from the simple explanation: the pair (2,1) never appears in an enumeration from the Haskell expression [(x,y) | x<-[1..], y<-[1..]] Although the notation is adapted from set theory, it does not necessarily reflect the meaning of its set-theory analog. A list comprehension specifies an enumeration order. In the present case that ordering is not well founded: some elements have an infinite descending chain of predecessors and thus never appear in the enumeration. Doug

1 0

Is the Haskell list comprehension just a Cartesian product machine?
by Galaxy Being 08 Dec '21

08 Dec '21

If I were a teacher of high-schoolers wanting to add some theory to Haskell could I explain Haskell list comprehensions as basically just a Cartesian/cross product machine? Would this be accurate? And then the combinatorics product rule also seems at play here. I would appreciate any theoretical explanation of what a list comprehension is about. ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 2

with -XOverloadedStrings, when is the implied fromString floated out?
by Johannes Waldmann 07 Dec '21

07 Dec '21

Dear Cafe, with OverloadedStrings, the compiler inserts `fromString` applications at String literals. I was wondering - are these floated out? {-# language OverloadedStrings #-} import Data.String import Debug.Trace data Foo = Foo deriving Show instance IsString Foo where fromString "Foo" = trace "**fromString**" Foo main = let { f Foo = "Foo" :: Foo; g _ = "Foo" :: Foo } in print $ map (f . g) [0..1] With ghc -O1, I get **fromString** [Foo,Foo] That's good - not just floated out, but also interned (? - both "Foo" are really the same, just one call) With ghc -00, and in ghci, I get **fromString** **fromString** **fromString** **fromString** [Foo,Foo] no floating here. Is there a way to get this floated in ghci? The background of my question is that overloaded strings, and ghci, are heavily used in Tidal Cycles https://hackage.haskell.org/package/tidal I guess it's mostly fine, because it's rare (in live coding performance) that application code contains function definitions. - J.

2 1

Re: [Haskell-cafe] Endo a, endomorphisms
by Olaf Klinke 07 Dec '21

07 Dec '21

> it might be possible that the intention was > to state that function composition is an endomorphism of the set of endofunctions (Endo a). > So again, given that the context is the Data.Monoid library, it seems much more appropriate to > say that Endo a forms a monoid of endofunctions under composition. As the examples I presented > above show, even stating that function composition is an endomorphism of Endo a (endofunctions) > seems incorrect. > What you write does not even type-check: Composition is an operation (b -> c) -> (a -> b) -> (a -> c) so it is a binary operation. Hence it cannot form an endomorphism, because you can't unify the above type with (x -> x). No ambiguity here. > opening :: String -> String > opening = ("Hello, " ++) > > closing :: String -> String > > closing = (++ "!") > > eo = Endo opening > > ec = Endo closing This is a manifestation of the fact that every monoid has a function a -> Endo a given by \a -> Endo (mappend a) This is indeed a monoid homomorphism (by virtue of associativity). Your 'eo' is of this kind. But then you mixed in another monoid homomorphism, namely \a -> Endo (flip mappend a) where your 'ec' is of this kind. It is not true in general that you can mix these two monoid homomorphisms. Only for commutative monoids the above two homomorphisms are identical. And (String,++) is not commutative. Indeed we could not give a Monoid instance to naked (a -> a) because it overlaps with the Semigroup instance you mention. But historically this is not the reason why the Endo newtype was introduced. One could argue that the Semigroup instance should also be on a newtype. I'd be in favour of such a proposal. Olaf P.S.: Let S be a functor (a signature) and a be an S-algebra, that is, there is a structure map alpha :: S a -> a. Then for any r, the type (r -> a) is an S-algebra, too. Indeed, alpha' :: Functor s => (s a -> a) -> s (r -> a) -> r -> a alpha' alpha sf = \r -> alpha (fmap ($x) sf) This is what makes the ReaderT transformer work. For Semigroup, the signature is S a = (a,a) and alpha = uncurry (<>).

1 0

Endo a, endomorphisms
by Adrian 06 Dec '21

06 Dec '21

In the Data.Monoid library there is a monoid type instance for Endo a that is described in the following manner: > The monoid of endomorphisms under composition. I understand how it is a monoid of endofunctions, but am unclear on how it is a monoid of endomorphisms. In the pattern: "forms a monoid of X under Y", X refers to the set and Y to the associative binary operation. So it seems that X in this case is the set of endofunctions. However, it might be possible that the intention was to state that function composition is an endomorphism of the set of endofunctions (Endo a). However even this statement seems difficult to prove in Haskell: opening :: String -> String opening = ("Hello, " ++) closing :: String -> String closing = (++ "!") eo = Endo opening ec = Endo closing appEndo (Endo $ opening <> closing) "Haskell" -- "Hello, HaskellHaskell!" (appEndo eo <> appEndo ec) "Haskell" -- "Hello, HaskellHaskell!" appEndo (eo <> ec) "Haskell -- "Hello, Haskell!" (opening <> closing) "Haskell" -- "Hello, HaskellHaskell!" (opening . closing) "Haskell" -- "Hello, Haskell!" I believe the reason for this behavior is that the fallback for mappend for the general endofunction with type a -> b is found in the Base library as: -- @since 4.9.0.0 instance Semigroup b => Semigroup (a -> b) where f <> g = \x -> f x <> g x

3 7

Output order of Data.List.permutations?
by Johannes Waldmann 05 Dec '21

05 Dec '21

Dear Cafe - what is the ordering of the output of https://hackage.haskell.org/package/base-4.16.0.0/docs/src/Data.OldList.htm… - and why is it not lexicographic? E.g., *Main> last $ L.permutations [1..8] [5,3,6,2,7,1,8,4] note: [5,_,6,_,7,_,8,_] and [_,3,_,2,_,1,_,4] indeed, an auxiliary function is called "interleave". Data.List.permutations appeared in base-4.0.0.0 (ghc-6.10.1, 2008) https://downloads.haskell.org/~ghc/6.10.1/docs/html/users_guide/release-6-1… What is the source of the algorithm? Is it any of the algorithms in Knuth AOCP 4A(I) 7.2.1.2? Hard to tell - as they are given in an imperative style. The implementation *is* fast, e.g., L.sort . L.permutations seems better than a naive lexicographic enumeration lp1 [] = [[]] lp1 xs = do (ys, z:zs) <- zip (L.inits xs) (L.tails xs) (z:) <$> lp1 (ys <> zs) (un-scientifically measured with :set +s) Here, clearly, L.inits and "<>" are bad. NB - I was looking in to this because of https://www.mathekalender.de/wp/calendar/challenges/challenge-01/ Yes I know that can be solved without enumeration. - J.

1 2

ANN: NASA's ogma
by Ivan Perez 04 Dec '21

04 Dec '21

Dear café We are thrilled to announce the release of Ogma, a new open-source NASA tool, written in Haskell, to generate hard-realtime C runtime monitoring applications from high-level specifications. Ogma takes the output of existing tools, like NASA's requirements elicitation tool FRET [2], and produces monitors in Copilot [3], a runtime verification language that can be compiled to hard-realtime C99. Ogma is also able to produce monitoring applications for NASA's Core Flight System (cFS), which can be compiled alongside existing applications to flag requirement violations. On the website you will see several videos, including one with a FRET requirement being monitored inside the XPlane flight simulator by taking the code generated by Ogma and making it accessible to the simualtor via a custom on-screen plugin. This is research-only software (Class E) and it has not been certified for use in aircraft or UAVs. We are currently using it for upcoming experiments at NASA Langley. We'd like to also take this opportunity to publicly thank the team that creates BNFC, for their tool, their response to technical questions during the development of ogma, and for accommodations made to help us speed up our release process. If you have any issues, feel free to open a ticket in the github repo directly. Happy haskelling, [1] https://github.com/NASA/ogma [2] https://github.com/NASA-SW-VnV/fret [3] https://github.com/Copilot-Language/copilot

1 0

Why and How the External STG Interpreter is Useful (Online presentation, Dec 2, Thursday, 17:00 UTC)
by Csaba Hruska 03 Dec '21

03 Dec '21

Hello, Today I'll do a presentation about the external stg interpreter. If you are interested please join and ask questions. https://skillsmatter.com/meetups/13654-haskell-stg-interp Regards, Csaba Hruska Abstract: Haskell: Why and How the External STG Interpreter is Useful The external STG interpreter is a from scratch implementation of the STG machine in Haskell. Currently it supports almost all GHC primops and RTS features. It can run real world Haskell programs that were compiled with GHC Whole Program Compiler (GHC-WPC). GHC-WPC is a GHC fork that exports the whole program STG IR. The external STG interpreter is an excellent tool to study the runtime behaviour of Haskell programs, i.e. it can run/interpret GHC or Pandoc. The implementation of the interpreter is in plain simple Haskell, so it makes compiler backend and tooling development approachable for everyone. It already has a programmable debugger which supports step-by-step evaluation, breakpoints and execution region based inspection. It also can export the whole program memory state and call-graphs to files for further investigation. These features make it easy to find a memory leak or to identify a performance bottleneck in a large real world Haskell application. https://github.com/grin-compiler/ghc-whole-program-compiler-project

1 1

Re: [Haskell-cafe] Breaking change to Eq accepted by Core Libraries Committee
by Olaf Klinke 03 Dec '21

03 Dec '21

For what it's worth, one of the examples listed in the issue where (/=) is not simply the negation of (==) is violating the laws. It is the one in https://hackage.haskell.org/package/numbers-3000.2.0.2/docs/Data-Number-Int… That module defines two intervals to be equal if their bounds are equal, but to be unequal only if they are disjoint. In my eyes this speaks for the proposal, because the library author would have been unable to write the broken instance. (And I did look at the proposal some time ago, whence I feel it was indeed discussed or at least mentioned on this list before.) Olaf

6 7