Ticket #5565: session-2.txt

                  -> Word16
                  -> Word16
                  -> Word16
                  -> IPv6Address'
    has only 8
    In the first argument of `print', namely
      `(IPv6Address 1 0 0 1 0 0 0 1 0)'
    In the expression: print (IPv6Address 1 0 0 1 0 0 0 1 0)
    In an equation for `it': it = print (IPv6Address 1 0 0 1 0 0 0 1 0)
*Main> print (IPv6Address 1 0 0 1 0 0 0 1)
1:::1:::1
*Main> :r
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )
Ok, modules loaded: Main.
*Main> print (IPv6Address 1 0 0 1 0 0 0 1)
1::1::1
*Main> let longestZeroSeq parts = groupBy ((==) `on` fst) zip parts [0..]

<interactive>:1:42: Not in scope: `on'
*Main> import Data.Function
*Main Data.Function> let longestZeroSeq parts = groupBy ((==) `on` fst) zip part
s [0..]

<interactive>:1:28:
    The function `groupBy' is applied to four arguments,
    but its type `(a0 -> a0 -> Bool) -> [a0] -> [[a0]]' has only two
    In the expression: groupBy ((==) `on` fst) zip parts [0 .. ]
    In an equation for `longestZeroSeq':
        longestZeroSeq parts = groupBy ((==) `on` fst) zip parts [0 .. ]
*Main Data.Function> let longestZeroSeq parts = groupBy ((==) `on` fst) (zip par
ts [0..])
*Main Data.Function> longestZeroSeq [1,2,0,0,0,1,0,0,2,0,0,0,0]
[[(1,0)],[(2,1)],[(0,2),(0,3),(0,4)],[(1,5)],[(0,6),(0,7)],[(2,8)],[(0,9),(0,10)
,(0,11),(0,12)]]
*Main Data.Function> longestZeroSeq = fst $ maxBy length $ filter ((==0) . fst .
 head) $ groupBy ((==) `on` fst) $ zip parts [0..]

<interactive>:1:16: parse error on input `='
*Main Data.Function> let longestZeroSeq = fst $ maxBy length $ filter ((==0) . f
st . head) $ groupBy ((==) `on` fst) $ zip parts [0..]

<interactive>:1:28: Not in scope: `maxBy'

<interactive>:1:103: Not in scope: `parts'
*Main Data.Function> let longestZeroSeq parts = fst $ maximumBy length $ filter
((==0) . fst . head) $ groupBy ((==) `on` fst) $ zip parts [0..]

<interactive>:1:44:
    Couldn't match expected type `[a0] -> Ordering'
                with actual type `Int'
    Expected type: [a0] -> [a0] -> Ordering
      Actual type: [a0] -> Int
    In the first argument of `maximumBy', namely `length'
    In the expression: maximumBy length
*Main Data.Function> let longestZeroSeq parts = fst $ maximumBy (comparing.lengt
h) $ filter ((==0) . fst . head) $ groupBy ((==) `on` fst) $ zip parts [0..]

<interactive>:1:45: Not in scope: `comparing'
*Main Data.Function> import Data.List
*Main Data.Function Data.List> let longestZeroSeq parts = fst $ maximumBy (compa
ring.length) $ filter ((==0) . fst . head) $ groupBy ((==) `on` fst) $ zip parts
 [0..]

<interactive>:1:45: Not in scope: `comparing'
*Main Data.Function Data.List> import Data.Ord
*Main Data.Function Data.List Data.Ord> let longestZeroSeq parts = fst $ maximum
By (comparing.length) $ filter ((==0) . fst . head) $ groupBy ((==) `on` fst) $
zip parts [0..]

<interactive>:1:45:
    Couldn't match expected type `Ordering'
                with actual type `a0 -> Ordering'
    Expected type: (a0 -> a1) -> a0 -> Ordering
      Actual type: (a0 -> a1) -> a0 -> a0 -> Ordering
    In the first argument of `(.)', namely `comparing'
    In the first argument of `maximumBy', namely `(comparing . length)'
*Main Data.Function Data.List Data.Ord> let longestZeroSeq parts = fst $ maximum
By (comparing length) $ filter ((==0) . fst . head) $ groupBy ((==) `on` fst) $
zip parts [0..]

<interactive>:1:34:
    Couldn't match expected type `(a0, b0)'
                with actual type `[(b1, b2)]'
    In the second argument of `($)', namely
      `maximumBy (comparing length)
     $   filter ((== 0) . fst . head)
       $   groupBy ((==) `on` fst) $ zip parts [0 .. ]'
    In the expression:
        fst
      $   maximumBy (comparing length)
        $   filter ((== 0) . fst . head)
          $   groupBy ((==) `on` fst) $ zip parts [0 .. ]
    In an equation for `longestZeroSeq':
        longestZeroSeq parts
          = fst
          $   maximumBy (comparing length)
            $   filter ((== 0) . fst . head)
              $   groupBy ((==) `on` fst) $ zip parts [0 .. ]
*Main Data.Function Data.List Data.Ord> let longestZeroSeq parts = maximumBy (co
mparing length) $ filter ((==0) . fst . head) $ groupBy ((==) `on` fst) $ zip pa
rts [0..]
*Main Data.Function Data.List Data.Ord> longestZeroSeq [1,0,0,0,0,0,1,0,0,1,0]
[(0,1),(0,2),(0,3),(0,4),(0,5)]
*Main Data.Function Data.List Data.Ord> let longestZeroSeq parts = $ maximumBy (
comparing length) $ filter ((==0) . fst . head) $ groupBy ((==) `on` fst) $ zip
parts [0..]
*Main Data.Function Data.List Data.Ord> :r
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:32:46: Not in scope: `go'

IpAddress.hs:35:26:
    Illegal view pattern:  length -> maxZeroLen
    Use -XViewPatterns to enable view patterns

IpAddress.hs:35:45:
    Illegal view pattern:  snd . head -> maxZeroAt
    Use -XViewPatterns to enable view patterns

IpAddress.hs:35:79: Not in scope: `comparing'

IpAddress.hs:35:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude Data.Function Data.List Data.Ord> r

<interactive>:1:1: Not in scope: `r'
Prelude Data.Function Data.List Data.Ord> :r
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:35:46: Not in scope: `go'

IpAddress.hs:38:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude Data.Function Data.List Data.Ord>
ghc.exe: panic! (the 'impossible' happened)
  (GHC version 7.0.3 for i386-unknown-mingw32):
        thread blocked indefinitely in an MVar operation

Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug


C:\Users\porges\Desktop\H>ghci IpAddress.hs
GHCi, version 7.0.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package ffi-1.0 ... linking ... done.
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:35:46: Not in scope: `go'

IpAddress.hs:38:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude> :l test.hs
[1 of 1] Compiling Main             ( test.hs, interpreted )

test.hs:3:44: Not in scope: `maximumBy'

test.hs:3:55: Not in scope: `comparing'

test.hs:3:105: Not in scope: `groupBy'

test.hs:3:119: Not in scope: `on'

test.hs:3:135: Not in scope: `parts'
Failed, modules loaded: none.
Prelude> :r
[1 of 1] Compiling Main             ( test.hs, interpreted )

test.hs:6:119: Not in scope: `on'

test.hs:6:135: Not in scope: `parts'
Failed, modules loaded: none.
Prelude> :r
[1 of 1] Compiling Main             ( test.hs, interpreted )

test.hs:7:119: Not in scope: `on'
Failed, modules loaded: none.
Prelude> :q
Leaving GHCi.

C:\Users\porges\Desktop\H>ghci IpAddress.hs
GHCi, version 7.0.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package ffi-1.0 ... linking ... done.
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:35:46: Not in scope: `go'

IpAddress.hs:38:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude> :r
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:35:46: Not in scope: `go'

IpAddress.hs:38:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude> :r
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:34:46: Not in scope: `go'

IpAddress.hs:37:26:
    Illegal view pattern:  length -> maxZeroLen
    Use -XViewPatterns to enable view patterns

IpAddress.hs:37:45:
    Illegal view pattern:  snd . head -> maxZeroAt
    Use -XViewPatterns to enable view patterns

IpAddress.hs:37:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude> :r
[1 of 1] Compiling Main             ( IpAddress.hs, interpreted )

IpAddress.hs:35:46: Not in scope: `go'

IpAddress.hs:38:143: Not in scope: `on'
Failed, modules loaded: none.
Prelude>
Prelude> let maxZeroSeq parts =
ghc.exe: panic! (the 'impossible' happened)
  (GHC version 7.0.3 for i386-unknown-mingw32):
        thread blocked indefinitely in an MVar operation

Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug