Re: Change return type for Int64# and Word64# comparisons?
for me personally Bool would be even better To get a Bool you can use wrappers defined in the same module, e.g.: geInt64# :: Int64# - Int64# - Bool geInt64# a b = tagToEnum# (int64ToInt# (geInt64## a b)) Looking at the implementation of this wrapper I think Luite has a point - to get a Bool it has to be caste to a machine supported Int#. So I think that it would make sense to have these primops retunr Int# instead of Int64#, but I'd like to hear what others have to say. Janek - Oryginalna wiadomość - Od: Luite Stegeman stege...@gmail.com Do: ghc-devs ghc-devs@haskell.org Wysłane: czwartek, 15 sierpień 2013 16:36:59 Temat: Change return type for Int64# and Word64# comparisons? Hi all, With the recent change of comparison primops to return Int# instead of Bool, the 64 bit operations were also changed, to return Int64# or Word64#: https://github.com/jstolarek/packages-ghc-prim/commit/07920f03d76dbaec64e3829404d332af22d744fe It seems a bit wasteful to me to return a value bigger than a machine word for just a boolean. Changing the type to Int# would make the same optimizations possible as for the native-sized primops (though since they map to JavaScript bools in GHCJS). thoughts? luite ___ ghc-devs mailing list ghc-devs@haskell.org http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.org http://www.haskell.org/mailman/listinfo/ghc-devs
Re: Change return type for Int64# and Word64# comparisons?
Please use native size. Eg Int# and/or Word# Booleans should always always be a size that fits in native registers. (If there's good reasons to the contrary, I'd love to hear them) Thanks Luite for noticing this! On Thursday, August 15, 2013, Jan Stolarek wrote: for me personally Bool would be even better To get a Bool you can use wrappers defined in the same module, e.g.: geInt64# :: Int64# - Int64# - Bool geInt64# a b = tagToEnum# (int64ToInt# (geInt64## a b)) Looking at the implementation of this wrapper I think Luite has a point - to get a Bool it has to be caste to a machine supported Int#. So I think that it would make sense to have these primops retunr Int# instead of Int64#, but I'd like to hear what others have to say. Janek - Oryginalna wiadomość - Od: Luite Stegeman stege...@gmail.com javascript:; Do: ghc-devs ghc-devs@haskell.org javascript:; Wysłane: czwartek, 15 sierpień 2013 16:36:59 Temat: Change return type for Int64# and Word64# comparisons? Hi all, With the recent change of comparison primops to return Int# instead of Bool, the 64 bit operations were also changed, to return Int64# or Word64#: https://github.com/jstolarek/packages-ghc-prim/commit/07920f03d76dbaec64e3829404d332af22d744fe It seems a bit wasteful to me to return a value bigger than a machine word for just a boolean. Changing the type to Int# would make the same optimizations possible as for the native-sized primops (though since they map to JavaScript bools in GHCJS). thoughts? luite ___ ghc-devs mailing list ghc-devs@haskell.org javascript:; http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.org javascript:; http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.org http://www.haskell.org/mailman/listinfo/ghc-devs
RE: Change return type for Int64# and Word64# comparisons?
Yes I agree: native Int#! Simon From: ghc-devs [mailto:ghc-devs-boun...@haskell.org] On Behalf Of Carter Schonwald Sent: 15 August 2013 17:43 To: Jan Stolarek Cc: ghc-devs Subject: Re: Change return type for Int64# and Word64# comparisons? Please use native size. Eg Int# and/or Word# Booleans should always always be a size that fits in native registers. (If there's good reasons to the contrary, I'd love to hear them) Thanks Luite for noticing this! On Thursday, August 15, 2013, Jan Stolarek wrote: for me personally Bool would be even better To get a Bool you can use wrappers defined in the same module, e.g.: geInt64# :: Int64# - Int64# - Bool geInt64# a b = tagToEnum# (int64ToInt# (geInt64## a b)) Looking at the implementation of this wrapper I think Luite has a point - to get a Bool it has to be caste to a machine supported Int#. So I think that it would make sense to have these primops retunr Int# instead of Int64#, but I'd like to hear what others have to say. Janek - Oryginalna wiadomość - Od: Luite Stegeman stege...@gmail.comjavascript:; Do: ghc-devs ghc-devs@haskell.orgjavascript:; Wysłane: czwartek, 15 sierpień 2013 16:36:59 Temat: Change return type for Int64# and Word64# comparisons? Hi all, With the recent change of comparison primops to return Int# instead of Bool, the 64 bit operations were also changed, to return Int64# or Word64#: https://github.com/jstolarek/packages-ghc-prim/commit/07920f03d76dbaec64e3829404d332af22d744fe It seems a bit wasteful to me to return a value bigger than a machine word for just a boolean. Changing the type to Int# would make the same optimizations possible as for the native-sized primops (though since they map to JavaScript bools in GHCJS). thoughts? luite ___ ghc-devs mailing list ghc-devs@haskell.orgjavascript:; http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.orgjavascript:; http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.org http://www.haskell.org/mailman/listinfo/ghc-devs
Re: Change return type for Int64# and Word64# comparisons?
OK, will fix that ASAP. Janek Dnia czwartek, 15 sierpnia 2013, Simon Peyton-Jones napisał: Yes I agree: native Int#! Simon From: ghc-devs [mailto:ghc-devs-boun...@haskell.org] On Behalf Of Carter Schonwald Sent: 15 August 2013 17:43 To: Jan Stolarek Cc: ghc-devs Subject: Re: Change return type for Int64# and Word64# comparisons? Please use native size. Eg Int# and/or Word# Booleans should always always be a size that fits in native registers. (If there's good reasons to the contrary, I'd love to hear them) Thanks Luite for noticing this! On Thursday, August 15, 2013, Jan Stolarek wrote: for me personally Bool would be even better To get a Bool you can use wrappers defined in the same module, e.g.: geInt64# :: Int64# - Int64# - Bool geInt64# a b = tagToEnum# (int64ToInt# (geInt64## a b)) Looking at the implementation of this wrapper I think Luite has a point - to get a Bool it has to be caste to a machine supported Int#. So I think that it would make sense to have these primops retunr Int# instead of Int64#, but I'd like to hear what others have to say. Janek - Oryginalna wiadomość - Od: Luite Stegeman stege...@gmail.comjavascript:; Do: ghc-devs ghc-devs@haskell.orgjavascript:; Wysłane: czwartek, 15 sierpień 2013 16:36:59 Temat: Change return type for Int64# and Word64# comparisons? Hi all, With the recent change of comparison primops to return Int# instead of Bool, the 64 bit operations were also changed, to return Int64# or Word64#: https://github.com/jstolarek/packages-ghc-prim/commit/07920f03d76dbaec64e38 29404d332af22d744fe It seems a bit wasteful to me to return a value bigger than a machine word for just a boolean. Changing the type to Int# would make the same optimizations possible as for the native-sized primops (though since they map to JavaScript bools in GHCJS). thoughts? luite ___ ghc-devs mailing list ghc-devs@haskell.orgjavascript:; http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.orgjavascript:; http://www.haskell.org/mailman/listinfo/ghc-devs ___ ghc-devs mailing list ghc-devs@haskell.org http://www.haskell.org/mailman/listinfo/ghc-devs
