December 2005 - Haskell-Cafe

Statements spanning multiple lines?
by Daniel Carrera 22 Dec '05

22 Dec '05

Hi all, How do I write a statement that spans multiple lines? I have this function: pythagoras n = [(a,b,c) | a <-[1..n], b <-[1..n], c <-[1..n], a <= b, b < c, a*a + b*b == c*c] This should all be in one line. I know some ways to make the line shorter, like defining local functions and using 'filter'. But the code would be clearer if I could just make this one statement span several lines. Daniel. -- /\/`) http://oooauthors.org /\/_/ http://opendocumentfellowship.org /\/_/ \/_/ I am not over-weight, I am under-tall. /

4 6

RE: GHC optimization issue
by Simon Peyton-Jones 22 Dec '05

22 Dec '05

(Brief because I'm at home.) Use INLINE (alone) to include swap at its call sites. (That gives perfect per-call-site specialisation.) Use SPECIALISE (alone) to make a specialised copy of swap, which is then not duplicated at each call site, but instead is called. No need to use them both. The fact that GHC inlines the (big) unspecialised version and not the (apparently smaller) specialised version, is something we should look into. Simon | -----Original Message----- | From: Joel Reymont [mailto:joelr1@gmail.com] | Sent: 22 December 2005 14:09 | To: Haskell-Cafe Cafe | Cc: Simon Peyton-Jones; Simon Marlow | Subject: GHC optimization issue | | Folks, | | I have been trying to improve my byte swapping routines as part of my | effort to speed up serialization. I then tried to look at the core | output from GHC to see what it was converting my code into. Brandon | (skew on #haskell) helped me code a TH version but then I went with a | regular CPP version instead. | | The point of contention is that the logical approach to optimization | does not produce expected results. The only difference between the | following two core outputs is the presence or absence of specialize | and inline pragmas. The code is the same. | | The version without pragmas inlines foo1 into | | Main.foo1 :: GHC.Word.Word16 | [GlobalId] | [Str: DmdType] | Main.foo1 = case GHC.Word.Word16 GHC.Word.$wshift3 __word 3855 (-8) | of ww1_a2eo { __DEFAULT -> | case GHC.Word.Word16 GHC.Word.$wshift3 __word 15 8 of | ww_a2f4 { __DEFAULT -> | GHC.Word.W16# (GHC.Prim.narrow16Word# | (GHC.Prim.plusWord# ww1_a2eo ww_a2f4)) | } | } | | Whereas the version _with_ pragmas produces a function call: | | Main.foo1 :: GHC.Word.Word16 | [GlobalId] | [Str: DmdType] | Main.foo1 = case GHC.Word.Word16 Swap1.$w$sswap16 __word 3855 | of ww1_s1Ia { __DEFAULT -> | GHC.Word.W16# ww1_s1Ia | } | | Is there a reasonable explanation? | | Both versions compiled thusly: ghc --make Foo.hs -O -ddump-simpl > foo | | Swap: | | {-# OPTIONS_GHC -fglasgow-exts -cpp #-} | module Swap1 | ( | swap16 | ) | where | | import Data.Word | import Data.Int | import Data.Bits | | #define BIG_ENDIAN 1 | | {-# SPECIALIZE swap16 :: Word16 -> Word16 #-} | {-# SPECIALIZE swap16 :: Int16 -> Int16 #-} | {-# INLINE swap16 #-} | | swap16 :: Bits a => a -> a | #ifdef BIG_ENDIAN | swap16 v = (v `shiftR` 8) + ((v .&. 0xFF) `shiftL` 8) | #else | swap16 v = v | #endif | | Foo: | | module Main where | | import Data.Word | import Swap1 | | foo1 :: Word16 | foo1 = swap16 0x0f0f | | main = putStrLn $ show foo1 | | Core output for the version WITH pragmas, see the version w/o pragmas | way below | | ==================== Tidy Core Rules ==================== | "SPEC Swap1.swap16" __forall {$dBits_X1Co :: {Data.Bits.Bits | GHC.Int.Int16}} | Swap1.swap16 @ GHC.Int.Int16 $dBits_X1Co | = Swap1.$sswap16 ; | "SPEC Swap1.swap16" __forall {$dBits_X1Cv :: {Data.Bits.Bits | GHC.Word.Word16}} | Swap1.swap16 @ GHC.Word.Word16 $dBits_X1Cv | = Swap1.$sswap161 ; | | | ==================== Tidy Core ==================== | Main.foo1 :: GHC.Word.Word16 | [GlobalId] | [Str: DmdType] | Main.foo1 = case GHC.Word.Word16 Swap1.$w$sswap16 __word 3855 | of ww1_s1Ia { __DEFAULT -> | GHC.Word.W16# ww1_s1Ia | } | | ==================== Tidy Core ==================== | Swap1.$w$sswap16 :: GHC.Prim.Word# -> GHC.Prim.Word# | [GlobalId] | [Arity 1 | NoCafRefs | Str: DmdType L] | Swap1.$w$sswap16 = \ (ww_s1I5 :: GHC.Prim.Word#) -> | case GHC.Prim.Word# GHC.Word.$wshift3 ww_s1I5 | (-8) of ww1_a1Gx { __DEFAULT -> | case GHC.Prim.Word# GHC.Word.$wshift3 | (GHC.Prim.and# ww_s1I5 __word 255) 8 | of ww11_a1Hd { __DEFAULT -> | GHC.Prim.narrow16Word# (GHC.Prim.plusWord# | ww1_a1Gx ww11_a1Hd) | } | } | | Swap1.$w$sswap161 :: GHC.Prim.Int# -> GHC.Prim.Int# | [GlobalId] | [Arity 1 | NoCafRefs | Str: DmdType L] | Swap1.$w$sswap161 = \ (ww_s1HV :: GHC.Prim.Int#) -> | case GHC.Prim.Int# GHC.Int.$wshift2 ww_s1HV | (-8) of ww1_a1Fk { __DEFAULT -> | case GHC.Prim.Int# GHC.Int.$wshift2 | (GHC.Prim.word2Int# | (GHC.Prim.and# (GHC.Prim.int2Word# ww_s1HV) __word 255)) | 8 | of ww11_a1G5 { __DEFAULT -> | GHC.Prim.narrow16Int# (GHC.Prim.+# ww1_a1Fk | ww11_a1G5) | } | } | | Swap1.$sswap16 :: GHC.Int.Int16 -> GHC.Int.Int16 | [GlobalId] | [Arity 1 | Worker Swap1.$w$sswap161 | NoCafRefs | Str: DmdType U(L)m] | Swap1.$sswap16 = __inline_me (\ (w_s1HT :: GHC.Int.Int16) -> | case GHC.Int.Int16 w_s1HT of w1_X1I5 | { GHC.Int.I16# ww_s1HV -> | case GHC.Int.Int16 Swap1.$w$sswap161 | ww_s1HV of ww1_s1I0 { __DEFAULT -> | GHC.Int.I16# ww1_s1I0 | } | }) | | Swap1.$sswap161 :: GHC.Word.Word16 -> GHC.Word.Word16 | [GlobalId] | [Arity 1 | Worker Swap1.$w$sswap16 | NoCafRefs | Str: DmdType U(L)m] | Swap1.$sswap161 = __inline_me (\ (w_s1I3 :: GHC.Word.Word16) -> | case GHC.Word.Word16 w_s1I3 of | w1_X1Ih { GHC.Word.W16# ww_s1I5 -> | case GHC.Word.Word16 Swap1.$w | $sswap16 ww_s1I5 of ww1_s1Ia { __DEFAULT -> | GHC.Word.W16# ww1_s1Ia | } | }) | | Swap1.swap16 :: forall a_a1aQ. (Data.Bits.Bits a_a1aQ) => a_a1aQ -> | a_a1aQ | [GlobalId] | [Arity 1 | NoCafRefs | Str: DmdType L] | Swap1.swap16 = __inline_me (\ (@ a_a1dB) | ($dBits_a1ip :: {Data.Bits.Bits | a_a1dB}) -> | let { | $dNum_s1BO :: {GHC.Num.Num a_a1dB} | [Str: DmdType {a1ip->U | (SAAAAAAAAAAAAAAAAA)}] | $dNum_s1BO = Data.Bits.$p1Bits @ | a_a1dB $dBits_a1ip } in | let { | lit_s1BN :: a_a1dB | [Str: DmdType {a1ip->U | (SAAAAAAAAAAAAAAAAA) s1BO->U(AAAAAAAAS)}] | lit_s1BN = GHC.Num.fromInteger @ | a_a1dB $dNum_s1BO (GHC.Num.S# 255) | } in | \ (v_a1aW :: a_a1dB) -> | GHC.Num.+ | @ a_a1dB | $dNum_s1BO | (Data.Bits.shiftR @ a_a1dB | $dBits_a1ip v_a1aW (GHC.Base.I# 8)) | (Data.Bits.shiftL | @ a_a1dB | $dBits_a1ip | (Data.Bits..&. @ a_a1dB | $dBits_a1ip v_a1aW lit_s1BN) | (GHC.Base.I# 8))) | | | Core output without pragmas: | | Main.foo1 :: GHC.Word.Word16 | [GlobalId] | [Str: DmdType] | Main.foo1 = case GHC.Word.Word16 GHC.Word.$wshift3 __word 3855 (-8) | of ww1_a2eo { __DEFAULT -> | case GHC.Word.Word16 GHC.Word.$wshift3 __word 15 8 of | ww_a2f4 { __DEFAULT -> | GHC.Word.W16# (GHC.Prim.narrow16Word# | (GHC.Prim.plusWord# ww1_a2eo ww_a2f4)) | } | } | | --- | Swap1.swap16 :: forall a_a1aQ. (Data.Bits.Bits a_a1aQ) => a_a1aQ -> | a_a1aQ | [GlobalId] | [Arity 1 | NoCafRefs | Str: DmdType L] | Swap1.swap16 = \ (@ a_a1dB) ($dBits_a1ip :: {Data.Bits.Bits a_a1dB}) -> | let { | $dNum_s1BK :: {GHC.Num.Num a_a1dB} | [Str: DmdType] | $dNum_s1BK = case {GHC.Num.Num a_a1dB} $dBits_a1ip | of tpl_B1 { Data.Bits.:DBits tpl1_B2 | tpl2_B3 tpl3_B4 tpl4_B5 tpl5_B6 tpl6_B7 tpl7_B8 tpl8_B9 tpl9_Ba | tpl10_Bb tpl11_Bc tpl12_Bd tpl13_Be tpl14_Bf tpl15_Bg tpl16_Bh | tpl17_Bi tpl18_Bj -> | tpl1_B2 | } } in | let { | lit_s1BM :: a_a1dB | [Str: DmdType] | lit_s1BM = case a_a1dB $dNum_s1BK | of tpl_B1 { GHC.Num.:DNum tpl1_B2 | tpl2_B3 tpl3_B4 tpl4_B5 tpl5_B6 tpl6_B7 tpl7_B8 tpl8_B9 tpl9_Ba -> | tpl9_Ba Swap1.lvl1 | } | } in | \ (v_a1aW :: a_a1dB) -> | tpl3_B4 | (case a_a1dB $dBits_a1ip | of tpl10_Xy { Data.Bits.:DBits tpl11_XB | tpl12_XD tpl13_XF tpl14_XH tpl15_XJ tpl16_XL tpl17_XN tpl18_XP | tpl19_XR tpl20_Bb tpl21_Bc tpl22_Bd tpl23_Be tpl24_Bf tpl25_Bg | tpl26_Bh tpl27_Bi tpl28_Bj -> | tpl26_Bh v_a1aW Swap1.lvl | }) | (case a_a1dB $dBits_a1ip | of tpl10_Xy { Data.Bits.:DBits tpl11_XB | tpl12_XD tpl13_XF tpl14_XH tpl15_XJ tpl16_XL tpl17_XN tpl18_XP | tpl19_XR tpl20_Bb tpl21_Bc tpl22_Bd tpl23_Be tpl24_Bf tpl25_Bg | tpl26_Bh tpl27_Bi tpl28_Bj -> | tpl25_Bg (tpl12_XD v_a1aW lit_s1BM) Swap1.lvl | }) | | -- | http://wagerlabs.com/ | | | |

2 1

ANN: HDBC 0.6.0
by John Goerzen 22 Dec '05

22 Dec '05

Hello, Version 0.6.0 of HDBC and the Sqlite3 bindings are now available. New features since Tuesday's 0.5.0 announcement include: * New type system for marshalling different Haskell types back and forth * New support for querying meta-information about the server * Much improved documentation * Fix for a race condition in the Sqlite3 binding * New fetchAllRows function that returns a lazy list of result rows (think hGetContents for database queries) I will shortly begin work on a PostgreSQL binding. Also, I plan to write a MissingH interface module. The main idea of that is to provide a SQL backend for the MissingH AnyDBM interface (which uses *dbm databases for persistent hashes). Combined with Sqlite, this provides a very interesting and easy to use persistent hash interface. -- John

1 0

FAQ: Why no interactive definitions?
by Greg Woodhouse 22 Dec '05

22 Dec '05

In neither GHCi nor Hugs (so far as I know) is it possible to interactively enter definitions. coming from Scheme, this was a bit of a surprise, as I'm used to being able to enter, say (define mysquare (lambda (x) (* x x))) Is this just a matter of the feature not being implemented, or is there a deeper reason for this? === Gregory Woodhouse <gregory.woodhouse(a)sbcglobal.net> "Interaction is the mind-body problem of computing." --Philip L. Wadler

3 2

Re: GHC Optimization Issue
by Brandon Moore 22 Dec '05

22 Dec '05

I think what's happening here is that the rewrite rule SPECIALIZE is producing turns the call to swap16 into a call to the specialized verision before any inlining happens[1], and then the specialized version can't be inlined[2]. Manually writing out a copy of swap16 at type Word16 -> Word16, marking it INLINE and setting up a rewite rule for specialization gives you the more efficient code: changing the definition to swap16 to this: swap16 :: Bits a => a -> a swap16 v = (v `shiftR` 8) + ((v .&. 0xFF) `shiftL` 8) {- # RULES "swap16/Word16" forall (v :: Int16) . swap16 v = swap16Word16 v #-} {- # INLINE swap16Word16 #-} swap16Word16 :: Word16 -> Word16 swap16Word16 v = (v `shiftR` 8) + ((v .&. 0xFF) `shiftL` 8) gives this Core for foo: Main.foo :: GHC.Word.Word16 [GlobalId] [Str: DmdType] Main.foo = case GHC.Word.Word16 GHC.Word.$wshift3 __word 3855 (-8) of ww1 { __DEFAULT -> case GHC.Word.Word16 GHC.Word.$wshift3 __word 15 8 of ww { __DEFAULT -> GHC.Word.W16# (GHC.Prim.narrow16Word# (GHC.Prim.plusWord# ww1 ww)) } } and for swapWord16: Swap.swap16Word16 :: GHC.Word.Word16 -> GHC.Word.Word16 [GlobalId] [Arity 1 NoCafRefs Str: DmdType U(L)m] Swap.swap16Word16 = __inline_me (\ (v :: GHC.Word.Word16) -> GHC.Word.+2 (GHC.Word.$dmshiftR2 v (GHC.Base.I# 8)) (GHC.Word.shift2 (GHC.Word..&.2 v Swap.lit) (GHC.Base.I# 8))) Removing the INLINE directive for swap16Word16 leaves this code for foo, with a call to the worker function for swap16Word16: Main.foo :: GHC.Word.Word16 [GlobalId] [Str: DmdType] Main.foo = case GHC.Word.Word16 Swap.$wswap16Word16 __word 3855 of ww1 { __DEFAULT -> GHC.Word.W16# ww1 } and these definitions for swap16Word16: Swap.$wswap16Word16 :: GHC.Prim.Word# -> GHC.Prim.Word# [GlobalId] [Arity 1 NoCafRefs Str: DmdType L] Swap.$wswap16Word16 = \ (ww :: GHC.Prim.Word#) -> case GHC.Prim.Word# GHC.Word.$wshift3 ww (-8) of ww1 { __DEFAULT -> case GHC.Prim.Word# GHC.Word.$wshift3 (GHC.Prim.and# ww __word 255) 8 of ww11 { __DEFAULT -> GHC.Prim.narrow16Word# (GHC.Prim.plusWord# ww1 ww11) } } Swap.swap16Word16 :: GHC.Word.Word16 -> GHC.Word.Word16 [GlobalId] [Arity 1 Worker Swap.$wswap16Word16 NoCafRefs Str: DmdType U(L)m] Swap.swap16Word16 = __inline_me (\ (w :: GHC.Word.Word16) -> case GHC.Word.Word16 w of w1 { GHC.Word.W16# ww -> case GHC.Word.Word16 Swap.$wswap16Word16 ww of ww1 { __DEFAULT -> GHC.Word.W16# ww1 } }) It looks like marking the function INLINE supresses the worker/wrapper split, and when there is not INLINE and the function get split, only the wrapper is eligible for inlining. Brandon Moore [1] (section 10.7.2 of the 6.4.1 User's guide says "In the earlier phases of compilation, GHC inlines nothing that appears on the LHS of a rule, because once you have substituted for something you can't match against it (given the simple minded matching).") [2] Maybe because the worker isn't annotation with __inline_me in the Core? Maybe from the aside in 7.10.5 about and INLINE pragma preventing any inlining in the RHS of the thing marked inline?

1 0

Re: [Haskell-cafe] Functions with side-effects?
by Wolfgang Jeltsch 22 Dec '05

22 Dec '05

Am Donnerstag, 22. Dezember 2005 03:32 schrieb Gregory Woodhouse: > [...] > If this analogy is at all valid, then I wonder if the IO monad, at > least, doesn't represent something of a blurring of the traditional > distinction between applications and operating system functionality. An application can modify local state, e.g., a C variable. Purely functional code cannot do this. > Incidentally, devices do not necessarily correspond to hardware and > you can write drivers to do all sorts of interesting things if you > are so inclined -- just as monads are not limited in their use to I/O. The IO monad is not just about I/O but also about modifiable variables. Most other monads only deal with purely functional stuff. For example, a list has nothing to do with modifiable variables and I/O at all. > > We have a "evaluation machine" and a "execution machine". The former > > evaluates expressions, the latter executes I/O actions. > > This is where I'm a bit fuzzy. "Actions" make think of something like > a finite automaton, where the action would be (possibly) consuming an > input token and changing state. "Actions" makes me think of things like I/O and modifying variables in contrast to calculations which don't really "act". Of course, an I/O action, for example, modifies a state, namely the state of the outside world. > > When the program is started, the execution machine wants to execute the > > actions from the "main to do list". In order to be able to do so, it asks > > the evaluation machine to start evaluating main. For each entry on the to > > do list, main is evaluated as far as it's necessary to provide the > > execution machine with the entry. Of course, evaluating main may result > > in evaluating other expressions. > > I imagine this is somewhat analogous to a C statement like > > c = getchar(); > > Evaluation is "blocked" (and the process becomes not runnable) until > such a time as getchar() returns a value. If there is no buffered > input, a system call will be required, and control will pass to the > driver for the appropriate device. When control returns to the > calling process it can, of course, go on until it again > (transparently) blocks, waiting for input or other actions. I meant it the other way round. The execution machine does something like the following: while (actionsRemaining()) { nextAction = getNextAction(); executeAction(nextAction); } getNextAction() will force the evaluation machine to evaluate as much of main as is needed to provide the execution machine with the next action. > > The point is that the evaluation machine does never execute any I/O > > actions while the execution machine is unable to do any evaluation but > > needs to be feeded by the evaluation machine. > > Is this a reasonable analogy? I think so. :-) > [...] Best wishes, Wolfgang

1 0

GHC optimization issue
by Joel Reymont 22 Dec '05

22 Dec '05

Folks, I have been trying to improve my byte swapping routines as part of my effort to speed up serialization. I then tried to look at the core output from GHC to see what it was converting my code into. Brandon (skew on #haskell) helped me code a TH version but then I went with a regular CPP version instead. The point of contention is that the logical approach to optimization does not produce expected results. The only difference between the following two core outputs is the presence or absence of specialize and inline pragmas. The code is the same. The version without pragmas inlines foo1 into Main.foo1 :: GHC.Word.Word16 [GlobalId] [Str: DmdType] Main.foo1 = case GHC.Word.Word16 GHC.Word.$wshift3 __word 3855 (-8) of ww1_a2eo { __DEFAULT -> case GHC.Word.Word16 GHC.Word.$wshift3 __word 15 8 of ww_a2f4 { __DEFAULT -> GHC.Word.W16# (GHC.Prim.narrow16Word# (GHC.Prim.plusWord# ww1_a2eo ww_a2f4)) } } Whereas the version _with_ pragmas produces a function call: Main.foo1 :: GHC.Word.Word16 [GlobalId] [Str: DmdType] Main.foo1 = case GHC.Word.Word16 Swap1.$w$sswap16 __word 3855 of ww1_s1Ia { __DEFAULT -> GHC.Word.W16# ww1_s1Ia } Is there a reasonable explanation? Both versions compiled thusly: ghc --make Foo.hs -O -ddump-simpl > foo Swap: {-# OPTIONS_GHC -fglasgow-exts -cpp #-} module Swap1 ( swap16 ) where import Data.Word import Data.Int import Data.Bits #define BIG_ENDIAN 1 {-# SPECIALIZE swap16 :: Word16 -> Word16 #-} {-# SPECIALIZE swap16 :: Int16 -> Int16 #-} {-# INLINE swap16 #-} swap16 :: Bits a => a -> a #ifdef BIG_ENDIAN swap16 v = (v `shiftR` 8) + ((v .&. 0xFF) `shiftL` 8) #else swap16 v = v #endif Foo: module Main where import Data.Word import Swap1 foo1 :: Word16 foo1 = swap16 0x0f0f main = putStrLn $ show foo1 Core output for the version WITH pragmas, see the version w/o pragmas way below ==================== Tidy Core Rules ==================== "SPEC Swap1.swap16" __forall {$dBits_X1Co :: {Data.Bits.Bits GHC.Int.Int16}} Swap1.swap16 @ GHC.Int.Int16 $dBits_X1Co = Swap1.$sswap16 ; "SPEC Swap1.swap16" __forall {$dBits_X1Cv :: {Data.Bits.Bits GHC.Word.Word16}} Swap1.swap16 @ GHC.Word.Word16 $dBits_X1Cv = Swap1.$sswap161 ; ==================== Tidy Core ==================== Main.foo1 :: GHC.Word.Word16 [GlobalId] [Str: DmdType] Main.foo1 = case GHC.Word.Word16 Swap1.$w$sswap16 __word 3855 of ww1_s1Ia { __DEFAULT -> GHC.Word.W16# ww1_s1Ia } ==================== Tidy Core ==================== Swap1.$w$sswap16 :: GHC.Prim.Word# -> GHC.Prim.Word# [GlobalId] [Arity 1 NoCafRefs Str: DmdType L] Swap1.$w$sswap16 = \ (ww_s1I5 :: GHC.Prim.Word#) -> case GHC.Prim.Word# GHC.Word.$wshift3 ww_s1I5 (-8) of ww1_a1Gx { __DEFAULT -> case GHC.Prim.Word# GHC.Word.$wshift3 (GHC.Prim.and# ww_s1I5 __word 255) 8 of ww11_a1Hd { __DEFAULT -> GHC.Prim.narrow16Word# (GHC.Prim.plusWord# ww1_a1Gx ww11_a1Hd) } } Swap1.$w$sswap161 :: GHC.Prim.Int# -> GHC.Prim.Int# [GlobalId] [Arity 1 NoCafRefs Str: DmdType L] Swap1.$w$sswap161 = \ (ww_s1HV :: GHC.Prim.Int#) -> case GHC.Prim.Int# GHC.Int.$wshift2 ww_s1HV (-8) of ww1_a1Fk { __DEFAULT -> case GHC.Prim.Int# GHC.Int.$wshift2 (GHC.Prim.word2Int# (GHC.Prim.and# (GHC.Prim.int2Word# ww_s1HV) __word 255)) 8 of ww11_a1G5 { __DEFAULT -> GHC.Prim.narrow16Int# (GHC.Prim.+# ww1_a1Fk ww11_a1G5) } } Swap1.$sswap16 :: GHC.Int.Int16 -> GHC.Int.Int16 [GlobalId] [Arity 1 Worker Swap1.$w$sswap161 NoCafRefs Str: DmdType U(L)m] Swap1.$sswap16 = __inline_me (\ (w_s1HT :: GHC.Int.Int16) -> case GHC.Int.Int16 w_s1HT of w1_X1I5 { GHC.Int.I16# ww_s1HV -> case GHC.Int.Int16 Swap1.$w$sswap161 ww_s1HV of ww1_s1I0 { __DEFAULT -> GHC.Int.I16# ww1_s1I0 } }) Swap1.$sswap161 :: GHC.Word.Word16 -> GHC.Word.Word16 [GlobalId] [Arity 1 Worker Swap1.$w$sswap16 NoCafRefs Str: DmdType U(L)m] Swap1.$sswap161 = __inline_me (\ (w_s1I3 :: GHC.Word.Word16) -> case GHC.Word.Word16 w_s1I3 of w1_X1Ih { GHC.Word.W16# ww_s1I5 -> case GHC.Word.Word16 Swap1.$w $sswap16 ww_s1I5 of ww1_s1Ia { __DEFAULT -> GHC.Word.W16# ww1_s1Ia } }) Swap1.swap16 :: forall a_a1aQ. (Data.Bits.Bits a_a1aQ) => a_a1aQ -> a_a1aQ [GlobalId] [Arity 1 NoCafRefs Str: DmdType L] Swap1.swap16 = __inline_me (\ (@ a_a1dB) ($dBits_a1ip :: {Data.Bits.Bits a_a1dB}) -> let { $dNum_s1BO :: {GHC.Num.Num a_a1dB} [Str: DmdType {a1ip->U (SAAAAAAAAAAAAAAAAA)}] $dNum_s1BO = Data.Bits.$p1Bits @ a_a1dB $dBits_a1ip } in let { lit_s1BN :: a_a1dB [Str: DmdType {a1ip->U (SAAAAAAAAAAAAAAAAA) s1BO->U(AAAAAAAAS)}] lit_s1BN = GHC.Num.fromInteger @ a_a1dB $dNum_s1BO (GHC.Num.S# 255) } in \ (v_a1aW :: a_a1dB) -> GHC.Num.+ @ a_a1dB $dNum_s1BO (Data.Bits.shiftR @ a_a1dB $dBits_a1ip v_a1aW (GHC.Base.I# 8)) (Data.Bits.shiftL @ a_a1dB $dBits_a1ip (Data.Bits..&. @ a_a1dB $dBits_a1ip v_a1aW lit_s1BN) (GHC.Base.I# 8))) Core output without pragmas: Main.foo1 :: GHC.Word.Word16 [GlobalId] [Str: DmdType] Main.foo1 = case GHC.Word.Word16 GHC.Word.$wshift3 __word 3855 (-8) of ww1_a2eo { __DEFAULT -> case GHC.Word.Word16 GHC.Word.$wshift3 __word 15 8 of ww_a2f4 { __DEFAULT -> GHC.Word.W16# (GHC.Prim.narrow16Word# (GHC.Prim.plusWord# ww1_a2eo ww_a2f4)) } } --- Swap1.swap16 :: forall a_a1aQ. (Data.Bits.Bits a_a1aQ) => a_a1aQ -> a_a1aQ [GlobalId] [Arity 1 NoCafRefs Str: DmdType L] Swap1.swap16 = \ (@ a_a1dB) ($dBits_a1ip :: {Data.Bits.Bits a_a1dB}) -> let { $dNum_s1BK :: {GHC.Num.Num a_a1dB} [Str: DmdType] $dNum_s1BK = case {GHC.Num.Num a_a1dB} $dBits_a1ip of tpl_B1 { Data.Bits.:DBits tpl1_B2 tpl2_B3 tpl3_B4 tpl4_B5 tpl5_B6 tpl6_B7 tpl7_B8 tpl8_B9 tpl9_Ba tpl10_Bb tpl11_Bc tpl12_Bd tpl13_Be tpl14_Bf tpl15_Bg tpl16_Bh tpl17_Bi tpl18_Bj -> tpl1_B2 } } in let { lit_s1BM :: a_a1dB [Str: DmdType] lit_s1BM = case a_a1dB $dNum_s1BK of tpl_B1 { GHC.Num.:DNum tpl1_B2 tpl2_B3 tpl3_B4 tpl4_B5 tpl5_B6 tpl6_B7 tpl7_B8 tpl8_B9 tpl9_Ba -> tpl9_Ba Swap1.lvl1 } } in \ (v_a1aW :: a_a1dB) -> tpl3_B4 (case a_a1dB $dBits_a1ip of tpl10_Xy { Data.Bits.:DBits tpl11_XB tpl12_XD tpl13_XF tpl14_XH tpl15_XJ tpl16_XL tpl17_XN tpl18_XP tpl19_XR tpl20_Bb tpl21_Bc tpl22_Bd tpl23_Be tpl24_Bf tpl25_Bg tpl26_Bh tpl27_Bi tpl28_Bj -> tpl26_Bh v_a1aW Swap1.lvl }) (case a_a1dB $dBits_a1ip of tpl10_Xy { Data.Bits.:DBits tpl11_XB tpl12_XD tpl13_XF tpl14_XH tpl15_XJ tpl16_XL tpl17_XN tpl18_XP tpl19_XR tpl20_Bb tpl21_Bc tpl22_Bd tpl23_Be tpl24_Bf tpl25_Bg tpl26_Bh tpl27_Bi tpl28_Bj -> tpl25_Bg (tpl12_XD v_a1aW lit_s1BM) Swap1.lvl }) -- http://wagerlabs.com/

1 0

RE: [Haskell-cafe] When to teach IO
by Bayley, Alistair 22 Dec '05

22 Dec '05

> [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of > jerzy.karczmarczuk(a)info.unicaen.fr > > PS. About the subject (when to teach IO): don't be sectarians. If > a programming course insists on algorithmics, the IO issues can be > postponed a bit. If it insists on practical data processing, IO > should come in immediately. A programming course should be > harmonious, homogeneous, well assembled, interesting, and easy to > put into practice (...sorry for triviality, you ALL know that...), > and the details depend on the language and on the teacher. > In Scheme it is easier than in Haskell. _What_ is easier in Scheme than in Haskell? IO, or teaching (IO)? ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

2 1

Re: When to teach IO (was Tutorial uploaded)
by Bayley, Alistair 22 Dec '05

22 Dec '05

> From: haskell-cafe-bounces(a)haskell.org > [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of Robin Green > > No, that's not what I meant at all. I meant that for *many* > but not all > practical programming tasks, IO is important. Games, GUI office > applications, database applications, web applications, etc. > > Compilers are atypical in this regard. Something that is perceived as > being only useful for a compilers and a few other academic-ish things > isn't going to be perceived as very practically useful. > -- > Robin Hear, hear. Compilers, and computationally complex programs in general, are atypical. IMO, a lot of programming these days is integration work i.e. shuffling and transforming data from one system to another, or transforming data for reports, etc. Not many programmers write compilers these days :-( (apologies to the Simons, and John Meacham, and anyone else who *has* written a compiler, Haskell or otherwise...) http://www.mcs.vuw.ac.nz/~kjx/papers/nopp.pdf It's good to start with IO. Reading and writing files, parsing and printing (show and read), talking to databases, GUIs, and networking are more-or-less essential activities, and people want to know early on how to do these things. You don't have to introduce the IO monad; just tell people that we separate IO functions from "pure" functions with this special IO type, and, with the "imperative" do-notation, IO code in Haskell looks a lot like IO code in C/Java/.Net. The Really Good Stuff (real monadic programming) can come later. Perhaps there are two different worlds to consider. Teaching Haskell to tertiary students might well be better suited to a style where purely functional programming is explored in some detail before IO and monads are introduced. However, a jobbing programmer evaluating Haskell wants to know how they do the things they're used to doing in other langauges, and if they see the volume of stuff that must be covered before topics like IO, GUIs, and networking, they'll start to look elsewhere... How hard should it be to shove a window on the screen, or select some data from a database? Part of the problem is that we're not just introducing a new language, we're introducing a new paradigm. I can see that a noob would choke if you tried to ram it down their throat all at once. As a comparison, I have some .Net books in front of me, and although they also introduce the language first (declarations, choice, iteration, classes and interfaces), it's pretty trivial stuff and can be skimmed over fairly quickly, and then you quickly get into introspection (reflection), GUIs, IO, databases, and networking. Indeed, the bulk of the book covers these topics. Alistair ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

4 3

Problems with square root...
by Daniel Carrera 21 Dec '05

21 Dec '05

Hey, The sqrt function is not doing what I want. This is what I want: round sqrt(2) The problem is that sqrt() returns a "Floating" value and round wants a "ReacFrac": --//-- *Main> round sqrt(2) <interactive>:1:0: No instances for (RealFrac (a -> a), Integral (t -> a1)) arising from use of `round' at <interactive>:1:0-4 Probable fix: add an instance declaration for (RealFrac (a -> a), Integral (t -> a1)) In the definition of `it': it = round sqrt (2) *Main> --//-- I'm trying to figure out how to turn a Float into a RealFrac so I can pass it to 'round'. Any ideas? Daniel. -- /\/`) http://oooauthors.org /\/_/ http://opendocumentfellowship.org /\/_/ \/_/ I am not over-weight, I am under-tall. /

7 9