search

valderman / haste-compiler

A GHC-based Haskell to JavaScript compiler
http://haste-lang.org
BSD 3-Clause "New" or "Revised" License
1.45k stars 109 forks source link

haste-inst fails with error code 1 #200

Closed jonathanknowles closed 10 years ago

jonathanknowles commented 10 years ago

Environment

$ which cabal
/home/jsk/.cabal/bin/cabal
$ cabal --version
cabal-install version 1.20.0.3
using version 1.20.0.0 of the Cabal library 
$ which ghc
/usr/local/bin/ghc
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.8.2
$ uname -a
Linux helium 3.13.0-29-generic #53-Ubuntu SMP Wed Jun 4 21:00:20 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux

Reproduction steps

$ mkdir haskell-haste
$ cd haskell-haste
$ cabal sandbox init
$ cabal install haste-compiler
$ cabal info haste-compiler
* haste-compiler   (programs and library)
    Synopsis:      Haskell To ECMAScript compiler
    Versions available: 0.2.5, 0.2.6, 0.2.7, 0.2.8, 0.2.9, 0.2.10, 0.2.11,
                        0.2.99, 0.3 (and 5 others)
    Versions installed: 0.3
    Homepage:      http://github.com/valderman/haste-compiler
    Bug reports:   http://github.com/valderman/haste-compiler/issues
    Description:   This package provides a featureful compiler from Haskell to
                   Javascript. It generates small, fast code, makes use of
                   standard Haskell libraries, integrates with Cabal, supports
                   most GHC extensions and works on Windows, Linux and OSX. Bug
                   reports are highly appreciated.
    Category:      Javascript, Compiler, Web
    License:       BSD3
    Author:        Anton Ekblad <anton@ekblad.cc>
    Maintainer:    anton@ekblad.cc
    Source repo:   https://github.com/valderman/haste-compiler.git
    Executables:   haste-boot, hastec, haste-inst, haste-pkg, haste-install-his,
                   haste-copy-pkg
    Flags:         portable, portable-compiler
    Dependencies:  integer-gmp -any, transformers -any, monads-tf -any,
                   ghc-prim -any, containers -any, base <5, array -any,
                   random -any, binary -any, data-binary-ieee754 -any,
                   bytestring >=0.9.2.1, websockets >=0.8, utf8-string -any,
                   shellmate >=0.1.5, data-default -any, directory -any,
                   executable-path -any, filepath -any, process -any,
                   shellmate >=0.1.5, executable-path -any, transformers -any,
                   time -any, temporary -any, process -any, directory -any,
                   filepath -any, base <5, executable-path -any, process -any,
                   directory -any, filepath -any, base <5, executable-path -any,
                   directory -any, filepath -any, process -any, base <5,
                   executable-path -any, directory -any, process -any,
                   filepath -any, base <5, shellmate >=0.1.5,
                   executable-path -any, system-fileio -any, random -any,
                   process -any, ghc-paths -any, array -any, directory -any,
                   filepath -any, blaze-builder -any, bytestring >=0.9.2.1,
                   data-default -any, containers -any, binary -any, mtl -any,
                   ghc >=7.4, ghc-prim -any, base <5, shellmate >=0.1.5,
                   executable-path -any, HTTP -any, network -any,
                   transformers -any, time -any, temporary -any, filepath -any,
                   zip-archive -any, bzlib -any, tar -any, bytestring -any,
                   process -any, directory -any, base <5, ghc -any
    Documentation: [ Not installed ]
    Cached:        Yes
    Modules:
        Haste
        Haste.Ajax
        Haste.App
        Haste.App.Concurrent
        Haste.Binary
        Haste.Compiler
        Haste.Concurrent
        Haste.DOM
        Haste.Foreign
        Haste.Graphics.Canvas
        Haste.JSON
        Haste.LocalStorage
        Haste.Parsing
        Haste.Prim
        Haste.Serialize
        Haste.WebSockets

$ haste-boot

Reading package info from "libraries/rts.pkg" ... done.
Resolving dependencies...
Configuring ghc-prim-0.3.0.0...
Building ghc-prim-0.3.0.0...
Preprocessing library ghc-prim-0.3.0.0...
hastec: setNumCapabilities: not supported in the non-threaded RTS

GHC/CString.hs:46:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `eqChar#` '\NUL'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `eqChar#` '\NUL'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = []
          | True = C# ch : unpack (nh +# 1#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:58:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `eqChar#` '\NUL'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `eqChar#` '\NUL'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = rest
          | True = C# ch : unpack (nh +# 1#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:83:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `eqChar#` '\NUL'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `eqChar#` '\NUL'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = z
          | True = C# ch `f` unpack (nh +# 1#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:93:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `eqChar#` '\NUL'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `eqChar#` '\NUL'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = []
          | ch `leChar#` '\DEL'# = C# ch : unpack (nh +# 1#)
          | ch `leChar#` '\223'#
          = C#
              (chr#
                 (((ord# ch -# 192#) `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)))
            : unpack (nh +# 2#)
          | ch `leChar#` '\239'#
          = C#
              (chr#
                 (((ord# ch -# 224#) `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)))
            : unpack (nh +# 3#)
          | True
          = C#
              (chr#
                 (((ord# ch -# 240#) `uncheckedIShiftL#` 18#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 128#)))
            : unpack (nh +# 4#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:94:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `leChar#` '\DEL'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `leChar#` '\DEL'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = []
          | ch `leChar#` '\DEL'# = C# ch : unpack (nh +# 1#)
          | ch `leChar#` '\223'#
          = C#
              (chr#
                 (((ord# ch -# 192#) `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)))
            : unpack (nh +# 2#)
          | ch `leChar#` '\239'#
          = C#
              (chr#
                 (((ord# ch -# 224#) `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)))
            : unpack (nh +# 3#)
          | True
          = C#
              (chr#
                 (((ord# ch -# 240#) `uncheckedIShiftL#` 18#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 128#)))
            : unpack (nh +# 4#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:95:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `leChar#` '\223'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `leChar#` '\223'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = []
          | ch `leChar#` '\DEL'# = C# ch : unpack (nh +# 1#)
          | ch `leChar#` '\223'#
          = C#
              (chr#
                 (((ord# ch -# 192#) `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)))
            : unpack (nh +# 2#)
          | ch `leChar#` '\239'#
          = C#
              (chr#
                 (((ord# ch -# 224#) `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)))
            : unpack (nh +# 3#)
          | True
          = C#
              (chr#
                 (((ord# ch -# 240#) `uncheckedIShiftL#` 18#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 128#)))
            : unpack (nh +# 4#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:99:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: ch `leChar#` '\239'#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      ch `leChar#` '\239'#
    In an equation for ‘unpack’:
        unpack nh
          | ch `eqChar#` '\NUL'# = []
          | ch `leChar#` '\DEL'# = C# ch : unpack (nh +# 1#)
          | ch `leChar#` '\223'#
          = C#
              (chr#
                 (((ord# ch -# 192#) `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)))
            : unpack (nh +# 2#)
          | ch `leChar#` '\239'#
          = C#
              (chr#
                 (((ord# ch -# 224#) `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)))
            : unpack (nh +# 3#)
          | True
          = C#
              (chr#
                 (((ord# ch -# 240#) `uncheckedIShiftL#` 18#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 128#)
                     `uncheckedIShiftL#` 12#)
                  +#
                    ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 128#)
                     `uncheckedIShiftL#` 6#)
                  +# (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 128#)))
            : unpack (nh +# 4#)
          where
              !ch = indexCharOffAddr# addr nh

GHC/CString.hs:118:9:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: i# <# 0#
    In a stmt of a pattern guard for
                   an equation for ‘unpack’:
      i# <# 0#
    In an equation for ‘unpack’:
        unpack acc i#
          | i# <# 0# = acc
          | True
          = case indexCharOffAddr# addr i# of {
              ch -> unpack (C# ch : acc) (i# -# 1#) }

GHC/Classes.hs:96:26:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: c1 `eqChar#` c2
    In an equation for ‘==’: (C# c1) == (C# c2) = c1 `eqChar#` c2
    In the instance declaration for ‘Eq Char’

GHC/Classes.hs:97:26:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: c1 `neChar#` c2
    In an equation for ‘/=’: (C# c1) /= (C# c2) = c1 `neChar#` c2
    In the instance declaration for ‘Eq Char’

GHC/Classes.hs:100:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `eqFloat#` y
    In an equation for ‘==’: (F# x) == (F# y) = x `eqFloat#` y
    In the instance declaration for ‘Eq Float’

GHC/Classes.hs:103:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x ==## y
    In an equation for ‘==’: (D# x) == (D# y) = x ==## y
    In the instance declaration for ‘Eq Double’

GHC/Classes.hs:112:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x ==# y
    In an equation for ‘eqInt’: (I# x) `eqInt` (I# y) = x ==# y

GHC/Classes.hs:113:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x /=# y
    In an equation for ‘neInt’: (I# x) `neInt` (I# y) = x /=# y

GHC/Classes.hs:199:26:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: c1 `gtChar#` c2
    In an equation for ‘>’: (C# c1) > (C# c2) = c1 `gtChar#` c2
    In the instance declaration for ‘Ord Char’

GHC/Classes.hs:200:26:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: c1 `geChar#` c2
    In an equation for ‘>=’: (C# c1) >= (C# c2) = c1 `geChar#` c2
    In the instance declaration for ‘Ord Char’

GHC/Classes.hs:201:26:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: c1 `leChar#` c2
    In an equation for ‘<=’: (C# c1) <= (C# c2) = c1 `leChar#` c2
    In the instance declaration for ‘Ord Char’

GHC/Classes.hs:202:26:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: c1 `ltChar#` c2
    In an equation for ‘<’: (C# c1) < (C# c2) = c1 `ltChar#` c2
    In the instance declaration for ‘Ord Char’

GHC/Classes.hs:206:19:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `ltFloat#` y
    In the expression:
      if x `ltFloat#` y then LT else if x `eqFloat#` y then EQ else GT
    In an equation for ‘compare’:
        (F# x) `compare` (F# y)
          = if x `ltFloat#` y then LT else if x `eqFloat#` y then EQ else GT

GHC/Classes.hs:207:19:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `eqFloat#` y
    In the expression: if x `eqFloat#` y then EQ else GT
    In the expression:
      if x `ltFloat#` y then LT else if x `eqFloat#` y then EQ else GT

GHC/Classes.hs:210:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `ltFloat#` y
    In an equation for ‘<’: (F# x) < (F# y) = x `ltFloat#` y
    In the instance declaration for ‘Ord Float’

GHC/Classes.hs:211:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `leFloat#` y
    In an equation for ‘<=’: (F# x) <= (F# y) = x `leFloat#` y
    In the instance declaration for ‘Ord Float’

GHC/Classes.hs:212:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `geFloat#` y
    In an equation for ‘>=’: (F# x) >= (F# y) = x `geFloat#` y
    In the instance declaration for ‘Ord Float’

GHC/Classes.hs:213:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x `gtFloat#` y
    In an equation for ‘>’: (F# x) > (F# y) = x `gtFloat#` y
    In the instance declaration for ‘Ord Float’

GHC/Classes.hs:217:19:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x <## y
    In the expression:
      if x <## y then LT else if x ==## y then EQ else GT
    In an equation for ‘compare’:
        (D# x) `compare` (D# y)
          = if x <## y then LT else if x ==## y then EQ else GT

GHC/Classes.hs:218:19:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x ==## y
    In the expression: if x ==## y then EQ else GT
    In the expression:
      if x <## y then LT else if x ==## y then EQ else GT

GHC/Classes.hs:221:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x <## y
    In an equation for ‘<’: (D# x) < (D# y) = x <## y
    In the instance declaration for ‘Ord Double’

GHC/Classes.hs:222:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x <=## y
    In an equation for ‘<=’: (D# x) <= (D# y) = x <=## y
    In the instance declaration for ‘Ord Double’

GHC/Classes.hs:223:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x >=## y
    In an equation for ‘>=’: (D# x) >= (D# y) = x >=## y
    In the instance declaration for ‘Ord Double’

GHC/Classes.hs:224:24:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x >## y
    In an equation for ‘>’: (D# x) > (D# y) = x >## y
    In the instance declaration for ‘Ord Double’

GHC/Classes.hs:238:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x ># y
    In an equation for ‘gtInt’: (I# x) `gtInt` (I# y) = x ># y

GHC/Classes.hs:239:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x >=# y
    In an equation for ‘geInt’: (I# x) `geInt` (I# y) = x >=# y

GHC/Classes.hs:240:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x <# y
    In an equation for ‘ltInt’: (I# x) `ltInt` (I# y) = x <# y

GHC/Classes.hs:241:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x <=# y
    In an equation for ‘leInt’: (I# x) `leInt` (I# y) = x <=# y

GHC/Classes.hs:248:7:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x# <# y#
    In a stmt of a pattern guard for
                   an equation for ‘compareInt#’:
      x# <# y#
    In an equation for ‘compareInt#’:
        compareInt# x# y#
          | x# <# y# = LT
          | x# ==# y# = EQ
          | True = GT

GHC/Classes.hs:249:7:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: x# ==# y#
    In a stmt of a pattern guard for
                   an equation for ‘compareInt#’:
      x# ==# y#
    In an equation for ‘compareInt#’:
        compareInt# x# y#
          | x# <# y# = LT
          | x# ==# y# = EQ
          | True = GT

GHC/Classes.hs:283:16:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the first argument of ‘(&&)’, namely ‘(x# ># 0#)’
    In the expression: (x# ># 0#) && (y# <# 0#)
    In the expression:
      if (x# ># 0#) && (y# <# 0#) then
          ((x# -# 1#) `quotInt#` y#) -# 1#
      else
          if (x# <# 0#) && (y# ># 0#) then
              ((x# +# 1#) `quotInt#` y#) -# 1#
          else
              x# `quotInt#` y#

GHC/Classes.hs:283:30:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the second argument of ‘(&&)’, namely ‘(y# <# 0#)’
    In the expression: (x# ># 0#) && (y# <# 0#)
    In the expression:
      if (x# ># 0#) && (y# <# 0#) then
          ((x# -# 1#) `quotInt#` y#) -# 1#
      else
          if (x# <# 0#) && (y# ># 0#) then
              ((x# +# 1#) `quotInt#` y#) -# 1#
          else
              x# `quotInt#` y#

GHC/Classes.hs:284:16:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the first argument of ‘(&&)’, namely ‘(x# <# 0#)’
    In the expression: (x# <# 0#) && (y# ># 0#)
    In the expression:
      if (x# <# 0#) && (y# ># 0#) then
          ((x# +# 1#) `quotInt#` y#) -# 1#
      else
          x# `quotInt#` y#

GHC/Classes.hs:284:30:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the second argument of ‘(&&)’, namely ‘(y# ># 0#)’
    In the expression: (x# <# 0#) && (y# ># 0#)
    In the expression:
      if (x# <# 0#) && (y# ># 0#) then
          ((x# +# 1#) `quotInt#` y#) -# 1#
      else
          x# `quotInt#` y#

GHC/Classes.hs:289:11:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the first argument of ‘(&&)’, namely ‘(x# ># 0#)’
    In the first argument of ‘(||)’, namely ‘(x# ># 0#) && (y# <# 0#)’
    In the expression:
      (x# ># 0#) && (y# <# 0#) || (x# <# 0#) && (y# ># 0#)

GHC/Classes.hs:289:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the second argument of ‘(&&)’, namely ‘(y# <# 0#)’
    In the first argument of ‘(||)’, namely ‘(x# ># 0#) && (y# <# 0#)’
    In the expression:
      (x# ># 0#) && (y# <# 0#) || (x# <# 0#) && (y# ># 0#)

GHC/Classes.hs:290:11:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the first argument of ‘(&&)’, namely ‘(x# <# 0#)’
    In the second argument of ‘(||)’, namely ‘(x# <# 0#) && (y# ># 0#)’
    In the expression:
      (x# ># 0#) && (y# <# 0#) || (x# <# 0#) && (y# ># 0#)

GHC/Classes.hs:290:25:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the second argument of ‘(&&)’, namely ‘(y# ># 0#)’
    In the second argument of ‘(||)’, namely ‘(x# <# 0#) && (y# ># 0#)’
    In the expression:
      (x# ># 0#) && (y# <# 0#) || (x# <# 0#) && (y# ># 0#)

GHC/Classes.hs:291:15:
    Couldn't match expected type ‘Bool’ with actual type ‘Int#’
    In the expression: r# /=# 0#
    In the expression: if r# /=# 0# then r# +# y# else 0#
    In the expression:
      if (x# ># 0#) && (y# <# 0#) || (x# <# 0#) && (y# ># 0#) then
          if r# /=# 0# then r# +# y# else 0#
      else
          r#
Downloading base libs from GitHub
Sending:
GET /haste-libs/haste-libs-0.3.tar.bz2 HTTP/1.1
Host: valderman.github.io

Creating new connection to valderman.github.io
Received:
HTTP/1.1 200 OK 
Server: GitHub.com
Content-Type: application/octet-stream
Last-Modified: Wed, 21 May 2014 13:36:11 GMT
Expires: Mon, 30 Jun 2014 08:36:40 GMT
Cache-Control: max-age=600
Content-Length: 484741
Accept-Ranges: bytes
Date: Mon, 30 Jun 2014 09:19:55 GMT
Via: 1.1 varnish
Age: 3196
Connection: keep-alive
X-Served-By: cache-hk93-HKG
X-Cache: HIT
X-Cache-Hits: 4
X-Timer: S1404119995.913240433,VS0,VE0
Vary: Accept-Encoding

Command '/home/jsk/private/projects/haskell-haste/.cabal-sandbox/bin/haste-inst' failed with error  code 1
jonathanknowles commented 10 years ago

Let me know if I can provide any further details about the environment. Cheers!

mavenraven commented 10 years ago

@jonathanknowles haste doesn't declare its "extra" dependencies in a way that cabal can see them. ghc prim changed how ># and <# work in 0.3.1.1, so the libraries that haste downloads outside of cabal need to be updated.

valderman commented 10 years ago

GHC 7.8 support isn't ready yet, unfortunately. Closing this as a duplicate of #173 to keep all the remaining 7.8 issues in the same thread.