Skip to content

Instantly share code, notes, and snippets.

@gksato
Last active June 21, 2020 08:58
Show Gist options
  • Save gksato/157a98da55c643f15760720383419b4b to your computer and use it in GitHub Desktop.
Save gksato/157a98da55c643f15760720383419b4b to your computer and use it in GitHub Desktop.
The optimization results of two definitions of Data.Vector.Generic.length

Test of vector: Data.Vector.Generic.length revised (Simplified version)


Summary

This gist is here to record the result of a test I conducted in order to compare the optimization of versions of the function Data.Vector.Generic.length in vector. The test was conducted by compiling a simple program (Test.hs) with different revisions and checking the optimization result (-ddump-simpl). The versions compared are:


Test requisites

  • git
  • Haskell Stack

Test content

  1. Clone the repository. The working tree root is considered as the working directory:
    $ git clone https://github.com/gksato/vector.git
    $ cd vector
  2. Copy the content of this gist to a subfolder of vector. Say this folder is named test-length2.
  3. Move stack.yaml upward:
    $ mv test-length2/stack.yaml ./stack.yaml
  4. checkout any of the revisions:
    # For the old version:
    $ git checkout eeb42ad42aa345ce192086baed80c805bcfc3e72
    # For the new version:
    $ git checkout 50c0ff0ac24c7d39c1d7c69c8311316187fb766c
  5. Compile the test:
    $ stack build vector:lib && stack ghc -- -ddump-simpl -ddump-to-file -O2 test-length2/Test.hs
    
  6. You get the optimization result in Test.dump-simpl.

changelog

  • 04-Jun-2020 Gist created
  • 21-Jun-2020 Updated the revision hash (Reworded the TestAfter commit)
# This file was automatically generated by 'stack init'
#
# Some commonly used options have been documented as comments in this file.
# For advanced use and comprehensive documentation of the format, please see:
# https://docs.haskellstack.org/en/stable/yaml_configuration/
# Resolver to choose a 'specific' stackage snapshot or a compiler version.
# A snapshot resolver dictates the compiler version and the set of packages
# to be used for project dependencies. For example:
#
# resolver: lts-3.5
# resolver: nightly-2015-09-21
# resolver: ghc-7.10.2
#
# The location of a snapshot can be provided as a file or url. Stack assumes
# a snapshot provided as a file might change, whereas a url resource does not.
#
# resolver: ./custom-snapshot.yaml
# resolver: https://example.com/snapshots/2018-01-01.yaml
resolver: lts-15.15
# User packages to be built.
# Various formats can be used as shown in the example below.
#
# packages:
# - some-directory
# - https://example.com/foo/bar/baz-0.0.2.tar.gz
# subdirs:
# - auto-update
# - wai
packages:
- .
- benchmarks
# Dependency packages to be pulled from upstream that are not in the resolver.
# These entries can reference officially published versions as well as
# forks / in-progress versions pinned to a git hash. For example:
#
# extra-deps:
# - acme-missiles-0.3
# - git: https://github.com/commercialhaskell/stack.git
# commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a
#
# extra-deps: []
# Override default flag values for local packages and extra-deps
# flags: {}
# Extra package databases containing global packages
# extra-package-dbs: []
# Control whether we use the GHC we find on the path
# system-ghc: true
#
# Require a specific version of stack, using version ranges
# require-stack-version: -any # Default
# require-stack-version: ">=2.3"
#
# Override the architecture used by stack, especially useful on Windows
# arch: i386
# arch: x86_64
#
# Extra directories used by stack for building
# extra-include-dirs: [/path/to/dir]
# extra-lib-dirs: [/path/to/dir]
#
# Allow a newer minor version of GHC than the snapshot specifies
# compiler-check: newer-minor
import qualified Data.Vector.Unboxed as VU
x :: Int
x = VU.length
$ VU.filter (==1)
$ VU.takeWhile (<40)
$ VU.generate (maxBound `div` 16) id
main :: IO ()
main = x `seq` return ()
==================== Tidy Core ====================
2020-06-03 22:29:49.847005 UTC
Result size of Tidy Core
= {terms: 59, types: 75, coercions: 9, joins: 3/3}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule4 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule4 = "main"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule3 :: GHC.Types.TrName
[GblId,
Caf=NoCafRefs,
Str=m1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule3 = GHC.Types.TrNameS Main.$trModule4
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule2 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule2 = "Main"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule1 :: GHC.Types.TrName
[GblId,
Caf=NoCafRefs,
Str=m1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule1 = GHC.Types.TrNameS Main.$trModule2
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$trModule :: GHC.Types.Module
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
Main.$trModule = GHC.Types.Module Main.$trModule3 Main.$trModule1
-- RHS size: {terms: 37, types: 45, coercions: 0, joins: 3/3}
Main.main1
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 79 0}]
Main.main1
= \ (eta_B1 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
join {
exit_Xq [Dmd=<L,U(U,U)>]
:: (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[LclId[JoinId(0)]]
exit_Xq = (# eta_B1, GHC.Tuple.() #) } in
join {
exit1_Xs [Dmd=<L,U(U,U)>]
:: (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[LclId[JoinId(0)]]
exit1_Xs = (# eta_B1, GHC.Tuple.() #) } in
joinrec {
$s$wfoldlM'_loop_s7tg [Occ=LoopBreaker]
:: GHC.Prim.Int# -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[LclId[JoinId(1)], Arity=1, Str=<L,U>, Unf=OtherCon []]
$s$wfoldlM'_loop_s7tg (sc_s7tf :: GHC.Prim.Int#)
= case GHC.Prim.<# sc_s7tf 576460752303423487# of {
__DEFAULT -> jump exit_Xq;
1# ->
case GHC.Prim.<# sc_s7tf 40# of {
__DEFAULT -> jump exit1_Xs;
1# ->
case sc_s7tf of wild_X1c {
__DEFAULT -> jump $s$wfoldlM'_loop_s7tg (GHC.Prim.+# wild_X1c 1#);
1# -> jump $s$wfoldlM'_loop_s7tg 2#
}
}
}; } in
jump $s$wfoldlM'_loop_s7tg 0#
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
main :: IO ()
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
Tmpl= Main.main1
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())}]
main
= Main.main1
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())
-- RHS size: {terms: 2, types: 1, coercions: 3, joins: 0/0}
Main.main2
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.main2
= GHC.TopHandler.runMainIO1
@ ()
(Main.main1
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ()))
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
:Main.main :: IO ()
[GblId,
Arity=1,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
Tmpl= Main.main2
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())}]
:Main.main
= Main.main2
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())
==================== Tidy Core ====================
2020-06-03 22:34:43.203823 UTC
Result size of Tidy Core
= {terms: 105, types: 195, coercions: 121, joins: 1/1}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule4 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule4 = "main"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule3 :: GHC.Types.TrName
[GblId,
Caf=NoCafRefs,
Str=m1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule3 = GHC.Types.TrNameS Main.$trModule4
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule2 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule2 = "Main"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule1 :: GHC.Types.TrName
[GblId,
Caf=NoCafRefs,
Str=m1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule1 = GHC.Types.TrNameS Main.$trModule2
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$trModule :: GHC.Types.Module
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
Main.$trModule = GHC.Types.Module Main.$trModule3 Main.$trModule1
-- RHS size: {terms: 71, types: 107, coercions: 109, joins: 1/1}
Main.main2
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, VU.Vector Int #)
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 122 0}]
Main.main2
= \ (s1_i4CI [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Prim.newByteArray#
@ (Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))
4611686018427387896#
(s1_i4CI
`cast` ((GHC.Prim.State#
(Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
(Nth:0
(Nth:2
(<GHC.Prim.State# GHC.Prim.RealWorld>_R
->_R ((#,#)
<'GHC.Types.TupleRep '[]>_R
<'GHC.Types.LiftedRep>_R
<GHC.Prim.State# GHC.Prim.RealWorld>_R
(Data.Vector.Generic.Base.Mutable
<VU.Vector>_N
(Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N)
<Int>_N)_R)_R))))))_R
:: GHC.Prim.State# GHC.Prim.RealWorld
~R# GHC.Prim.State#
(Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))))
of
{ (# ipv_i7F8, ipv1_i7F9 #) ->
joinrec {
$s$wfoldlM'_loop_sa6P [Occ=LoopBreaker]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> (# GHC.Prim.State# GHC.Prim.RealWorld, VU.Vector Int #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><L,U><L,U>, Unf=OtherCon []]
$s$wfoldlM'_loop_sa6P (sc_sa6O
:: GHC.Prim.State# GHC.Prim.RealWorld)
(sc1_sa6M :: GHC.Prim.Int#)
(sc2_sa6L :: GHC.Prim.Int#)
= case GHC.Prim.<# sc1_sa6M 576460752303423487# of {
__DEFAULT ->
case GHC.Prim.unsafeFreezeByteArray#
@ (Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))
ipv1_i7F9
(sc_sa6O
`cast` ((GHC.Prim.State#
(Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
(Nth:0
(Nth:2
(Nth:3
(<GHC.Prim.State# GHC.Prim.RealWorld>_R
->_R ((#,#)
<'GHC.Types.TupleRep '[]>_R
<'GHC.Types.LiftedRep>_R
<GHC.Prim.State#
GHC.Prim.RealWorld>_R
(Data.Vector.Generic.Base.Mutable
<VU.Vector>_N
(Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N))
<Int>_N)_R)_R)))))))_R
:: GHC.Prim.State# GHC.Prim.RealWorld
~R# GHC.Prim.State#
(Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))))
of
{ (# ipv2_i7D5, ipv3_i7D6 #) ->
(# ipv2_i7D5
`cast` ((GHC.Prim.State#
(Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N))_R
:: GHC.Prim.State#
(Control.Monad.Primitive.PrimState (GHC.ST.ST GHC.Prim.RealWorld))
~R# GHC.Prim.State# GHC.Prim.RealWorld),
(Data.Vector.Primitive.Vector @ Int 0# sc2_sa6L ipv3_i7D6)
`cast` (Sym (Data.Vector.Unboxed.Base.N:R:VectorInt[0]) ; Sym (Data.Vector.Unboxed.Base.D:R:VectorInt0[0])
:: Data.Vector.Primitive.Vector Int ~R# VU.Vector Int) #)
};
1# ->
case GHC.Prim.<# sc1_sa6M 40# of {
__DEFAULT ->
case GHC.Prim.unsafeFreezeByteArray#
@ (Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))
ipv1_i7F9
(sc_sa6O
`cast` ((GHC.Prim.State#
(Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
(Nth:0
(Nth:2
(Nth:3
(<GHC.Prim.State#
GHC.Prim.RealWorld>_R
->_R ((#,#)
<'GHC.Types.TupleRep '[]>_R
<'GHC.Types.LiftedRep>_R
<GHC.Prim.State#
GHC.Prim.RealWorld>_R
(Data.Vector.Generic.Base.Mutable
<VU.Vector>_N
(Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N))
<Int>_N)_R)_R)))))))_R
:: GHC.Prim.State# GHC.Prim.RealWorld
~R# GHC.Prim.State#
(Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))))
of
{ (# ipv2_i7D5, ipv3_i7D6 #) ->
(# ipv2_i7D5
`cast` ((GHC.Prim.State#
(Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N))_R
:: GHC.Prim.State#
(Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))
~R# GHC.Prim.State# GHC.Prim.RealWorld),
(Data.Vector.Primitive.Vector @ Int 0# sc2_sa6L ipv3_i7D6)
`cast` (Sym (Data.Vector.Unboxed.Base.N:R:VectorInt[0]) ; Sym (Data.Vector.Unboxed.Base.D:R:VectorInt0[0])
:: Data.Vector.Primitive.Vector Int ~R# VU.Vector Int) #)
};
1# ->
case sc1_sa6M of wild_X1y {
__DEFAULT ->
jump $s$wfoldlM'_loop_sa6P
sc_sa6O (GHC.Prim.+# wild_X1y 1#) sc2_sa6L;
1# ->
case GHC.Prim.writeIntArray#
@ (Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))
ipv1_i7F9
sc2_sa6L
1#
(sc_sa6O
`cast` ((GHC.Prim.State#
(Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N)))_R
:: GHC.Prim.State# GHC.Prim.RealWorld
~R# GHC.Prim.State#
(Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))))
of s'#_i8vO
{ __DEFAULT ->
jump $s$wfoldlM'_loop_sa6P
(s'#_i8vO
`cast` ((GHC.Prim.State#
(Control.Monad.Primitive.D:R:PrimStateST[0]
<GHC.Prim.RealWorld>_N))_R
:: GHC.Prim.State#
(Control.Monad.Primitive.PrimState
(GHC.ST.ST GHC.Prim.RealWorld))
~R# GHC.Prim.State# GHC.Prim.RealWorld))
2#
(GHC.Prim.+# sc2_sa6L 1#)
}
}
}
}; } in
jump $s$wfoldlM'_loop_sa6P
(ipv_i7F8
`cast` ((GHC.Prim.State#
(Control.Monad.Primitive.D:R:PrimStateST[0]
(Nth:0
(Nth:2
(Nth:3
(<GHC.Prim.State# GHC.Prim.RealWorld>_R
->_R ((#,#)
<'GHC.Types.TupleRep '[]>_R
<'GHC.Types.LiftedRep>_R
<GHC.Prim.State# GHC.Prim.RealWorld>_R
(Sub (Sym (Data.Vector.Unboxed.Base.D:R:MutableVector[0])) <Control.Monad.Primitive.PrimState
(GHC.ST.ST
GHC.Prim.RealWorld)>_N <Int>_N))_R))))))_R
:: GHC.Prim.State#
(Control.Monad.Primitive.PrimState (GHC.ST.ST GHC.Prim.RealWorld))
~R# GHC.Prim.State# GHC.Prim.RealWorld))
0#
0#
}
-- RHS size: {terms: 11, types: 47, coercions: 3, joins: 0/0}
Main.main1
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 40 30}]
Main.main1
= \ (eta_B1 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Magic.runRW#
@ ('GHC.Types.TupleRep
'[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep])
@ (# GHC.Prim.State# GHC.Prim.RealWorld, VU.Vector Int #)
Main.main2
of
{ (# ipv1_i4F3, ipv2_i4F4 #) ->
case ipv2_i4F4
`cast` (Data.Vector.Unboxed.Base.D:R:VectorInt0[0] ; Data.Vector.Unboxed.Base.N:R:VectorInt[0]
:: VU.Vector Int ~R# Data.Vector.Primitive.Vector Int)
of
{ Data.Vector.Primitive.Vector ipv_s8ei ipv4_s8ej ipv5_s8ek ->
(# eta_B1, GHC.Tuple.() #)
}
}
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
main :: IO ()
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
Tmpl= Main.main1
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())}]
main
= Main.main1
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())
-- RHS size: {terms: 2, types: 1, coercions: 3, joins: 0/0}
Main.main3
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.main3
= GHC.TopHandler.runMainIO1
@ ()
(Main.main1
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ()))
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
:Main.main :: IO ()
[GblId,
Arity=1,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
Tmpl= Main.main3
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())}]
:Main.main
= Main.main3
`cast` (Sym (GHC.Types.N:IO[0] <()>_R)
:: (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# IO ())
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment