├── .bazelrc ├── .github ├── settings.yml └── workflows │ ├── bazel.yaml │ ├── docs.yml │ └── shell.yml ├── .gitignore ├── BUILD ├── README.md ├── WORKSPACE ├── asterius ├── BUILD.bazel ├── CHANGELOG.md ├── LICENSE ├── README.md ├── app │ ├── Setup-ghc-prim.hs │ ├── ahc-cabal.hs │ ├── ahc-dist.hs │ ├── ahc-ld.hs │ ├── ahc-link.hs │ ├── fs.c │ ├── fs.h │ ├── genconstants.hs │ └── unlit.c ├── boot.sh ├── cabal │ └── config ├── ghc-bin-asterius │ ├── Main.hs │ ├── PosixSource.h │ └── hschooks.c ├── package.yaml ├── rts │ ├── browser │ │ ├── default.mjs │ │ ├── rts.fs.mjs │ │ └── rts.wasi.mjs │ ├── genunicode.hs │ ├── node │ │ ├── default.mjs │ │ ├── rts.fs.mjs │ │ └── rts.wasi.mjs │ ├── rts.autoapply.mjs │ ├── rts.closuretypes.mjs │ ├── rts.constants.mjs │ ├── rts.eventlog.mjs │ ├── rts.exception.mjs │ ├── rts.exports.mjs │ ├── rts.float.mjs │ ├── rts.funtypes.mjs │ ├── rts.gc.mjs │ ├── rts.heapalloc.mjs │ ├── rts.integer.mjs │ ├── rts.jsval.mjs │ ├── rts.memory.mjs │ ├── rts.memorytrap.mjs │ ├── rts.messages.mjs │ ├── rts.mjs │ ├── rts.modulify.mjs │ ├── rts.reentrancy.mjs │ ├── rts.scheduler.mjs │ ├── rts.setimmediate.mjs │ ├── rts.stablename.mjs │ ├── rts.stableptr.mjs │ ├── rts.symtable.mjs │ ├── rts.time.mjs │ ├── rts.tracing.mjs │ ├── rts.typecheck.mjs │ └── rts.unicode.mjs ├── src-types │ └── Asterius │ │ ├── Binary │ │ ├── Orphans.hs │ │ └── TH.hs │ │ ├── Monoid │ │ └── TH.hs │ │ ├── NFData │ │ └── TH.hs │ │ ├── Semigroup │ │ └── TH.hs │ │ ├── Types.hs │ │ └── Types │ │ ├── EntitySymbol.hs │ │ ├── SymbolMap.hs │ │ └── SymbolSet.hs ├── src │ ├── Asterius │ │ ├── Ar.hs │ │ ├── Backends │ │ │ ├── Binaryen.hs │ │ │ └── Binaryen │ │ │ │ ├── CheckOverlapDataSegment.hs │ │ │ │ └── RunPass.hs │ │ ├── Binary │ │ │ ├── ByteString.hs │ │ │ ├── File.hs │ │ │ └── NameCache.hs │ │ ├── Builtins.hs │ │ ├── Builtins │ │ │ ├── Barf.hs │ │ │ ├── Blackhole.hs │ │ │ ├── CMath.hs │ │ │ ├── Endianness.hs │ │ │ ├── Env.hs │ │ │ ├── Exports.hs │ │ │ ├── Main.hs │ │ │ ├── Posix.hs │ │ │ ├── Primitive.hs │ │ │ ├── SM.hs │ │ │ ├── Scheduler.hs │ │ │ ├── Sparks.hs │ │ │ ├── StgPrimFloat.hs │ │ │ └── Time.hs │ │ ├── CodeGen.hs │ │ ├── EDSL.hs │ │ ├── EDSL │ │ │ ├── BinaryOp.hs │ │ │ ├── LibC.hs │ │ │ └── UnaryOp.hs │ │ ├── FixEnv.hs │ │ ├── Foreign │ │ │ ├── DsForeign.hs │ │ │ ├── ExportStatic.hs │ │ │ ├── Internals.hs │ │ │ ├── SupportedTypes.hs │ │ │ ├── TcForeign.hs │ │ │ └── TypesTag.hs │ │ ├── FrontendPlugin.hs │ │ ├── GHCi │ │ │ └── Internals.hs │ │ ├── Internals.hs │ │ ├── Internals │ │ │ ├── Arena.hs │ │ │ ├── Barf.hs │ │ │ ├── ByteString.hs │ │ │ ├── MagicNumber.hs │ │ │ ├── Marshal.hs │ │ │ ├── Name.hs │ │ │ ├── PrettyShow.hs │ │ │ ├── SYB.hs │ │ │ └── Temp.hs │ │ ├── JSFFI.hs │ │ ├── JSGen │ │ │ ├── Bundle.hs │ │ │ ├── Constants.hs │ │ │ ├── Wasm.hs │ │ │ └── Wizer.hs │ │ ├── JSRun │ │ │ └── NonMain.hs │ │ ├── Ld.hs │ │ ├── Main.hs │ │ ├── Main │ │ │ └── Task.hs │ │ ├── MemoryTrap.hs │ │ ├── Passes │ │ │ ├── All.hs │ │ │ ├── Common.hs │ │ │ ├── DataSymbolTable.hs │ │ │ ├── FunctionSymbolTable.hs │ │ │ ├── GCSections.hs │ │ │ ├── GlobalRegs.hs │ │ │ ├── LocalRegs.hs │ │ │ ├── Relooper.hs │ │ │ └── Tracing.hs │ │ ├── Resolve.hs │ │ ├── Sysroot.hs │ │ ├── Types │ │ │ └── LinkReport.hs │ │ └── TypesConv.hs │ └── Language │ │ └── Haskell │ │ └── GHC │ │ └── Toolkit │ │ ├── Compiler.hs │ │ ├── Constants.hs │ │ ├── Hooks.hs │ │ └── Orphans │ │ └── Show.hs └── test │ ├── .gitignore │ ├── argv.hs │ ├── argv │ └── argv.hs │ ├── array.hs │ ├── array │ └── array.hs │ ├── bigint.hs │ ├── bigint │ └── bigint.hs │ ├── bytearray.hs │ ├── bytearray │ └── bytearray.hs │ ├── bytearraymini.hs │ ├── bytearraymini │ └── bytearraymini.hs │ ├── cloudflare-new.hs │ ├── cloudflare-new │ ├── Cloudflare │ │ ├── Application.hs │ │ ├── Request.hs │ │ └── Response.hs │ ├── Worker.hs │ ├── Worker.mjs │ ├── package-lock.json │ ├── package.json │ ├── webpack.config.js │ └── wrangler.toml │ ├── cloudflare.hs │ ├── cloudflare │ ├── cloudflare.hs │ ├── cloudflare.mjs │ ├── package.json │ └── test.js │ ├── endianness.hs │ ├── endianness │ └── endianness.hs │ ├── exception.hs │ ├── exception │ └── exception.hs │ ├── fib.hs │ ├── fib │ └── fib.hs │ ├── format-ghc-testsuite-report.py │ ├── ghc-testsuite-with-ghc.hs │ ├── ghc-testsuite.hs │ ├── ghc-testsuite │ ├── ado │ │ ├── T11607.hs │ │ ├── T11607.stdout │ │ ├── ado-optimal.hs │ │ ├── ado-optimal.stdout │ │ ├── ado001.hs │ │ └── ado001.stdout │ ├── array │ │ ├── arr001.hs │ │ ├── arr001.stdout │ │ ├── arr002.hs │ │ ├── arr002.stdout │ │ ├── arr003.hs │ │ ├── arr003.stderr │ │ ├── arr004.hs │ │ ├── arr004.stderr │ │ ├── arr005.hs │ │ ├── arr005.stdout │ │ ├── arr006.hs │ │ ├── arr006.stdout │ │ ├── arr007.hs │ │ ├── arr007.stderr │ │ ├── arr008.hs │ │ ├── arr008.stderr │ │ ├── arr008.stdout │ │ ├── arr009.hs │ │ ├── arr009.stdout │ │ ├── arr010.hs │ │ ├── arr010.stdout │ │ ├── arr011.hs │ │ ├── arr011.stdout │ │ ├── arr012.hs │ │ ├── arr012.stdout │ │ ├── arr013.hs │ │ ├── arr013.stdout │ │ ├── arr014.hs │ │ ├── arr015.hs │ │ ├── arr015.stdout │ │ ├── arr017.hs │ │ ├── arr017.stdout │ │ ├── arr018.hs │ │ ├── arr018.stdout │ │ ├── arr019.hs │ │ ├── arr019.stdout │ │ ├── arr020.hs │ │ └── arr020.stdout │ ├── arrows │ │ ├── T3822.hs │ │ ├── T3822.stdout │ │ ├── arrowrun001.hs │ │ ├── arrowrun001.stdout │ │ ├── arrowrun002.hs │ │ ├── arrowrun002.stdout │ │ ├── arrowrun003.hs │ │ ├── arrowrun003.stdout │ │ ├── arrowrun004.hs │ │ └── arrowrun004.stdout │ ├── boxy │ │ ├── T2193.hs │ │ └── T2193.stdout │ ├── callarity │ │ ├── StrictLet.hs │ │ └── StrictLet.stderr │ ├── codeGen │ │ ├── CgStaticPointers.hs │ │ ├── CgStaticPointers.stdout │ │ ├── CgStaticPointersNoFullLazyness.hs │ │ ├── CgStaticPointersNoFullLazyness.stdout │ │ ├── CmmSwitchTest32.hs │ │ ├── CmmSwitchTest64.hs │ │ ├── CmmSwitchTestGen.hs │ │ ├── CopySmallArray.hs │ │ ├── CopySmallArray.stdout │ │ ├── PopCnt.hs │ │ ├── PopCnt.stdout │ │ ├── PopCnt_cmm.cmm │ │ ├── SizeOfSmallArray.hs │ │ ├── SizeOfSmallArray.stdout │ │ ├── StaticArraySize.hs │ │ ├── StaticArraySize.stdout │ │ ├── StaticByteArraySize.hs │ │ ├── StaticByteArraySize.stdout │ │ ├── T10245.hs │ │ ├── T10245.stdout-ws-32 │ │ ├── T10245.stdout-ws-64 │ │ ├── T10246.hs │ │ ├── T10246.stdout │ │ ├── T10414.hs │ │ ├── T10414.stdout │ │ ├── T10521.hs │ │ ├── T10521.stdout │ │ ├── T10521b.hs │ │ ├── T10521b.stdout │ │ ├── T10870.hs │ │ ├── T10870.stdout │ │ ├── T12059.hs │ │ ├── T12059.stdout │ │ ├── T12433.hs │ │ ├── T12433.stdout │ │ ├── T12757.hs │ │ ├── T12757.stdout │ │ ├── T12855.hs │ │ ├── T13425.hs │ │ ├── T13425.stdout │ │ ├── T14251.hs │ │ ├── T14251.stdout │ │ ├── T14346.hs │ │ ├── T14619.hs │ │ ├── T14619.stdout │ │ ├── T14754.hs │ │ ├── T14754.stderr │ │ ├── T14754.stdout │ │ ├── T15696_1.hs │ │ ├── T15696_1.stdout │ │ ├── T15696_2.hs │ │ ├── T15696_2.stdout │ │ ├── T15696_3.hs │ │ ├── T15696_3.stdout │ │ ├── T15892.hs │ │ ├── T1852.hs │ │ ├── T1852.stdout │ │ ├── T1861.hs │ │ ├── T1861.stdout │ │ ├── T2080.hs │ │ ├── T2080.stdout │ │ ├── T2838.hs │ │ ├── T2838.stdout │ │ ├── T2838.stdout-ws-64 │ │ ├── T3207.hs │ │ ├── T3207.stdout │ │ ├── T3561.hs │ │ ├── T3561.stdout │ │ ├── T3677.hs │ │ ├── T3677.stdout │ │ ├── T4441.hs │ │ ├── T4441.stdout │ │ ├── T5129.hs │ │ ├── T5149.hs │ │ ├── T5149.stdout │ │ ├── T5149_cmm.cmm │ │ ├── T5626.hs │ │ ├── T5626.stderr │ │ ├── T5747.hs │ │ ├── T5747.stdout │ │ ├── T5785.hs │ │ ├── T5785.stdout │ │ ├── T5900.hs │ │ ├── T5900.stderr │ │ ├── T5900.stdout │ │ ├── T6084.hs │ │ ├── T6084.stdout │ │ ├── T6146.hs │ │ ├── T6146.stdin │ │ ├── T6146.stdout │ │ ├── T7163.hs │ │ ├── T7163.stdout │ │ ├── T7319.hs │ │ ├── T7319.stderr │ │ ├── T7361.hs │ │ ├── T7361.stdout │ │ ├── T8256.hs │ │ ├── T8256.stdout │ │ ├── T9001.hs │ │ ├── T9001.stdout │ │ ├── T9013.hs │ │ ├── T9013.stdout │ │ ├── T9340.hs │ │ ├── T9340.stdout │ │ ├── T9533.hs │ │ ├── T9533.stdout │ │ ├── T9533b.hs │ │ ├── T9533b.stdout │ │ ├── T9533c.hs │ │ ├── T9533c.stdout │ │ ├── Word2Float32.hs │ │ ├── Word2Float32.stdout │ │ ├── Word2Float64.hs │ │ ├── Word2Float64.stdout │ │ ├── castFloatWord.hs │ │ ├── castFloatWord.stdout │ │ ├── cgrun001.hs │ │ ├── cgrun001.stdout │ │ ├── cgrun002.hs │ │ ├── cgrun002.stdout │ │ ├── cgrun003.hs │ │ ├── cgrun003.stdout │ │ ├── cgrun004.hs │ │ ├── cgrun004.stdout │ │ ├── cgrun005.hs │ │ ├── cgrun005.stdout │ │ ├── cgrun006.hs │ │ ├── cgrun006.stdout │ │ ├── cgrun007.hs │ │ ├── cgrun007.stdout │ │ ├── cgrun008.hs │ │ ├── cgrun008.stdout │ │ ├── cgrun009.hs │ │ ├── cgrun009.stdout │ │ ├── cgrun010.hs │ │ ├── cgrun010.stdout │ │ ├── cgrun011.hs │ │ ├── cgrun011.stdout │ │ ├── cgrun012.hs │ │ ├── cgrun012.stdout │ │ ├── cgrun013.hs │ │ ├── cgrun013.stdout │ │ ├── cgrun014.hs │ │ ├── cgrun014.stdout │ │ ├── cgrun015.hs │ │ ├── cgrun015.stdout │ │ ├── cgrun016.hs │ │ ├── cgrun016.stderr │ │ ├── cgrun017.hs │ │ ├── cgrun017.stdout │ │ ├── cgrun018.hs │ │ ├── cgrun018.stdout │ │ ├── cgrun019.hs │ │ ├── cgrun019.stdout │ │ ├── cgrun020.hs │ │ ├── cgrun020.stdout │ │ ├── cgrun021.hs │ │ ├── cgrun021.stdout │ │ ├── cgrun022.hs │ │ ├── cgrun022.stdout │ │ ├── cgrun023.stdout │ │ ├── cgrun024.hs │ │ ├── cgrun024.stdout │ │ ├── cgrun026.hs │ │ ├── cgrun026.stdout │ │ ├── cgrun027.hs │ │ ├── cgrun027.stdout │ │ ├── cgrun028.hs │ │ ├── cgrun028.stdout │ │ ├── cgrun031.hs │ │ ├── cgrun031.stdout │ │ ├── cgrun032.hs │ │ ├── cgrun032.stdout │ │ ├── cgrun033.hs │ │ ├── cgrun033.stdout │ │ ├── cgrun034.hs │ │ ├── cgrun034.stdout │ │ ├── cgrun035.hs │ │ ├── cgrun035.stdout │ │ ├── cgrun036.hs │ │ ├── cgrun036.stdout │ │ ├── cgrun037.hs │ │ ├── cgrun037.stdout │ │ ├── cgrun038.hs │ │ ├── cgrun039.hs │ │ ├── cgrun039.stdout │ │ ├── cgrun040.hs │ │ ├── cgrun040.stdout │ │ ├── cgrun043.hs │ │ ├── cgrun044.hs │ │ ├── cgrun044.stdout │ │ ├── cgrun045.hs │ │ ├── cgrun045.stderr │ │ ├── cgrun046.hs │ │ ├── cgrun046.stdout │ │ ├── cgrun047.hs │ │ ├── cgrun047.stdout │ │ ├── cgrun048.hs │ │ ├── cgrun048.stdout │ │ ├── cgrun049.hs │ │ ├── cgrun049.stdout │ │ ├── cgrun050.hs │ │ ├── cgrun050.stdout │ │ ├── cgrun051.hs │ │ ├── cgrun051.stderr │ │ ├── cgrun052.hs │ │ ├── cgrun052.stdout │ │ ├── cgrun053.hs │ │ ├── cgrun054.hs │ │ ├── cgrun054.stdout │ │ ├── cgrun055.hs │ │ ├── cgrun055.stdout │ │ ├── cgrun056.hs │ │ ├── cgrun056.stdout │ │ ├── cgrun057.hs │ │ ├── cgrun057.stderr │ │ ├── cgrun058.hs │ │ ├── cgrun058.stdout │ │ ├── cgrun059.hs │ │ ├── cgrun059.stderr │ │ ├── cgrun059.stdout │ │ ├── cgrun060.hs │ │ ├── cgrun060.stdout │ │ ├── cgrun061.hs │ │ ├── cgrun061.stdout │ │ ├── cgrun062.hs │ │ ├── cgrun062.stdout │ │ ├── cgrun063.hs │ │ ├── cgrun063.stdout │ │ ├── cgrun064.hs │ │ ├── cgrun064.stdout │ │ ├── cgrun065.hs │ │ ├── cgrun065.stdout │ │ ├── cgrun066.hs │ │ ├── cgrun066.stdout │ │ ├── cgrun069.hs │ │ ├── cgrun069.stdout │ │ ├── cgrun069_cmm.cmm │ │ ├── cgrun070.hs │ │ ├── cgrun070.stdout │ │ ├── cgrun071.hs │ │ ├── cgrun071.stdout │ │ ├── cgrun072.hs │ │ ├── cgrun072.stdout │ │ ├── cgrun074.hs │ │ ├── cgrun074.stdout │ │ ├── cgrun075.hs │ │ ├── cgrun075.stdout │ │ ├── cgrun076.hs │ │ ├── cgrun076.stdout │ │ ├── cgrun077.hs │ │ ├── cgrun077.stdout │ │ ├── compareByteArrays.hs │ │ ├── compareByteArrays.stdout │ │ ├── setByteArray.hs │ │ └── setByteArray.stdout │ ├── cpranal │ │ ├── CPRRepeat.hs │ │ └── CPRRepeat.stdout │ ├── deSugar │ │ ├── DsLambdaCase.hs │ │ ├── DsLambdaCase.stdout │ │ ├── DsMultiWayIf.hs │ │ ├── DsMultiWayIf.stdout │ │ ├── DsStaticPointers.hs │ │ ├── DsStaticPointers.stdout │ │ ├── DsStrict.hs │ │ ├── DsStrict.stderr │ │ ├── DsStrict.stdout │ │ ├── DsStrictData.hs │ │ ├── DsStrictData.stdout │ │ ├── DsStrictLet.hs │ │ ├── DsStrictLet.stderr │ │ ├── T10215.hs │ │ ├── T10215.stdout │ │ ├── T11193.hs │ │ ├── T11193.stderr │ │ ├── T11572.hs │ │ ├── T11572.stderr │ │ ├── T11601.hs │ │ ├── T11601.stderr │ │ ├── T11747.hs │ │ ├── T11747.stdout │ │ ├── T12595.hs │ │ ├── T12595.stdout │ │ ├── T13285.hs │ │ ├── T13285.stdout │ │ ├── T246.hs │ │ ├── T246.stdout │ │ ├── T3126.hs │ │ ├── T3126.stdout │ │ ├── T3382.hs │ │ ├── T3382.stdout │ │ ├── T5742.hs │ │ ├── T5742.stdout │ │ ├── T8952.hs │ │ ├── T8952.stdout │ │ ├── T9238.hs │ │ ├── T9238.stdout │ │ ├── T9844.hs │ │ ├── T9844.stderr │ │ ├── T9844.stdout │ │ ├── dsrun001.hs │ │ ├── dsrun001.stdout │ │ ├── dsrun002.hs │ │ ├── dsrun002.stdout │ │ ├── dsrun003.hs │ │ ├── dsrun003.stdout │ │ ├── dsrun004.hs │ │ ├── dsrun004.stdout │ │ ├── dsrun005.hs │ │ ├── dsrun005.stderr │ │ ├── dsrun006.hs │ │ ├── dsrun006.stdout │ │ ├── dsrun007.hs │ │ ├── dsrun007.stderr │ │ ├── dsrun008.hs │ │ ├── dsrun008.stderr │ │ ├── dsrun009.hs │ │ ├── dsrun009.stdout │ │ ├── dsrun010.hs │ │ ├── dsrun010.stdout │ │ ├── dsrun011.hs │ │ ├── dsrun011.stdout │ │ ├── dsrun012.hs │ │ ├── dsrun012.stdout │ │ ├── dsrun013.hs │ │ ├── dsrun013.stdout │ │ ├── dsrun014.hs │ │ ├── dsrun014.stderr │ │ ├── dsrun014.stdout │ │ ├── dsrun015.hs │ │ ├── dsrun015.stdout │ │ ├── dsrun016.hs │ │ ├── dsrun016.stdout │ │ ├── dsrun017.hs │ │ ├── dsrun017.stdout │ │ ├── dsrun018.hs │ │ ├── dsrun018.stdout │ │ ├── dsrun019.hs │ │ ├── dsrun019.stdout │ │ ├── dsrun020.hs │ │ ├── dsrun020.stdout │ │ ├── dsrun021.hs │ │ ├── dsrun021.stdout │ │ ├── dsrun022.hs │ │ ├── dsrun022.stdout │ │ ├── dsrun023.hs │ │ ├── dsrun023.stdout │ │ ├── mc01.hs │ │ ├── mc01.stdout │ │ ├── mc02.hs │ │ ├── mc02.stdout │ │ ├── mc03.hs │ │ ├── mc03.stdout │ │ ├── mc04.hs │ │ ├── mc04.stdout │ │ ├── mc05.hs │ │ ├── mc05.stdout │ │ ├── mc06.hs │ │ ├── mc06.stdout │ │ ├── mc07.hs │ │ ├── mc07.stdout │ │ ├── mc08.hs │ │ └── mc08.stdout │ ├── deriving │ │ ├── T10104.hs │ │ ├── T10104.stdout │ │ ├── T10447.hs │ │ ├── T10447.stdout │ │ ├── T10598_bug.hs │ │ ├── T10598_bug.stdout │ │ ├── T10598_run.hs │ │ ├── T10598_run.stdout │ │ ├── T11535.hs │ │ ├── T11535.stdout │ │ ├── T14918.hs │ │ ├── T14918.stdout │ │ ├── T2529.hs │ │ ├── T2529.stdout │ │ ├── T4136.hs │ │ ├── T4136.stdout │ │ ├── T4528a.hs │ │ ├── T4528a.stdout │ │ ├── T5041.hs │ │ ├── T5041.stdout │ │ ├── T5628.hs │ │ ├── T5628.stdout │ │ ├── T5712.hs │ │ ├── T5712.stdout │ │ ├── T7401.hs │ │ ├── T7401.stdout │ │ ├── T7931.hs │ │ ├── T7931.stdout │ │ ├── T9576.hs │ │ ├── T9576.stderr │ │ ├── T9576.stdout │ │ ├── drvrun-foldable1.hs │ │ ├── drvrun-foldable1.stdout │ │ ├── drvrun-functor1.hs │ │ ├── drvrun-functor1.stdout │ │ ├── drvrun001.hs │ │ ├── drvrun001.stdout │ │ ├── drvrun002.hs │ │ ├── drvrun002.stdout │ │ ├── drvrun003.hs │ │ ├── drvrun003.stdout │ │ ├── drvrun004.hs │ │ ├── drvrun004.stdout │ │ ├── drvrun005.hs │ │ ├── drvrun005.stdout │ │ ├── drvrun006.hs │ │ ├── drvrun006.stdout │ │ ├── drvrun007.hs │ │ ├── drvrun007.stdout │ │ ├── drvrun008.hs │ │ ├── drvrun008.stdout │ │ ├── drvrun009.hs │ │ ├── drvrun009.stdout │ │ ├── drvrun010.hs │ │ ├── drvrun010.stdout │ │ ├── drvrun011.hs │ │ ├── drvrun011.stdout │ │ ├── drvrun012.hs │ │ ├── drvrun012.stdout │ │ ├── drvrun013.hs │ │ ├── drvrun013.stdout │ │ ├── drvrun014.hs │ │ ├── drvrun014.stdout │ │ ├── drvrun015.hs │ │ ├── drvrun015.stdout │ │ ├── drvrun016.hs │ │ ├── drvrun016.stdout │ │ ├── drvrun017.hs │ │ ├── drvrun017.stdout │ │ ├── drvrun018.hs │ │ ├── drvrun018.stdout │ │ ├── drvrun019.hs │ │ ├── drvrun019.stdout │ │ ├── drvrun020.hs │ │ ├── drvrun020.stdout │ │ ├── drvrun021.hs │ │ └── drvrun021.stdout │ ├── gadt │ │ ├── Session.hs │ │ ├── Session.stdout │ │ ├── T9380.hs │ │ ├── T9380.stdout │ │ ├── gadt2.hs │ │ ├── gadt2.stdout │ │ ├── gadt4.hs │ │ ├── gadt4.stdout │ │ ├── gadt5.hs │ │ ├── gadt5.stdout │ │ ├── records.hs │ │ ├── records.stdout │ │ ├── tc.hs │ │ ├── tc.stdout │ │ ├── type-rep.hs │ │ ├── type-rep.stdout │ │ ├── ubx-records.hs │ │ ├── ubx-records.stdout │ │ ├── while.hs │ │ └── while.stdout │ ├── generics │ │ ├── GFullyStrict.hs │ │ ├── GFullyStrict.stdout │ │ ├── GenNewtype.hs │ │ ├── GenNewtype.stdout │ │ ├── T10030.hs │ │ ├── T10030.stdout │ │ ├── T11358.hs │ │ └── T11358.stdout │ ├── indexed-types │ │ ├── GMapAssoc.hs │ │ ├── GMapAssoc.stdout │ │ ├── GMapTop.hs │ │ ├── GMapTop.stdout │ │ ├── T11465a.hs │ │ ├── T11465a.stdout │ │ ├── T2985.hs │ │ ├── T2985.stdout │ │ ├── T4235.hs │ │ ├── T4235.stdout │ │ ├── T5719.hs │ │ └── T5719.stdout │ ├── integer │ │ ├── gcdInteger.hs │ │ ├── gcdInteger.stdout │ │ ├── gcdInteger.stdout-ws-32 │ │ ├── integerBits.hs │ │ ├── integerBits.stdout │ │ ├── integerConstantFolding.hs │ │ ├── integerConstantFolding.stdout │ │ ├── integerConversions.hs │ │ ├── integerConversions.stdout │ │ ├── integerConversions.stdout-ws-64 │ │ ├── plusMinusInteger.hs │ │ └── plusMinusInteger.stdout │ ├── mdo │ │ ├── mdorun001.hs │ │ ├── mdorun001.stdout │ │ ├── mdorun002.hs │ │ ├── mdorun002.stdout │ │ ├── mdorun003.hs │ │ ├── mdorun003.stdout │ │ ├── mdorun004.hs │ │ ├── mdorun004.stdout │ │ ├── mdorun005.hs │ │ └── mdorun005.stdout │ ├── numeric │ │ ├── CarryOverflow.hs │ │ ├── CarryOverflow.stdout │ │ ├── FloatFnInverses.hs │ │ ├── FloatFnInverses.stdout │ │ ├── NumDecimals.hs │ │ ├── NumDecimals.stdout │ │ ├── T10011.hs │ │ ├── T10011.stdout │ │ ├── T10962.hs │ │ ├── T10962.stdout-ws-32 │ │ ├── T10962.stdout-ws-64 │ │ ├── T11702.hs │ │ ├── T11702.stdout │ │ ├── T12136.hs │ │ ├── T12136.stdout │ │ ├── T15271.hs │ │ ├── T15271.stdout │ │ ├── T15301.hs │ │ ├── T15301.stdout │ │ ├── T1603.hs │ │ ├── T1603.stdout │ │ ├── T4381.hs │ │ ├── T4381.stdout │ │ ├── T4383.hs │ │ ├── T4383.stdout │ │ ├── T5863.hs │ │ ├── T5863.stdout │ │ ├── T7014.hs │ │ ├── T7014.primops │ │ ├── T7014.stdout │ │ ├── T7233.hs │ │ ├── T7233.stdout │ │ ├── T8726.hs │ │ ├── T9407.hs │ │ ├── T9407.stdout │ │ ├── T9810.hs │ │ ├── T9810.stdout │ │ ├── add2.hs │ │ ├── add2.stdout │ │ ├── add2.stdout-ws-32 │ │ ├── arith001.hs │ │ ├── arith001.stdout │ │ ├── arith002.hs │ │ ├── arith002.stdout │ │ ├── arith003.hs │ │ ├── arith003.stdout │ │ ├── arith003.stdout-alpha-dec-osf3 │ │ ├── arith003.stdout-mips-sgi-irix │ │ ├── arith003.stdout-ws-64 │ │ ├── arith004.hs │ │ ├── arith004.stdout │ │ ├── arith005.hs │ │ ├── arith005.stdout │ │ ├── arith005.stdout-ws-64 │ │ ├── arith006.hs │ │ ├── arith006.stdout │ │ ├── arith007.hs │ │ ├── arith007.stdout │ │ ├── arith008.hs │ │ ├── arith008.stdout │ │ ├── arith009.hs │ │ ├── arith009.stdout │ │ ├── arith010.hs │ │ ├── arith010.stdout │ │ ├── arith011.hs │ │ ├── arith011.stdout │ │ ├── arith011.stdout-alpha-dec-osf3 │ │ ├── arith011.stdout-mips-sgi-irix │ │ ├── arith011.stdout-ws-64 │ │ ├── arith012.hs │ │ ├── arith012.stdout │ │ ├── arith013.hs │ │ ├── arith013.stdout │ │ ├── arith014.hs │ │ ├── arith014.stdout │ │ ├── arith015.hs │ │ ├── arith015.stdout │ │ ├── arith016.hs │ │ ├── arith016.stdout │ │ ├── arith017.hs │ │ ├── arith017.stdout │ │ ├── arith018.hs │ │ ├── arith018.stdout │ │ ├── arith019.hs │ │ ├── arith019.stdout │ │ ├── expfloat.hs │ │ ├── expfloat.stdout │ │ ├── mul2.hs │ │ ├── mul2.stdout │ │ ├── mul2.stdout-ws-32 │ │ ├── numrun009.hs │ │ ├── numrun009.stdout │ │ ├── numrun009.stdout-alpha-dec-osf3 │ │ ├── numrun009.stdout-mips-sgi-irix │ │ ├── numrun009.stdout-ws-64 │ │ ├── numrun009.stdout-x86_64-unknown-openbsd │ │ ├── numrun010.hs │ │ ├── numrun010.stdout │ │ ├── numrun011.hs │ │ ├── numrun011.stdout │ │ ├── numrun012.hs │ │ ├── numrun012.stdout │ │ ├── numrun012.stdout-ws-64 │ │ ├── numrun013.hs │ │ ├── numrun013.stdout │ │ ├── numrun014.hs │ │ ├── numrun014.stdout │ │ ├── numrun015.hs │ │ ├── numrun015.stdout │ │ ├── numrun016.hs │ │ ├── numrun016.stdout │ │ ├── quotRem2.hs │ │ └── quotRem2.stdout │ ├── overloadedlists │ │ ├── overloadedlistsrun01.hs │ │ ├── overloadedlistsrun01.stdout │ │ ├── overloadedlistsrun02.hs │ │ ├── overloadedlistsrun02.stdout │ │ ├── overloadedlistsrun03.hs │ │ ├── overloadedlistsrun03.stdout │ │ ├── overloadedlistsrun04.hs │ │ ├── overloadedlistsrun04.stdout │ │ ├── overloadedlistsrun05.hs │ │ └── overloadedlistsrun05.stdout │ ├── overloadedrecflds │ │ ├── T12243.hs │ │ ├── T12243.stdout │ │ ├── hasfieldrun01.hs │ │ ├── hasfieldrun01.stdout │ │ ├── hasfieldrun02.hs │ │ ├── hasfieldrun02.stdout │ │ ├── overloadedlabelsrun01.hs │ │ ├── overloadedlabelsrun01.stdout │ │ ├── overloadedlabelsrun02.hs │ │ ├── overloadedlabelsrun02.stdout │ │ ├── overloadedlabelsrun03.hs │ │ ├── overloadedlabelsrun03.stdout │ │ ├── overloadedrecflds_generics.hs │ │ ├── overloadedrecflds_generics.stdout │ │ ├── overloadedrecfldsrun01.hs │ │ ├── overloadedrecfldsrun01.stdout │ │ ├── overloadedrecfldsrun03.hs │ │ ├── overloadedrecfldsrun03.stdout │ │ ├── overloadedrecfldsrun04.hs │ │ ├── overloadedrecfldsrun04.stdout │ │ ├── overloadedrecfldsrun05.hs │ │ ├── overloadedrecfldsrun05.stdout │ │ ├── overloadedrecfldsrun06.hs │ │ ├── overloadedrecfldsrun06.stdout │ │ ├── overloadedrecfldsrun07.hs │ │ └── overloadedrecfldsrun07.stdout │ ├── overloadedstrings │ │ ├── overloadedstringsrun01.hs │ │ └── overloadedstringsrun01.stdout │ ├── parser │ │ ├── BinaryLiterals0.hs │ │ ├── BinaryLiterals0.stdout │ │ ├── BinaryLiterals1.hs │ │ ├── BinaryLiterals1.stdout │ │ ├── BinaryLiterals2.hs │ │ ├── BinaryLiterals2.stdout │ │ ├── HexFloatLiterals.hs │ │ ├── HexFloatLiterals.stdout │ │ ├── NegativeZero.hs │ │ ├── NegativeZero.stdout │ │ ├── NumericUnderscores0.hs │ │ ├── NumericUnderscores0.stdout │ │ ├── NumericUnderscores1.hs │ │ ├── NumericUnderscores1.stdout │ │ ├── ParserMultiWayIf.hs │ │ ├── ParserMultiWayIf.stdout │ │ ├── T10807.hs │ │ ├── T10807.stdout │ │ ├── T1344.hs │ │ ├── T1344.stdout │ │ ├── operator.hs │ │ ├── operator.stdout │ │ ├── operator2.hs │ │ ├── operator2.stdout │ │ ├── readRun001.hs │ │ ├── readRun001.stdout │ │ ├── readRun002.hs │ │ ├── readRun002.stdout │ │ ├── readRun003.hs │ │ ├── readRun003.stdout │ │ ├── readRun004.hs │ │ └── readRun004.stdout │ ├── patsyn │ │ ├── T11224.hs │ │ ├── T11224.stdout │ │ ├── T11985.script │ │ ├── T11985.stdout │ │ ├── T14228.hs │ │ ├── T14228.stdout │ │ ├── T9783.hs │ │ ├── T9783.stdout │ │ ├── bidir-explicit-scope.hs │ │ ├── bidir-explicit-scope.stdout │ │ ├── bidir-explicit.hs │ │ ├── bidir-explicit.stdout │ │ ├── eval.hs │ │ ├── eval.stdout │ │ ├── ex-prov-run.hs │ │ ├── ex-prov-run.stdout │ │ ├── ghci.script │ │ ├── ghci.stderr │ │ ├── ghci.stdout │ │ ├── match-unboxed.hs │ │ ├── match-unboxed.stdout │ │ ├── match.hs │ │ ├── match.stdout │ │ ├── records-run.hs │ │ ├── records-run.stdout │ │ ├── unboxed-wrapper.hs │ │ └── unboxed-wrapper.stdout │ ├── perf │ │ ├── Conversions.hs │ │ ├── Conversions.stdout │ │ ├── DeriveNull.hs │ │ ├── DeriveNull.stdout │ │ ├── DeriveNullTermination.hs │ │ ├── DeriveNullTermination.stdout │ │ ├── InlineArrayAlloc.hs │ │ ├── InlineByteArrayAlloc.hs │ │ ├── InlineCloneArrayAlloc.hs │ │ ├── MethSharing.hs │ │ ├── MethSharing.stdout │ │ ├── T10359.hs │ │ ├── T10359.stdout │ │ ├── T12791.hs │ │ ├── T12791.stdout │ │ ├── T12990.hs │ │ ├── T12996.hs │ │ ├── T12996.stdout │ │ ├── T13001.hs │ │ ├── T13001.stdout │ │ ├── T13218.hs │ │ ├── T13623.hs │ │ ├── T13623.stdout │ │ ├── T14936.hs │ │ ├── T14936.stdout │ │ ├── T149_A.hs │ │ ├── T149_B.hs │ │ ├── T15226.hs │ │ ├── T15226a.hs │ │ ├── T15263.hs │ │ ├── T15263.stdout │ │ ├── T15426.hs │ │ ├── T3245.hs │ │ ├── T3245.stdout │ │ ├── T3586.hs │ │ ├── T3586.stdout │ │ ├── T3736.hs │ │ ├── T3736.stdout │ │ ├── T4267.hs │ │ ├── T4321.hs │ │ ├── T4321.stdout │ │ ├── T4474a.hs │ │ ├── T4474a.stdout │ │ ├── T4474b.hs │ │ ├── T4474b.stdout │ │ ├── T4474c.hs │ │ ├── T4474c.stdout │ │ ├── T4830.hs │ │ ├── T4830.stdout │ │ ├── T4978.hs │ │ ├── T4978.stdout │ │ ├── T5113.hs │ │ ├── T5113.stdout │ │ ├── T5205.hs │ │ ├── T5205.stdout │ │ ├── T5237.hs │ │ ├── T5237.stdout │ │ ├── T5536.hs │ │ ├── T5835.hs │ │ ├── T5835.stdout │ │ ├── T5949.hs │ │ ├── T7257.hs │ │ ├── T7257.stdout │ │ ├── T7436.hs │ │ ├── T7436.stdout │ │ ├── T7507.hs │ │ ├── T7507.stdout │ │ ├── T7619.hs │ │ ├── T7850.hs │ │ ├── T7850.stdout │ │ ├── T7954.hs │ │ ├── T7954.stdout │ │ ├── T8472.hs │ │ ├── T8472.stdout │ │ ├── T876.hs │ │ ├── T876.stdout │ │ ├── T8763.hs │ │ ├── T9203.hs │ │ ├── T9203.stdout │ │ ├── T9339.hs │ │ ├── T9339.stdout │ │ └── lazy-bs-alloc.hs │ ├── polykinds │ │ ├── Freeman.hs │ │ ├── Freeman.stdout │ │ ├── MonoidsFD.hs │ │ ├── MonoidsFD.stdout │ │ ├── MonoidsTF.hs │ │ ├── MonoidsTF.stdout │ │ ├── PolyKinds09.hs │ │ ├── PolyKinds09.stdout │ │ ├── PolyKinds10.hs │ │ └── PolyKinds10.stdout │ ├── primops │ │ ├── ArithInt16.hs │ │ ├── ArithInt16.stdout │ │ ├── ArithInt8.hs │ │ ├── ArithInt8.stdout │ │ ├── ArithWord16.hs │ │ ├── ArithWord16.stdout │ │ ├── ArithWord8.hs │ │ ├── ArithWord8.stdout │ │ ├── CmpInt16.hs │ │ ├── CmpInt16.stdout │ │ ├── CmpInt8.hs │ │ ├── CmpInt8.stdout │ │ ├── CmpWord16.hs │ │ ├── CmpWord16.stdout │ │ ├── CmpWord8.hs │ │ ├── CmpWord8.stdout │ │ ├── ShowPrim.hs │ │ ├── ShowPrim.stdout │ │ ├── T10481.hs │ │ ├── T10481.stderr │ │ ├── T10678.hs │ │ ├── T11296.hs │ │ ├── T13825-compile.hs │ │ ├── T13825-compile.stdout │ │ ├── T16164.hs │ │ ├── T16164.stdout │ │ ├── T4442.hs │ │ ├── T4442.stdout │ │ ├── T6135.hs │ │ ├── T6135.stdout │ │ ├── T7689.hs │ │ ├── T7689.stdout │ │ └── T9430.hs │ ├── rebindable │ │ ├── RebindableFailA.hs │ │ ├── RebindableFailA.stderr │ │ ├── RebindableFailB.hs │ │ ├── RebindableFailB.stdout │ │ ├── T5038.hs │ │ ├── T5038.stdout │ │ ├── rebindable10.hs │ │ ├── rebindable10.stdout │ │ ├── rebindable2.hs │ │ ├── rebindable2.stdout │ │ ├── rebindable3.hs │ │ ├── rebindable3.stdout │ │ ├── rebindable4.hs │ │ ├── rebindable4.stdout │ │ ├── rebindable5.hs │ │ ├── rebindable5.stdout │ │ ├── rebindable7.hs │ │ └── rebindable7.stdout │ ├── rts │ │ ├── EventlogOutput.hs │ │ ├── GcStaticPointers.hs │ │ ├── GcStaticPointers.stdout │ │ ├── InternalCounters.stdout │ │ ├── ListStaticPointers.hs │ │ ├── T10017.hs │ │ ├── T10017.stdout │ │ ├── T10296a.hs │ │ ├── T10296a_c.c │ │ ├── T10296b.hs │ │ ├── T10590.hs │ │ ├── T10728.hs │ │ ├── T10728.stdout │ │ ├── T10904.hs │ │ ├── T10904lib.c │ │ ├── T11108.hs │ │ ├── T11108.stdout │ │ ├── T11788.c │ │ ├── T11788.hs │ │ ├── T11788.stdout │ │ ├── T12497.hs │ │ ├── T12497.stdout │ │ ├── T12903.hs │ │ ├── T12903.stdout │ │ ├── T13287.hs │ │ ├── T13287.stdout │ │ ├── T13617.c │ │ ├── T13617.hs │ │ ├── T13617.stdout │ │ ├── T13832.hs │ │ ├── T13832.stderr │ │ ├── T13894.hs │ │ ├── T14497.hs │ │ ├── T14497.stdout │ │ ├── T14702.hs │ │ ├── T15261a.hs │ │ ├── T15261a.stdout │ │ ├── T15261b.hs │ │ ├── T15261b.stdout │ │ ├── T2047.hs │ │ ├── T2783.hs │ │ ├── T2783.stderr │ │ ├── T3236.c │ │ ├── T3236.stderr │ │ ├── T4059.hs │ │ ├── T4059.stdout │ │ ├── T4059_c.c │ │ ├── T4850.hs │ │ ├── T4850.stdout │ │ ├── T5250.hs │ │ ├── T5423.hs │ │ ├── T5423.stdout │ │ ├── T5423_cmm.cmm │ │ ├── T5435.hs │ │ ├── T5435_asm.c │ │ ├── T5435_dyn_asm.stdout │ │ ├── T5435_dyn_asm.stdout-darwin │ │ ├── T5435_dyn_asm.stdout-mingw32 │ │ ├── T5435_dyn_gcc.stdout │ │ ├── T5435_gcc.c │ │ ├── T5435_v_asm.stdout │ │ ├── T5435_v_asm_a.stdout │ │ ├── T5435_v_asm_a.stdout-darwin │ │ ├── T5435_v_asm_a.stdout-mingw32 │ │ ├── T5435_v_asm_b.stdout │ │ ├── T5435_v_gcc.stdout │ │ ├── T5993.hs │ │ ├── T5993.stdout │ │ ├── T7037.hs │ │ ├── T7037.stdout │ │ ├── T7037_main.c │ │ ├── T7040.hs │ │ ├── T7040.stdout │ │ ├── T7040_c.c │ │ ├── T7040_c.h │ │ ├── T7040_ghci.hs │ │ ├── T7040_ghci.stdout │ │ ├── T7040_ghci_c.c │ │ ├── T7087.hs │ │ ├── T7087.stderr │ │ ├── T7160.hs │ │ ├── T7160.stderr │ │ ├── T7227.hs │ │ ├── T7636.hs │ │ ├── T7636.stderr │ │ ├── T7815.hs │ │ ├── T8035.hs │ │ ├── T8035.stdout │ │ ├── T8209.hs │ │ ├── T8242.hs │ │ ├── T8308.hs │ │ ├── T8308.stdout │ │ ├── T9045.hs │ │ ├── T9078.hs │ │ ├── T9405.hs │ │ ├── T9405.stdout │ │ ├── T9839_01.hs │ │ ├── T9839_01.stderr │ │ ├── T9839_02.hs │ │ ├── T9839_02.stderr │ │ ├── T9839_03.hs │ │ ├── T9839_03.stderr │ │ ├── T9839_04.hs │ │ ├── T9839_05.hs │ │ ├── T9839_05.stderr │ │ ├── T9839_06.hs │ │ ├── T9839_06.stderr │ │ ├── alloccounter1.hs │ │ ├── alloccounter1.stdout │ │ ├── atomicinc.c │ │ ├── atomicxchg.c │ │ ├── bug1010.hs │ │ ├── bug1010.stdout │ │ ├── derefnull.hs │ │ ├── derefnull.stderr-x86_64-unknown-openbsd │ │ ├── divbyzero.hs │ │ ├── divbyzero.stderr-x86_64-unknown-openbsd │ │ ├── ffishutdown.hs │ │ ├── ffishutdown.stderr │ │ ├── keep-cafs-fail.stdout │ │ ├── keep-cafs.stdout │ │ ├── libfoo_T2615.c │ │ ├── libfoo_script_T2615.so │ │ ├── linker_error.c │ │ ├── linker_error2.c │ │ ├── linker_error3.c │ │ ├── linker_unload.c │ │ ├── linker_unload.stdout │ │ ├── numa001.hs │ │ ├── nursery-chunks1.hs │ │ ├── outofmem.hs │ │ ├── outofmem.stderr │ │ ├── outofmem.stderr-i386-apple-darwin │ │ ├── outofmem.stderr-i386-unknown-mingw32 │ │ ├── outofmem.stderr-powerpc-apple-darwin │ │ ├── outofmem.stderr-ws-32 │ │ ├── outofmem.stderr-ws-64 │ │ ├── outofmem.stderr-x86_64-unknown-mingw32 │ │ ├── outofmem.stdout │ │ ├── outofmem2.hs │ │ ├── outofmem2.stderr │ │ ├── outofmem2.stdout │ │ ├── overflow1.hs │ │ ├── overflow1.stderr │ │ ├── overflow2.hs │ │ ├── overflow2.stderr │ │ ├── overflow3.hs │ │ ├── overflow3.stderr │ │ ├── return_mem_to_os.hs │ │ ├── return_mem_to_os.stdout │ │ ├── rtsflags001.hs │ │ ├── rtsflags001.stderr-ws-32 │ │ ├── rtsflags001.stderr-ws-64 │ │ ├── rtsflags002.hs │ │ ├── rtsflags002.stderr │ │ ├── spalign.c │ │ ├── stablename001.hs │ │ ├── stablename001.stdout │ │ ├── stack001.hs │ │ ├── stack002.hs │ │ ├── stack003.hs │ │ ├── stack003.stdout │ │ ├── stack004.hs │ │ ├── testblockalloc.c │ │ ├── testheapalloced.c │ │ ├── testmblockalloc.c │ │ ├── testwsdeque.c │ │ ├── traceBinaryEvent.hs │ │ ├── traceBinaryEvent.stderr │ │ ├── traceEvent.hs │ │ └── traceEvent.stderr │ ├── safeHaskell │ │ ├── SafeLang04.hs │ │ ├── SafeLang04.stdout │ │ ├── SafeLang05.hs │ │ └── SafeLang05.stdout │ ├── simplCore │ │ ├── AmapCoerce.hs │ │ ├── AmapCoerce.stdout │ │ ├── SeqRule.hs │ │ ├── SeqRule.stdout │ │ ├── T10830.hs │ │ ├── T11172.hs │ │ ├── T11172.stdout │ │ ├── T11731.hs │ │ ├── T11731.stderr │ │ ├── T12689a.hs │ │ ├── T12689a.stdout │ │ ├── T12689broken.hs │ │ ├── T12689broken.stdout │ │ ├── T13172.hs │ │ ├── T13172.stdout │ │ ├── T13227.hs │ │ ├── T13227.stderr │ │ ├── T13733.hs │ │ ├── T13733.stdout │ │ ├── T14178.hs │ │ ├── T14178.stdout │ │ ├── T14868.hs │ │ ├── T14868.stdout │ │ ├── T14894.hs │ │ ├── T14894.stdout │ │ ├── T15114.hs │ │ ├── T15114.stdout │ │ ├── T15436.hs │ │ ├── T15436.stdout │ │ ├── T15840.hs │ │ ├── T15840.stdout │ │ ├── T15840a.hs │ │ ├── T15840a.stdout │ │ ├── T16208.hs │ │ ├── T16208.stdout │ │ ├── T2110.hs │ │ ├── T2110.stdout │ │ ├── T2486.hs │ │ ├── T2486.stderr │ │ ├── T2756.hs │ │ ├── T3403.hs │ │ ├── T3403.stdout │ │ ├── T3437.hs │ │ ├── T3437.stdout │ │ ├── T3591.hs │ │ ├── T3591.stderr │ │ ├── T3591.stdout │ │ ├── T3959.hs │ │ ├── T3959.stdout │ │ ├── T457.hs │ │ ├── T457.stderr │ │ ├── T4814.hs │ │ ├── T4814.stdout │ │ ├── T5315.hs │ │ ├── T5315.stdout │ │ ├── T5453.hs │ │ ├── T5453.stdout │ │ ├── T5587.hs │ │ ├── T5587.stderr │ │ ├── T5625.hs │ │ ├── T5625.stderr │ │ ├── T5915.hs │ │ ├── T5915.stdout │ │ ├── T5920.hs │ │ ├── T5920.stdout │ │ ├── T5997.hs │ │ ├── T5997.stdout │ │ ├── T7101.hs │ │ ├── T7101.stdout │ │ ├── T7611.hs │ │ ├── T7611.stdout │ │ ├── T7924.hs │ │ ├── T7924.stderr │ │ ├── T9128.hs │ │ ├── T9128.stdout │ │ ├── T9390.hs │ │ ├── T9390.stdout │ │ ├── runST.hs │ │ ├── runST.stdout │ │ ├── simplrun001.hs │ │ ├── simplrun001.stdout │ │ ├── simplrun002.hs │ │ ├── simplrun002.stderr │ │ ├── simplrun002.stdout │ │ ├── simplrun003.hs │ │ ├── simplrun003.stdout │ │ ├── simplrun004.hs │ │ ├── simplrun004.stdout │ │ ├── simplrun005.hs │ │ ├── simplrun005.stdout │ │ ├── simplrun007.hs │ │ ├── simplrun007.stdout │ │ ├── simplrun007.stdout-ws-64 │ │ ├── simplrun008.hs │ │ ├── simplrun008.stdout │ │ ├── simplrun009.hs │ │ ├── simplrun009.stdout │ │ ├── simplrun010.hs │ │ ├── simplrun010.stderr │ │ ├── simplrun011.hs │ │ └── simplrun011.stdout │ ├── simplStg │ │ ├── T13536.hs │ │ ├── T13536.stderr │ │ ├── T13536.stdout │ │ ├── T13536a.hs │ │ ├── T13536a.stdout │ │ ├── T9291.hs │ │ └── T9291.stdout │ ├── strAnal │ │ ├── T10148.hs │ │ ├── T10148.stderr │ │ ├── T10218.hs │ │ ├── T10218.stdout │ │ ├── T11555a.hs │ │ ├── T11555a.stdout │ │ ├── T12368.hs │ │ ├── T12368.stderr │ │ ├── T12368a.hs │ │ ├── T12368a.stderr │ │ ├── T13380.hs │ │ ├── T13380.stderr │ │ ├── T14290.hs │ │ ├── T16197.hs │ │ ├── T16197.stdout │ │ ├── T2756b.hs │ │ ├── T7649.hs │ │ ├── T7649.stdout │ │ ├── T9254.hs │ │ ├── T9254.stdout │ │ ├── strun001.hs │ │ ├── strun001.stdout │ │ ├── strun002.hs │ │ ├── strun002.stderr │ │ ├── strun003.hs │ │ ├── strun003.stdout │ │ ├── strun004.hs │ │ └── strun004.stdout │ ├── typecheck │ │ ├── Defer01.hs │ │ ├── Defer01.stdout │ │ ├── EtaExpandLevPoly.hs │ │ ├── EtaExpandLevPoly.stdout │ │ ├── IPLocation.hs │ │ ├── IPLocation.stdout │ │ ├── IPRun.hs │ │ ├── IPRun.stdout │ │ ├── KindInvariant.script │ │ ├── KindInvariant.stderr │ │ ├── KindInvariant.stdout │ │ ├── StrictPats.hs │ │ ├── StrictPats.stdout │ │ ├── T10284.hs │ │ ├── T10284.stderr │ │ ├── T10284.stdout │ │ ├── T10845.hs │ │ ├── T10845.stdout │ │ ├── T10846.hs │ │ ├── T10846.stdout │ │ ├── T11049.hs │ │ ├── T11049.stderr │ │ ├── T11049.stdout │ │ ├── T11120.hs │ │ ├── T11120.stdout │ │ ├── T11230.hs │ │ ├── T11230.stdout │ │ ├── T11715.hs │ │ ├── T11715.stderr │ │ ├── T12809.hs │ │ ├── T12809.stdout │ │ ├── T13435.hs │ │ ├── T13435.stdout │ │ ├── T13594a.script │ │ ├── T13838.hs │ │ ├── T13838.stderr │ │ ├── T14218.hs │ │ ├── T14218.stdout │ │ ├── T14236.hs │ │ ├── T14236.stdout │ │ ├── T14341.hs │ │ ├── T14341.stdout │ │ ├── T14925.hs │ │ ├── T14925.stdout │ │ ├── T1624.hs │ │ ├── T1624.stdout │ │ ├── T2722.hs │ │ ├── T2722.stdout │ │ ├── T3500a.hs │ │ ├── T3500a.stdout │ │ ├── T3500b.hs │ │ ├── T3500b.stdout │ │ ├── T3731-short.hs │ │ ├── T3731-short.stdout │ │ ├── T3731.hs │ │ ├── T3731.stdout │ │ ├── T5573a.hs │ │ ├── T5573a.stdout │ │ ├── T5573b.hs │ │ ├── T5573b.stdout │ │ ├── T5751.hs │ │ ├── T5751.stdout │ │ ├── T5759.hs │ │ ├── T5759.stdout │ │ ├── T5913.hs │ │ ├── T5913.stdout │ │ ├── T6117.hs │ │ ├── T6117.stdout │ │ ├── T7023.hs │ │ ├── T7023.stdout │ │ ├── T7126.hs │ │ ├── T7126.stdout │ │ ├── T7748.hs │ │ ├── T7748.stdout │ │ ├── T7861.hs │ │ ├── T7861.stderr │ │ ├── T7861.stdout │ │ ├── T8492.hs │ │ ├── T8492.stdout │ │ ├── T8739.hs │ │ ├── T8739.stdout │ │ ├── T9858c.hs │ │ ├── T9858c.stdout │ │ ├── T9858d.hs │ │ ├── T9858d.stdout │ │ ├── TcCoercible.hs │ │ ├── TcCoercible.stdout │ │ ├── TcNullaryTC.hs │ │ ├── TcNullaryTC.stdout │ │ ├── TcTypeNatSimpleRun.hs │ │ ├── TcTypeNatSimpleRun.stdout │ │ ├── TcTypeSymbolSimpleRun.hs │ │ ├── TcTypeSymbolSimpleRun.stdout │ │ ├── TestTypeableBinary.hs │ │ ├── TestTypeableBinary.stdout │ │ ├── TypeOf.hs │ │ ├── TypeOf.stdout │ │ ├── TypeRep.hs │ │ ├── TypeRep.stdout │ │ ├── Typeable1.hs │ │ ├── Typeable1.stderr │ │ ├── TypeableEq.hs │ │ ├── TypeableEq.stdout │ │ ├── church.hs │ │ ├── church.stdout │ │ ├── mc17.hs │ │ ├── mc17.stdout │ │ ├── tcrun.stderr │ │ ├── tcrun001.hs │ │ ├── tcrun001.stdout │ │ ├── tcrun002.hs │ │ ├── tcrun002.stdout │ │ ├── tcrun002.stdout-alpha-dec-osf3 │ │ ├── tcrun002.stdout-mips-sgi-irix │ │ ├── tcrun002.stdout-ws-64 │ │ ├── tcrun002.stdout-x86_64-unknown-openbsd │ │ ├── tcrun003.hs │ │ ├── tcrun003.stdout │ │ ├── tcrun004.hs │ │ ├── tcrun004.stdout │ │ ├── tcrun005.hs │ │ ├── tcrun005.stdout │ │ ├── tcrun006.hs │ │ ├── tcrun006.stdout │ │ ├── tcrun008.hs │ │ ├── tcrun008.stdout │ │ ├── tcrun009.hs │ │ ├── tcrun009.stdout │ │ ├── tcrun010.hs │ │ ├── tcrun010.stdout │ │ ├── tcrun011.hs │ │ ├── tcrun011.stdout │ │ ├── tcrun012.hs │ │ ├── tcrun012.stdout │ │ ├── tcrun013.hs │ │ ├── tcrun013.stdout │ │ ├── tcrun014.hs │ │ ├── tcrun014.stdout │ │ ├── tcrun015.hs │ │ ├── tcrun015.stdout │ │ ├── tcrun016.hs │ │ ├── tcrun016.stdout │ │ ├── tcrun017.hs │ │ ├── tcrun017.stdout │ │ ├── tcrun018.hs │ │ ├── tcrun018.stdout │ │ ├── tcrun019.hs │ │ ├── tcrun019.stdout │ │ ├── tcrun020.hs │ │ ├── tcrun020.stdout │ │ ├── tcrun021.hs │ │ ├── tcrun021.stdout │ │ ├── tcrun022.hs │ │ ├── tcrun022.stdout │ │ ├── tcrun023.hs │ │ ├── tcrun023.stdout │ │ ├── tcrun024.hs │ │ ├── tcrun024.stdout │ │ ├── tcrun026.hs │ │ ├── tcrun026.stdout │ │ ├── tcrun027.hs │ │ ├── tcrun027.stdout │ │ ├── tcrun028.hs │ │ ├── tcrun028.stdout │ │ ├── tcrun029.hs │ │ ├── tcrun029.stdout │ │ ├── tcrun030.hs │ │ ├── tcrun030.stdout │ │ ├── tcrun031.hs │ │ ├── tcrun031.stdout │ │ ├── tcrun032.hs │ │ ├── tcrun032.stdout │ │ ├── tcrun033.hs │ │ ├── tcrun033.stdout │ │ ├── tcrun034.hs │ │ ├── tcrun034.stdout │ │ ├── tcrun035.hs │ │ ├── tcrun036.hs │ │ ├── tcrun036.stdout │ │ ├── tcrun037.hs │ │ ├── tcrun037.stdout │ │ ├── tcrun039.hs │ │ ├── tcrun039.stdout │ │ ├── tcrun040.hs │ │ ├── tcrun040.stdout │ │ ├── tcrun041.hs │ │ ├── tcrun041.stdout │ │ ├── tcrun043.hs │ │ ├── tcrun043.stdout │ │ ├── tcrun044.hs │ │ ├── tcrun044.stdout │ │ ├── tcrun046.hs │ │ ├── tcrun046.stdout │ │ ├── tcrun047.hs │ │ ├── tcrun047.stdout │ │ ├── tcrun048.hs │ │ ├── tcrun048.stdout │ │ ├── tcrun049.hs │ │ ├── tcrun049.stdout │ │ ├── tcrun050.hs │ │ ├── tcrun050.stdout │ │ ├── tcrun051.hs │ │ ├── tcrun051.stdout │ │ ├── testeq2.hs │ │ └── testeq2.stdout │ └── unboxedsums │ │ ├── T12375.hs │ │ ├── T12375.stdout │ │ ├── T12711.script │ │ ├── T12711.stdout │ │ ├── empty_sum.hs │ │ ├── empty_sum.stdout │ │ ├── thunk.hs │ │ ├── thunk.stdout │ │ ├── unarise.hs │ │ ├── unarise.stdout │ │ ├── unboxedsums1.hs │ │ ├── unboxedsums1.stdout │ │ ├── unboxedsums10.hs │ │ ├── unboxedsums10.stdout │ │ ├── unboxedsums11.hs │ │ ├── unboxedsums11.stdout │ │ ├── unboxedsums2.hs │ │ ├── unboxedsums2.stdin │ │ ├── unboxedsums2.stdout │ │ ├── unboxedsums3.hs │ │ ├── unboxedsums3.stdout │ │ ├── unboxedsums6.hs │ │ ├── unboxedsums6.stdout │ │ ├── unboxedsums7.hs │ │ ├── unboxedsums7.stdout │ │ ├── unboxedsums8.hs │ │ ├── unboxedsums8.stdout │ │ ├── unboxedsums9.hs │ │ └── unboxedsums9.stdout │ ├── group-common-tests-ghc-testsuite-report.py │ ├── jsffi.hs │ ├── jsffi │ ├── AsteriusPrim.hs │ ├── index.html │ ├── jsffi.hs │ └── jsffi.mjs │ ├── largenum.hs │ ├── largenum │ └── largenum.hs │ ├── nir-test.hs │ ├── node-compile.hs │ ├── node-compile │ └── node-compile.js │ ├── nodeio.hs │ ├── nodeio │ └── nodeio.hs │ ├── nomain.hs │ ├── nomain │ └── NoMain.hs │ ├── parsec.hs │ ├── parsec │ └── parsec.hs │ ├── primitive.hs │ ├── primitive │ └── primitive.hs │ ├── regression60.hs │ ├── regression60 │ └── regression60.hs │ ├── rts.hs │ ├── rts │ ├── FFI.hs │ ├── ForkIO.hs │ ├── MVar.hs │ └── ThreadDelay.hs │ ├── rtsapi.hs │ ├── rtsapi │ ├── rtsapi.hs │ └── rtsapi.mjs │ ├── sizeof_md5context.hs │ ├── sizeof_md5context │ └── sizeof_md5context.hs │ ├── stableptr.hs │ ├── stableptr │ └── stableptr.hs │ ├── teletype.hs │ ├── teletype │ └── teletype.hs │ ├── text.hs │ ├── text │ └── text.hs │ ├── th.hs │ ├── th │ ├── Fib.hs │ └── th.hs │ ├── time.hs │ ├── time │ └── time.hs │ ├── todomvc.hs │ └── todomvc │ ├── ElementBuilder.hs │ ├── TodoView.hs │ ├── WebAPI.hs │ ├── index.html │ ├── package.json │ └── todomvc.hs ├── bazel ├── bazel.md ├── bazel_utils │ └── cabal_filegroup.bzl ├── nix │ ├── BUILD.bazel │ ├── bazel_build_shell.nix │ └── bazel_deps.nix ├── stack.yaml └── stackage_snapshot.json ├── cabal.project ├── docs ├── .gitignore ├── book.toml ├── default.nix ├── shell.nix └── src │ ├── README.md │ ├── SUMMARY.md │ ├── ahc-link.md │ ├── architecture.md │ ├── building.md │ ├── cabal.md │ ├── debugging.md │ ├── hacking.md │ ├── images.md │ ├── ir.md │ ├── jsffi.md │ ├── milestones-2022-01.md │ ├── overview.md │ ├── pipeline.svg │ ├── readings.md │ ├── roadmap.md │ ├── rts-api.md │ ├── rts-migration.md │ ├── scheduler.md │ ├── semantics.md │ ├── th.md │ ├── tweag-logo.svg │ ├── wasm-experimental.md │ ├── wasm-in-hs.md │ └── webassembly.md ├── ghc-toolkit ├── BUILD.bazel ├── boot-libs │ ├── asterius-prelude │ │ ├── CHANGELOG.md │ │ ├── LICENSE │ │ ├── README.md │ │ ├── asterius-prelude.cabal │ │ └── src │ │ │ └── Asterius │ │ │ ├── Aeson.hs │ │ │ ├── ByteString.hs │ │ │ ├── Text.hs │ │ │ └── UTF8.hs │ └── rts │ │ └── rts.conf └── cbits │ └── ghc_constants.c ├── nix.cabal.project ├── nix ├── BUILD.bazel ├── binaryen.nix ├── binaryen.patch ├── ghcconstants.nix ├── project.nix ├── sources.json ├── sources.nix └── wasi-sdk.nix ├── shell.nix └── webpack ├── default.nix ├── package-lock.json └── package.json /BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tweag/asterius/641ade855c95818527f1726cc58ea7b49befede1/BUILD -------------------------------------------------------------------------------- /asterius/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # CHANGELOG for `asterius` 2 | -------------------------------------------------------------------------------- /asterius/README.md: -------------------------------------------------------------------------------- 1 | # `asterius` 2 | 3 | Main package of `asterius`. 4 | -------------------------------------------------------------------------------- /asterius/app/ahc-link.hs: -------------------------------------------------------------------------------- 1 | import Asterius.FixEnv 2 | import Asterius.Main 3 | 4 | main :: IO () 5 | main = do 6 | fixEnv 7 | getTask >>= ahcLinkMain 8 | -------------------------------------------------------------------------------- /asterius/app/genconstants.hs: -------------------------------------------------------------------------------- 1 | import Asterius.JSGen.Constants 2 | import Data.ByteString.Builder 3 | import System.IO 4 | 5 | main :: IO () 6 | main = hPutBuilder stdout rtsConstants 7 | -------------------------------------------------------------------------------- /asterius/ghc-bin-asterius/Main.hs: -------------------------------------------------------------------------------- 1 | import qualified Asterius.FrontendPlugin as A 2 | import qualified GHC.Frontend.Ghc as GHC 3 | 4 | main :: IO () 5 | main = GHC.main A.frontendPlugin 6 | -------------------------------------------------------------------------------- /asterius/rts/rts.autoapply.mjs: -------------------------------------------------------------------------------- 1 | export const stg_arg_bitmaps = [ 2 | 0, 0, 0, 0, 33, 1, 33, 98, 98, 484, 8168, 2097136, 98, 34, 66, 2, 227, 99, 3 | 163, 35, 195, 67, 131, 3, 4, 5, 6, 7, 8, 4 | ]; 5 | -------------------------------------------------------------------------------- /asterius/rts/rts.typecheck.mjs: -------------------------------------------------------------------------------- 1 | export function isI32(v) { 2 | if (!Number.isSafeInteger(v)) { 3 | throw WebAssembly.RuntimeError(`${v} not a safe integer`); 4 | } 5 | if (v < 0 || v > 0xffffffff) { 6 | throw WebAssembly.RuntimeError(`${v} range error`); 7 | } 8 | return v; 9 | } 10 | -------------------------------------------------------------------------------- /asterius/test/argv/argv.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | 3 | main :: IO () 4 | main = getArgs >>= print -- expected output: ["extra","flags"] 5 | -------------------------------------------------------------------------------- /asterius/test/array.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/array/array.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/bigint.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/bigint/bigint.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/bigint/bigint.hs: -------------------------------------------------------------------------------- 1 | fact :: Integer -> Integer 2 | fact 0 = 1 3 | fact n = n * fact (n - 1) 4 | 5 | main :: IO () 6 | main = print $ fact 100 7 | -------------------------------------------------------------------------------- /asterius/test/bytearray.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/bytearray/bytearray.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/bytearraymini.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/bytearraymini/bytearraymini.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/cloudflare-new/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "devDependencies": { 3 | "@cloudflare/wrangler": "^1.11.0", 4 | "webpack": "^5.0.0-beta.28", 5 | "webpack-cli": "^3.3.12" 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /asterius/test/cloudflare-new/webpack.config.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | entry: "./Worker.mjs", 3 | }; 4 | -------------------------------------------------------------------------------- /asterius/test/cloudflare-new/wrangler.toml: -------------------------------------------------------------------------------- 1 | name = "cloudflare-new" 2 | type = "webpack" 3 | webpack_config = "webpack.config.js" 4 | 5 | account_id = "" 6 | workers_dev = true 7 | route = "" 8 | zone_id = "" 9 | -------------------------------------------------------------------------------- /asterius/test/endianness.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ ["--input-hs", "test/endianness/endianness.hs", "--run"] <> args 8 | -------------------------------------------------------------------------------- /asterius/test/exception.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/exception/exception.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/exception/exception.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ScopedTypeVariables #-} 2 | 3 | import Control.Exception 4 | import System.IO.Error 5 | 6 | main :: IO () 7 | main = catch (throwIO (userError "BOOM")) (\(e :: SomeException) -> print e) 8 | -------------------------------------------------------------------------------- /asterius/test/fib.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ ["--input-hs", "test/fib/fib.hs", "--run"] <> args 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/ado/T11607.stdout: -------------------------------------------------------------------------------- 1 | MaybeA (Just 42) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/ado/ado-optimal.stdout: -------------------------------------------------------------------------------- 1 | ((a; b) | (c; d)); e 2 | (a | c); ((b | d); e) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/ado/ado001.stdout: -------------------------------------------------------------------------------- 1 | (a | b) 2 | a; g 3 | ((a | (b; g)) | e) 4 | (((a | b); g) | c) 5 | ((a | b) | c); (g | h) 6 | a; (b | (c; (d; (e | (f; g))))) 7 | (a | b); (c | d) 8 | a; ((b | c) | d) 9 | ((a | (b; c)) | d) | e 10 | ((a | b); (c | d)) | e 11 | a | b 12 | a | (b; c) 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr001.hs: -------------------------------------------------------------------------------- 1 | -- !!! Simple array creation 2 | 3 | import Data.Array 4 | 5 | main = 6 | let a1 = array (1,3) (zip [2,3,1] ['a'..'d']) in 7 | print a1 8 | 9 | -- Result: 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr001.stdout: -------------------------------------------------------------------------------- 1 | array (1,3) [(1,'c'),(2,'a'),(3,'b')] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr002.stdout: -------------------------------------------------------------------------------- 1 | 'b' 2 | array (1,3) [(1,'b'),(2,'c'),(3,'d')] 3 | 'b' 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr003.stderr: -------------------------------------------------------------------------------- 1 | arr003: Ix{Int}.index: Index (4) out of range ((1,3)) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr004.stderr: -------------------------------------------------------------------------------- 1 | arr004: (Array.!): undefined array element 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr007.hs: -------------------------------------------------------------------------------- 1 | -- !!! Array - accessing empty arrays 2 | -- 3 | -- empty arrays are legal, but indexing them is undefined! 4 | -- 5 | import Data.Array 6 | 7 | main = 8 | let 9 | a1 = array (1::Int,0) [(1,'a')] 10 | in 11 | print (a1!0) 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr007.stderr: -------------------------------------------------------------------------------- 1 | arr007: Ix{Int}.index: Index (1) out of range ((1,0)) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr008.stderr: -------------------------------------------------------------------------------- 1 | arr008: Ix{Int}.index: Index (2) out of range ((0,1)) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr008.stdout: -------------------------------------------------------------------------------- 1 | array (1,0) [] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr010.stdout: -------------------------------------------------------------------------------- 1 | array (0,10) [(0,0),(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr011.stdout: -------------------------------------------------------------------------------- 1 | array (0,10) [(0,0),(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2)] 2 | array (0,10) [(0,0),(1,0),(2,2),(3,0),(4,2),(5,0),(6,2),(7,0),(8,2),(9,0),(10,2)] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr015.stdout: -------------------------------------------------------------------------------- 1 | arr==arrS True 2 | arrS==arr True 3 | bnds arr arrS True 4 | bnds +id arr arrS True 5 | id +bnds arr arrS True 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr017.stdout: -------------------------------------------------------------------------------- 1 | 1.2742165080678525 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr018.stdout: -------------------------------------------------------------------------------- 1 | 100000 2 | 0 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/array/arr020.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | 42 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/arrows/T3822.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 10 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/arrows/arrowrun001.stdout: -------------------------------------------------------------------------------- 1 | 10 2 | 15 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/arrows/arrowrun002.stdout: -------------------------------------------------------------------------------- 1 | Succ (Succ (Succ (Zero (((8,7),(6,5)),((4,3),(2,1)))))) 2 | Succ (Succ (Succ (Zero (((1,5),(3,7)),((2,6),(4,8)))))) 3 | Succ (Succ (Succ (Zero (((1,2),(3,4)),((5,6),(7,8)))))) 4 | Succ (Succ (Succ (Zero (((1,3),(6,10)),((15,21),(28,36)))))) 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/arrows/arrowrun003.stdout: -------------------------------------------------------------------------------- 1 | [0,1,0,1,2,0,1,0] 2 | [0,1,0,1,2,0,1,0] 3 | [0,0,0,0,5,0,0,0] 4 | [0,0,0,0,5,0,0,0] 5 | [1,1,3,3,3,6,6,8] 6 | [1,1,3,3,3,6,6,8] 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/arrows/arrowrun004.stdout: -------------------------------------------------------------------------------- 1 | 15 2 | 14 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/boxy/T2193.stdout: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/callarity/StrictLet.stderr: -------------------------------------------------------------------------------- 1 | cond called with 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/CgStaticPointers.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | 0 3 | "found" 4 | 'a' 5 | 'b' 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/CgStaticPointersNoFullLazyness.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | 0 3 | "found" 4 | 'a' 5 | 'b' 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/PopCnt.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash,GHCForeignImportPrim,UnliftedFFITypes #-} 2 | module Main where 3 | 4 | import GHC.Exts 5 | 6 | foreign import prim "do_popcnt32" popcnt32 :: Int# -> Int# 7 | 8 | main = print (I# (popcnt32 0xffff#)) 9 | 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/PopCnt.stdout: -------------------------------------------------------------------------------- 1 | 16 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/PopCnt_cmm.cmm: -------------------------------------------------------------------------------- 1 | #include "Cmm.h" 2 | 3 | do_popcnt32 (W_ x) 4 | { 5 | W_ res; 6 | (res) = prim %popcnt32(x); 7 | R1 = res; 8 | jump %ENTRY_CODE(Sp(0)) [R1]; 9 | } 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/StaticArraySize.stdout: -------------------------------------------------------------------------------- 1 | success 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/StaticByteArraySize.stdout: -------------------------------------------------------------------------------- 1 | success 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T10245.stdout-ws-32: -------------------------------------------------------------------------------- 1 | 2147483648 2 | -2147483648 3 | "yes" 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T10245.stdout-ws-64: -------------------------------------------------------------------------------- 1 | 9223372036854775808 2 | -9223372036854775808 3 | "yes" 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T10246.stdout: -------------------------------------------------------------------------------- 1 | "bar" 2 | "bar" 3 | "foo" 4 | "foo" 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T10521.stdout: -------------------------------------------------------------------------------- 1 | [145,189,137,132,233] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T10521b.stdout: -------------------------------------------------------------------------------- 1 | 1.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T10870.stdout: -------------------------------------------------------------------------------- 1 | [0,0] 2 | [-1,-1] 3 | [0,0] 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T12059.stdout: -------------------------------------------------------------------------------- 1 | False 2 | True 3 | True 4 | False 5 | True -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T12433.hs: -------------------------------------------------------------------------------- 1 | f :: Int -> IO () 2 | f p = case p of 3 | 0 -> return () 4 | 1 -> return () 5 | 2 -> return () 6 | 3 -> return () 7 | 4 -> return () 8 | 10 -> return () 9 | 11 -> return () 10 | _ -> print p 11 | {-# NOINLINE f #-} 12 | 13 | main = f 8 14 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T12433.stdout: -------------------------------------------------------------------------------- 1 | 8 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T12757.stdout: -------------------------------------------------------------------------------- 1 | () 2 | () 3 | 7 4 | () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T13425.hs: -------------------------------------------------------------------------------- 1 | import Data.Bits ((.&.)) 2 | 3 | flags :: Int -> Int 4 | flags x 5 | | x .&. 128 > 0 = 12 6 | | otherwise = 13 7 | {-# NOINLINE flags #-} 8 | 9 | main :: IO () 10 | main = print (flags 255) 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T13425.stdout: -------------------------------------------------------------------------------- 1 | 12 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T14251.stdout: -------------------------------------------------------------------------------- 1 | Hello World! 2 | Hello World! 3 | Hello 6.0 6.9 World! 4 | 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T14619.stdout: -------------------------------------------------------------------------------- 1 | (44.0,55.0,66.0) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T14754.stderr: -------------------------------------------------------------------------------- 1 | (3,1) 2 | (2,1) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T14754.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T15696_1.stdout: -------------------------------------------------------------------------------- 1 | EQ 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T15696_2.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | 1 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T15696_3.hs: -------------------------------------------------------------------------------- 1 | import qualified Data.Set as S 2 | 3 | main = print $ 4 | let {-# noinline f #-} 5 | f () = T2 6 | in S.fromList [f (), f ()] 7 | 8 | data T = T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 9 | deriving (Show, Read, Eq, Ord, Bounded, Enum) 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T15696_3.stdout: -------------------------------------------------------------------------------- 1 | fromList [T2] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T1852.stdout: -------------------------------------------------------------------------------- 1 | [1,2,3,4] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T1861.stdout: -------------------------------------------------------------------------------- 1 | True 2 | False 3 | False 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T2080.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T2838.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T2838.stdout-ws-64: -------------------------------------------------------------------------------- 1 | -4294967296 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T3207.stdout: -------------------------------------------------------------------------------- 1 | () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T3561.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T3677.stdout: -------------------------------------------------------------------------------- 1 | [0,1000000] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T4441.stdout: -------------------------------------------------------------------------------- 1 | "Float Version : 1.9999999552965164e-2" 2 | "Double Version: 2.0e-2" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5149.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash,GHCForeignImportPrim,UnliftedFFITypes #-} 2 | module Main where 3 | 4 | import GHC.Exts 5 | 6 | foreign import prim "f5149" f :: Int# -> Int# -> Double# -> Int# 7 | 8 | main = print (I# (f 1# 2# 1.0##)) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5149.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5626.stderr: -------------------------------------------------------------------------------- 1 | T5626: Prelude.undefined 2 | CallStack (from ImplicitParams): 3 | error, called at libraries/base/GHC/Err.hs:43:14 in base:GHC.Err 4 | undefined, called at T5626.hs:6:30 in main:Main 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5747.hs: -------------------------------------------------------------------------------- 1 | main = print (cos 0) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5747.stdout: -------------------------------------------------------------------------------- 1 | 1.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5900.stderr: -------------------------------------------------------------------------------- 1 | 1238988323332265734 11185553392205053542 -> 18360184157246690566 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T5900.stdout: -------------------------------------------------------------------------------- 1 | fl 1238988323332265734 11185553392205053542 -> 18360184157246690566 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T6084.stdout: -------------------------------------------------------------------------------- 1 | Hello World! 2 | Hello World! 3 | Hello World! 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T6146.stdin: -------------------------------------------------------------------------------- 1 | 2 2 | 3 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T6146.stdout: -------------------------------------------------------------------------------- 1 | First number? 2 | Second number? 3 | The sum is 5. 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T7163.hs: -------------------------------------------------------------------------------- 1 | 2 | module Main where 3 | 4 | main :: IO () 5 | main = putStrLn $ printFloat 100 6 | 7 | printFloat :: Float -> String 8 | printFloat x = f (show (round (x * 10))) 9 | where f "0" = "0" 10 | f _ = show (round x) 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T7163.stdout: -------------------------------------------------------------------------------- 1 | 100 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T7319.stderr: -------------------------------------------------------------------------------- 1 | T7319: test 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T7361.stdout: -------------------------------------------------------------------------------- 1 | [[1,1,1,1,1,1],[0,0,0,256,0,256],[0,0,0,0,0,0],[0,0,0,0,0,0],[-1,-1,-1,-1,-1,-1]] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T8256.stdout: -------------------------------------------------------------------------------- 1 | success 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9001.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE RankNTypes #-} 2 | 3 | newtype FMList = FM {unFM :: forall m. m -> m} 4 | 5 | main = print (delete 2000 (FM id) :: Int) 6 | 7 | delete 0 _ = 0 8 | delete n (FM a) = a $ delete (n-1) $ FM $ \g -> a (const g) undefined 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9001.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9013.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9340.stdout: -------------------------------------------------------------------------------- 1 | tested 2208 patterns 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9533.hs: -------------------------------------------------------------------------------- 1 | import Data.Word 2 | 3 | x :: Word 4 | x = 10 5 | 6 | y :: Word 7 | y = 11 8 | 9 | test = case x - y of 10 | 5 -> "C" 11 | -1 -> "A" 12 | _ -> "B" 13 | main = putStrLn $ show test 14 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9533.stdout: -------------------------------------------------------------------------------- 1 | "A" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9533b.stdout: -------------------------------------------------------------------------------- 1 | AA 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9533c.hs: -------------------------------------------------------------------------------- 1 | -- Don't wrap literals that will be used at type Integer 2 | f :: Integer -> Int 3 | f n = case n of 4 | 0x100000000000000000000000 -> 1 5 | 0 -> 2 6 | _ -> 3 7 | 8 | main = print (f (read "0")) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/T9533c.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/Word2Float32.stdout: -------------------------------------------------------------------------------- 1 | 0.0 2 | 4.294967295e9 3 | 0.0 4 | 1.6777216e7 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/Word2Float64.stdout: -------------------------------------------------------------------------------- 1 | 0.0 2 | 9.007199254740992e15 3 | 0.0 4 | 1.6777216e7 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun001.hs: -------------------------------------------------------------------------------- 1 | -- !! cg001: main = -42 -- take 1 2 | 3 | main = print ( f () ) 4 | where 5 | f :: a -> Int 6 | f x = -42 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun001.stdout: -------------------------------------------------------------------------------- 1 | -42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun002.hs: -------------------------------------------------------------------------------- 1 | main = print ((f id2) (10 + thirty_two)) 2 | where 3 | f x = g x 4 | where 5 | g x = h x 6 | where 7 | h x = x 8 | 9 | thirty_two :: Int 10 | thirty_two = 32 11 | 12 | id2 x = x 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun002.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun003.hs: -------------------------------------------------------------------------------- 1 | main = print (id2 (id2 id2) (42::Int)) 2 | -- where 3 | -- id2 = s k k 4 | 5 | -- id2 x = s k k x 6 | 7 | id2 = s k k 8 | 9 | s x y z = x z (y z) 10 | 11 | k x y = x 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun003.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun004.hs: -------------------------------------------------------------------------------- 1 | main = print (length ([9,8,7,6,5,4,3,2,1] :: [Int])) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun004.stdout: -------------------------------------------------------------------------------- 1 | 9 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun005.hs: -------------------------------------------------------------------------------- 1 | -- !! answer: 65532 2 | 3 | main = print foo 4 | 5 | foo :: Int 6 | foo = ((1 + 2 + 32767 - 4) * 6) --later? `div` 3 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun005.stdout: -------------------------------------------------------------------------------- 1 | 196596 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun006.hs: -------------------------------------------------------------------------------- 1 | main = print (length thirteen_ones) 2 | where 3 | thirteen_ones = take (13::Int) ones 4 | 5 | ones :: [Int] 6 | ones = 1 : ones 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun006.stdout: -------------------------------------------------------------------------------- 1 | 13 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun007.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun008.stdout: -------------------------------------------------------------------------------- 1 | 12 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun009.hs: -------------------------------------------------------------------------------- 1 | main = print (length take_list) 2 | where 3 | take_list :: [Int] 4 | take_list = takeWhile (\ x -> x < 6) given_list 5 | 6 | given_list :: [Int] 7 | given_list = [1,2,3,4,5,6,7,8,9] 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun009.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun010.hs: -------------------------------------------------------------------------------- 1 | main = print a 2 | where 3 | a :: Int 4 | b :: Int 5 | (a, b) = (3 + 4, 5 + 6) 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun010.stdout: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun011.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun012.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun013.stdout: -------------------------------------------------------------------------------- 1 | "43\n" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun014.hs: -------------------------------------------------------------------------------- 1 | -- !! cg014: main = -42 -- twice: in Float and Double 2 | 3 | main = print ((show ( (-42) :: Float )) ++ " " ++ (show ( (-42) :: Double )) ++ "\n") 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun014.stdout: -------------------------------------------------------------------------------- 1 | "-42.0 -42.0\n" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun015.stdout: -------------------------------------------------------------------------------- 1 | A -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun016.stderr: -------------------------------------------------------------------------------- 1 | cgrun016: 6th call to error 2 | CallStack (from ImplicitParams): 3 | error, called at cgrun016.hs:8:8 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun017.stdout: -------------------------------------------------------------------------------- 1 | TrueTrueFalse -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun018.stdout: -------------------------------------------------------------------------------- 1 | 0.46920002 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun019.hs: -------------------------------------------------------------------------------- 1 | -- !!! printing of floating-pt numbers 2 | -- 3 | main = print (1.234e5 :: Float) 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun019.stdout: -------------------------------------------------------------------------------- 1 | 123400.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun020.hs: -------------------------------------------------------------------------------- 1 | -- !!! reading/showing of Ints/Integers 2 | -- 3 | main = print ((read "-1") :: Integer) 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun020.stdout: -------------------------------------------------------------------------------- 1 | -1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun021.stdout: -------------------------------------------------------------------------------- 1 | I succeeded! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun022.stdout: -------------------------------------------------------------------------------- 1 | a -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun023.stdout: -------------------------------------------------------------------------------- 1 | False -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun024.hs: -------------------------------------------------------------------------------- 1 | -- !!! test super-dictionary grabification 2 | -- 3 | 4 | main = putStr (show (is_one (1.2::Double))) 5 | 6 | is_one :: RealFloat a => a -> Bool 7 | 8 | is_one x = x == 1.0 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun024.stdout: -------------------------------------------------------------------------------- 1 | False -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun027.stdout: -------------------------------------------------------------------------------- 1 | 58 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun028.hs: -------------------------------------------------------------------------------- 1 | main = putStr (shows (f (read "42.0")) "\n") 2 | 3 | -- f compiled to bogus code with ghc 0.18 and earlier 4 | -- switch() on a DoubleReg 5 | 6 | f :: Double -> Int 7 | f 1.0 = 1 8 | f 2.0 = 2 9 | f 3.0 = 3 10 | f x = round x 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun028.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun031.stdout: -------------------------------------------------------------------------------- 1 | 35 2 | 35 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun032.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun033.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun035.stdout: -------------------------------------------------------------------------------- 1 | 1.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun036.stdout: -------------------------------------------------------------------------------- 1 | [1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425,1276425,1037862,1276425] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun037.hs: -------------------------------------------------------------------------------- 1 | -- Andy Gill bug report 95/08: 2 | -- Constant strings with '\0' in them don't work :- 3 | -- 4 | main = putStrLn "hello\0 world" 5 | --main = putStrLn "hello0 world" 6 | 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun037.stdout: -------------------------------------------------------------------------------- 1 | hello world 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun039.stdout: -------------------------------------------------------------------------------- 1 | "Hello, world!\n" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun040.stdout: -------------------------------------------------------------------------------- 1 | 11 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun045.hs: -------------------------------------------------------------------------------- 1 | 2 | module Main( main ) where 3 | 4 | 5 | main :: IO () 6 | main = seq (error "hello world!" :: Int) (return ()) 7 | 8 | 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun045.stderr: -------------------------------------------------------------------------------- 1 | cgrun045: hello world! 2 | CallStack (from ImplicitParams): 3 | error, called at cgrun045.hs:6:13 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun046.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import System.IO 4 | 5 | -- !!! CAF space leaks 6 | 7 | main = lots_of_xs 10000 8 | 9 | lots_of_xs 0 = return () 10 | lots_of_xs n = putChar 'x' >> lots_of_xs (n-1) 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun047.stdout: -------------------------------------------------------------------------------- 1 | [(0,1),(1,2),(2,3),(3,4)] -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun048.stdout: -------------------------------------------------------------------------------- 1 | [False,True,False,False,False,False,False] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun049.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun050.stdout: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun051.hs: -------------------------------------------------------------------------------- 1 | 2 | module Main where 3 | 4 | data T1 -- No constructors 5 | data T2 = T2 !T1 Int 6 | 7 | main = print (case (T2 (error "OK") 1) of { T2 x y -> y }) 8 | 9 | -- We should hit the (error "OK") case 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun051.stderr: -------------------------------------------------------------------------------- 1 | cgrun051: OK 2 | CallStack (from ImplicitParams): 3 | error, called at cgrun051.hs:7:25 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun052.stdout: -------------------------------------------------------------------------------- 1 | ok 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun053.hs: -------------------------------------------------------------------------------- 1 | -- should run successfully and exit, i.e. without evaluating the 2 | -- argument to return. 3 | main = return undefined 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun054.stdout: -------------------------------------------------------------------------------- 1 | [X2,X4,X5] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun055.stdout: -------------------------------------------------------------------------------- 1 | ====== 2 | x: Five 3 | let y = succ x 4 | y: Six 5 | y == Six: True 6 | succ x == Six: True 7 | isFive x: True 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun056.hs: -------------------------------------------------------------------------------- 1 | -- Another test for the evaluated-ness of data2tag 2 | 3 | module Main where 4 | 5 | data S e = A | B | C | D | E | F | G | H | I deriving (Eq) 6 | newtype R = T (S R) deriving (Eq) 7 | 8 | main = do { print (T A == T B) ; print (T I == T I) } 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun056.stdout: -------------------------------------------------------------------------------- 1 | False 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun057.hs: -------------------------------------------------------------------------------- 1 | -- For testing +RTS -xc 2 | import Control.Exception 3 | main = try (evaluate (f ())) :: IO (Either SomeException ()) 4 | 5 | f x = g x 6 | 7 | g x = error (show x) 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun057.stderr: -------------------------------------------------------------------------------- 1 | *** Exception (reporting due to +RTS -xc): (THUNK_2_0), stack trace: 2 | Main.g, 3 | called from Main.f, 4 | called from Main.main, 5 | called from Main.CAF 6 | --> evaluated by: Main.f, 7 | called from Main.main 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun058.stdout: -------------------------------------------------------------------------------- 1 | [] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun059.stderr: -------------------------------------------------------------------------------- 1 | cgrun059: Error: File not found 2 | CallStack (from HasCallStack): 3 | error, called at cgrun059.hs:12:28 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun059.stdout: -------------------------------------------------------------------------------- 1 | ([],[]) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun060.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun061.stdout: -------------------------------------------------------------------------------- 1 | "a" 2 | "b" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun062.stdout: -------------------------------------------------------------------------------- 1 | "abc" 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun063.stdout: -------------------------------------------------------------------------------- 1 | ??( 2 | ??) 3 | ??< 4 | ??> 5 | ??= 6 | ??/ 7 | ??' 8 | ??! 9 | ??- 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun066.stdout: -------------------------------------------------------------------------------- 1 | 885 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun069.stdout: -------------------------------------------------------------------------------- 1 | Mem{cpy,set,move} Intrinsics Test... 2 | Test Passed! 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun071.stdout: -------------------------------------------------------------------------------- 1 | OK 2 | OK 3 | OK 4 | OK 5 | OK 6 | 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun072.stdout: -------------------------------------------------------------------------------- 1 | OK 2 | OK 3 | OK 4 | OK 5 | OK 6 | OK 7 | OK 8 | OK 9 | OK 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun074.stdout: -------------------------------------------------------------------------------- 1 | 2828000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun075.stdout: -------------------------------------------------------------------------------- 1 | OK 2 | OK 3 | OK 4 | OK 5 | OK 6 | 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun076.stdout: -------------------------------------------------------------------------------- 1 | OK 2 | OK 3 | OK 4 | OK 5 | OK 6 | 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/cgrun077.stdout: -------------------------------------------------------------------------------- 1 | OK 2 | OK 3 | OK 4 | OK 5 | OK 6 | 7 | OK 8 | OK 9 | OK 10 | OK 11 | OK 12 | 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/compareByteArrays.stdout: -------------------------------------------------------------------------------- 1 | BEGIN 2 | LT 3 | GT 4 | LT 5 | GT 6 | EQ 7 | (True,EQ) 8 | (False,LT) 9 | (False,GT) 10 | (True,EQ) 11 | True 12 | END 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/codeGen/setByteArray.stdout: -------------------------------------------------------------------------------- 1 | A 2 | C 3 | C 4 | C 5 | C 6 | C 7 | C 8 | A 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/cpranal/CPRRepeat.hs: -------------------------------------------------------------------------------- 1 | repeat' :: x -> [x] 2 | repeat' x = x : repeat' x 3 | 4 | main = print (repeat' () !! 10 ) 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/cpranal/CPRRepeat.stdout: -------------------------------------------------------------------------------- 1 | () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/DsLambdaCase.stdout: -------------------------------------------------------------------------------- 1 | [True,True,True,True,True] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/DsMultiWayIf.stdout: -------------------------------------------------------------------------------- 1 | [True,True,True,True,True] 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/DsStrict.stderr: -------------------------------------------------------------------------------- 1 | evaluated in fun 2 | evaluated in case 3 | evaluated in lambda 4 | evaluated in newtype 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/DsStrict.stdout: -------------------------------------------------------------------------------- 1 | fun 2 | fun2 3 | case 4 | case2 5 | lambda 6 | lambda2 7 | newtype 8 | newtype2 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/DsStrictData.stdout: -------------------------------------------------------------------------------- 1 | True 2 | True 3 | True 4 | True 5 | 6 | True 7 | True 8 | True 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/DsStrictLet.stderr: -------------------------------------------------------------------------------- 1 | recursive 2 | polymorphic 3 | no binders 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T10215.hs: -------------------------------------------------------------------------------- 1 | testF :: Float -> Bool 2 | testF x = x == 0 && not (isNegativeZero x) 3 | 4 | testD :: Double -> Bool 5 | testD x = x == 0 && not (isNegativeZero x) 6 | 7 | main :: IO () 8 | main = do print $ testF (-0.0) 9 | print $ testD (-0.0) 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T10215.stdout: -------------------------------------------------------------------------------- 1 | False 2 | False 3 | 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11193.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE Strict #-} 2 | 3 | module Main where 4 | 5 | main = do 6 | ~a <- return (error "don't error here!") 7 | b <- return (error "error here!") -- this binding should be strict 8 | print "should never reach here" 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11193.stderr: -------------------------------------------------------------------------------- 1 | T11193: error here! 2 | CallStack (from ImplicitParams): 3 | error, called at T11193.hs:7:16 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11572.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE BangPatterns #-} 2 | 3 | module Main where 4 | 5 | main :: IO () 6 | main = let !_ = (undefined :: ()) in print 2 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11572.stderr: -------------------------------------------------------------------------------- 1 | T11572: Prelude.undefined 2 | CallStack (from HasCallStack): 3 | error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err 4 | undefined, called at T11572.hs:6:18 in main:Main 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11601.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE BangPatterns #-} 2 | 3 | module Main where 4 | 5 | -- This should fail evern though y is unused 6 | f x = let !(Just (Just y)) = Just undefined in True 7 | 8 | main = print (f False) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11601.stderr: -------------------------------------------------------------------------------- 1 | T11601: Prelude.undefined 2 | CallStack (from HasCallStack): 3 | error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err 4 | undefined, called at T11601.hs:6:35 in main:Main 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T11747.stdout: -------------------------------------------------------------------------------- 1 | Nothing 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T12595.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T13285.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | -- Main.hs 4 | import GHC.Stack 5 | 6 | main :: IO () 7 | main = do 8 | foo 23 42 9 | (`foo` 23) 42 10 | 11 | foo :: HasCallStack => Int -> Int -> IO () 12 | foo _ _ = print (length . getCallStack $ callStack) 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T13285.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | 1 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T246.stdout: -------------------------------------------------------------------------------- 1 | "OK" 2 | "caught" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T3126.stdout: -------------------------------------------------------------------------------- 1 | False 2 | False 3 | False 4 | False 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T3382.stdout: -------------------------------------------------------------------------------- 1 | "correct" 2 | "false" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T5742.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T8952.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE BangPatterns #-} 2 | 3 | module Main where 4 | 5 | main = print (case Nothing of 6 | !(~(Just x)) -> "ok" 7 | Nothing -> "bad") 8 | 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T8952.stdout: -------------------------------------------------------------------------------- 1 | "ok" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T9238.stdout: -------------------------------------------------------------------------------- 1 | [(-0.0,-0.0,EQ),(-0.0,0.0,LT),(0.0,-0.0,GT),(0.0,0.0,EQ)] 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T9844.stderr: -------------------------------------------------------------------------------- 1 | evaluated f0 2 | evaluated f1 3 | evaluated f2 4 | evaluated f3 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/T9844.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 0 3 | 0 4 | 0 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun001.stdout: -------------------------------------------------------------------------------- 1 | [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun002.stdout: -------------------------------------------------------------------------------- 1 | aabcb 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun003.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun004.hs: -------------------------------------------------------------------------------- 1 | -- Test n+k patterns 2 | 3 | {-# LANGUAGE NPlusKPatterns #-} 4 | 5 | module Main where 6 | 7 | f (n+1) = n 8 | 9 | g :: Int -> Int 10 | g (n+4) = n 11 | 12 | main = print (f 3) >> 13 | print (g 9) 14 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun004.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | 5 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun005.stderr: -------------------------------------------------------------------------------- 1 | dsrun005: dsrun005.hs:42:1-18: Non-exhaustive patterns in function f 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun006.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun007.hs: -------------------------------------------------------------------------------- 1 | data T = C Int 2 | 3 | unpick (C i) = i + 1 4 | 5 | main = print (unpick (C{})) -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun007.stderr: -------------------------------------------------------------------------------- 1 | dsrun007: dsrun007.hs:5:23-25: Missing field in record construction 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun008.hs: -------------------------------------------------------------------------------- 1 | -- !!! Double irrefutable pattern (bug in Hugs98, 29/8/2001) 2 | main = print (case (1,2) of ~(~(2,x)) -> x) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun008.stderr: -------------------------------------------------------------------------------- 1 | dsrun008: dsrun008.hs:2:15-42: Non-exhaustive patterns in (2, x) 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun009.stdout: -------------------------------------------------------------------------------- 1 | (Negate (FromInteger 2),True) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun010.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun011.stdout: -------------------------------------------------------------------------------- 1 | 216 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun012.stdout: -------------------------------------------------------------------------------- 1 | 62 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun013.stdout: -------------------------------------------------------------------------------- 1 | "One" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun014.stderr: -------------------------------------------------------------------------------- 1 | one 2 | two 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun014.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun015.stdout: -------------------------------------------------------------------------------- 1 | 31 2 | (111,True) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun016.stdout: -------------------------------------------------------------------------------- 1 | ["","h","he","hel","hell","hello","helloh","hellohe","hellohel","hellohell","hellohello","hellohelloh","hellohellohe","hellohellohel","hellohellohell","hellohellohello"] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun017.stdout: -------------------------------------------------------------------------------- 1 | [("A",15,["Bob","Jim","Jim"]),("B",2,["Fred"])] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun018.stdout: -------------------------------------------------------------------------------- 1 | [(1,1728000),(2,14400),(1,120),(3,120)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun019.hs: -------------------------------------------------------------------------------- 1 | -- Test transform WITHOUT a by clause 2 | 3 | {-# OPTIONS_GHC -XTransformListComp #-} 4 | 5 | module Main where 6 | 7 | main = putStrLn (show output) 8 | where 9 | output = [ x 10 | | x <- [1..10] 11 | , then take 5 ] -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun019.stdout: -------------------------------------------------------------------------------- 1 | [1,2,3,4,5] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun020.stdout: -------------------------------------------------------------------------------- 1 | [11,12] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun021.stdout: -------------------------------------------------------------------------------- 1 | [("Yale",60)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun022.stdout: -------------------------------------------------------------------------------- 1 | "my group function called!" 2 | [(["Yale"],[60,60,60,60],"[1,1,1,2] and [4,5,6,4]"),(["Yale"],[60,60,60,60],"[1,1,1,2] and [4,5,6,4]")] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/dsrun023.stdout: -------------------------------------------------------------------------------- 1 | [460] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc01.stdout: -------------------------------------------------------------------------------- 1 | "my group function called!" 2 | [(["Yale"],[60,60,60,60],"[1,1,1,2] and [4,5,6,4]"),(["Yale"],[60,60,60,60],"[1,1,1,2] and [4,5,6,4]")] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc02.stdout: -------------------------------------------------------------------------------- 1 | [("Yale",60)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc03.stdout: -------------------------------------------------------------------------------- 1 | [460] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc04.stdout: -------------------------------------------------------------------------------- 1 | ["","h","he","hel","hell","hello","helloh","hellohe","hellohel","hellohell","hellohello","hellohelloh","hellohellohe","hellohellohel","hellohellohell","hellohellohello"] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc05.stdout: -------------------------------------------------------------------------------- 1 | [1,2,3,4,5] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc06.stdout: -------------------------------------------------------------------------------- 1 | [(1,1728000),(2,14400),(1,120),(3,120)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc07.stdout: -------------------------------------------------------------------------------- 1 | [11,12] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deSugar/mc08.stdout: -------------------------------------------------------------------------------- 1 | [("A",15,["Bob","Jim","Jim"]),("B",2,["Fred"])] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T10104.stdout: -------------------------------------------------------------------------------- 1 | Positives 42# 4.23# 4.23## '4'# 4## 2 | Negatives -4# -4.0# -4.0## 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T10447.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | 1 3 | 1 4 | 1 5 | 2 6 | 1 7 | 2 8 | Nothing 9 | Just "World" 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T10598_bug.stdout: -------------------------------------------------------------------------------- 1 | MyMaybe (Just 11) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T10598_run.stdout: -------------------------------------------------------------------------------- 1 | 100 2 | 42 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T11535.stdout: -------------------------------------------------------------------------------- 1 | True 2 | True 3 | True 4 | True 5 | True 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T14918.stdout: -------------------------------------------------------------------------------- 1 | MkT {runT = -1, (##) = 1} 2 | MkT# {runT# = -1, (###) = 1} 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T2529.stdout: -------------------------------------------------------------------------------- 1 | (:<>:) {x = 1, y = 2} 2 | [((:<>:) {x = 1, y = 2},"")] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T4136.stdout: -------------------------------------------------------------------------------- 1 | show (:=:) = (:=:) 2 | read (show (:=:)) :: T = (:=:) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T4528a.hs: -------------------------------------------------------------------------------- 1 | -- Crashed older GHCs when loaded into GHCi 2 | 3 | module Main where 4 | 5 | data T a = A | B | C deriving( Enum, Show ) 6 | 7 | main = print [A ..] 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T4528a.stdout: -------------------------------------------------------------------------------- 1 | [A,B,C] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T5041.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash #-} 2 | 3 | module Main where 4 | 5 | data T = T1# | T2# Int deriving( Read, Show ) 6 | 7 | foo :: [T] 8 | foo = read "[ T1#, T2# 4, T2# 5 ]" 9 | main = print foo 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T5041.stdout: -------------------------------------------------------------------------------- 1 | [T1#,T2# 4,T2# 5] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T5628.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE EmptyDataDecls, StandaloneDeriving #-} 2 | module Main where 3 | 4 | data Z 5 | deriving instance Eq Z 6 | 7 | g :: Z 8 | g = g 9 | 10 | main :: IO () 11 | main = print (g == g) 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T5628.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T5712.stdout: -------------------------------------------------------------------------------- 1 | (:+:) 'x' (3 :*: True) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T7401.stdout: -------------------------------------------------------------------------------- 1 | True 2 | EQ 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T7931.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE StandaloneDeriving #-} 2 | module Main where 3 | 4 | data A 5 | deriving instance Read A 6 | deriving instance Show A 7 | 8 | main = print (read "[]" :: [A]) 9 | -- Should successfully read the empty list 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T7931.stdout: -------------------------------------------------------------------------------- 1 | [] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T9576.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -fdefer-type-errors #-} 2 | 3 | module Main where 4 | 5 | data Foo = MkFoo 6 | data Bar = MkBar Foo deriving Show 7 | 8 | main = do { print True; print (MkBar MkFoo) } 9 | 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/T9576.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun-foldable1.stdout: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun001.stdout: -------------------------------------------------------------------------------- 1 | MkAge 8 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun002.stdout: -------------------------------------------------------------------------------- 1 | Options {s = SpecialOptions {test = 42}} 2 | Options {s = SpecialOptions {test = 42}} 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun003.stdout: -------------------------------------------------------------------------------- 1 | Y B 2 | Y B 3 | Y B 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun004.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | data Hash = Hash{ (#) :: Int } 4 | deriving (Show, Read) 5 | 6 | main = 7 | do print s 8 | print (read s :: Hash) 9 | where 10 | s = show (Hash 3) 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun004.stdout: -------------------------------------------------------------------------------- 1 | "Hash {(#) = 3}" 2 | Hash {(#) = 3} 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun005.stdout: -------------------------------------------------------------------------------- 1 | T1 2 | T1 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun006.stdout: -------------------------------------------------------------------------------- 1 | Leaf 2 2 | Leaf 2 :^: Leaf (-1) 3 | Leaf 2 4 | Leaf 2 :^: Leaf (-1) 5 | Leaf 2 6 | Leaf 2 :^: Leaf (-1) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun007.hs: -------------------------------------------------------------------------------- 1 | module Main( main ) where 2 | -- This one crashed Hugs98 3 | 4 | data X = X | X :\ X deriving Show 5 | 6 | main = putStrLn (show (X :\ X)) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun007.stdout: -------------------------------------------------------------------------------- 1 | X :\ X 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun008.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun009.stdout: -------------------------------------------------------------------------------- 1 | array ((1,4),(2,5)) [((1,4),5),((1,5),6),((2,4),6),((2,5),7)] 2 | array ((1,4),(2,5)) [((1,4),5),((1,5),6),((2,4),6),((2,5),7)] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun010.stdout: -------------------------------------------------------------------------------- 1 | works 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun011.stdout: -------------------------------------------------------------------------------- 1 | ([Commit Nothing,Commit (Just "foo")],[Foo,Baz True],[Boz 3,Boz (-2)]) 2 | ([Commit Nothing,Commit (Just "foo")],[Foo,Baz True],[Boz 3,Boz (-2)]) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun012.stdout: -------------------------------------------------------------------------------- 1 | Foo {x = 1 :%% 2, y = Just 4} 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun013.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun014.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun015.hs: -------------------------------------------------------------------------------- 1 | -- The leading underscore killed GHC 5.04 2 | 3 | module Main where 4 | 5 | data Obj = Obj {_id, p1, p2::Int} deriving (Show, Read) 6 | 7 | 8 | main = print (show (read "Obj {_id=1,p1=10,p2=20}" :: Obj)) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun015.stdout: -------------------------------------------------------------------------------- 1 | "Obj {_id = 1, p1 = 10, p2 = 20}" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun016.stdout: -------------------------------------------------------------------------------- 1 | Success 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun017.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash #-} 2 | 3 | -- Test Show on unboxed types 4 | 5 | module Main where 6 | import GHC.Base 7 | 8 | data Foo = MkFoo Int# Float# Int deriving( Show ) 9 | 10 | main = print (MkFoo 3# 4.3# 2) -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun017.stdout: -------------------------------------------------------------------------------- 1 | MkFoo 3# 4.3# 2 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun018.hs: -------------------------------------------------------------------------------- 1 | 2 | -- Test Show on unboxed types 3 | 4 | module Main where 5 | 6 | data Foo = Int `MkFoo` Int deriving( Read, Show ) 7 | 8 | main = do { print (MkFoo 4 5) 9 | ; print (read "3 `MkFoo` 5" :: Foo) } 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun018.stdout: -------------------------------------------------------------------------------- 1 | 4 `MkFoo` 5 2 | 3 `MkFoo` 5 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun019.stdout: -------------------------------------------------------------------------------- 1 | xxx 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun020.stdout: -------------------------------------------------------------------------------- 1 | 3 :%% T2 (T1 {f1 = 3}) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/deriving/drvrun021.stdout: -------------------------------------------------------------------------------- 1 | False 2 | False 3 | True 4 | True 5 | MkMoose () 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/Session.stdout: -------------------------------------------------------------------------------- 1 | Cons (5,True) (Cons (3,False) (Nil)) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/T9380.stdout: -------------------------------------------------------------------------------- 1 | test0 - A 2 | test1 - A 3 | test2 - A 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/gadt2.stdout: -------------------------------------------------------------------------------- 1 | [True,False] 2 | [LT,EQ,GT] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/gadt4.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/gadt5.stdout: -------------------------------------------------------------------------------- 1 | (3,4) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/records.stdout: -------------------------------------------------------------------------------- 1 | 9 2 | 5 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/tc.stdout: -------------------------------------------------------------------------------- 1 | Bool 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/type-rep.stdout: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/ubx-records.stdout: -------------------------------------------------------------------------------- 1 | 9 2 | 5 3 | 0 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/gadt/while.stdout: -------------------------------------------------------------------------------- 1 | (15,(6,1)) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/generics/GFullyStrict.stdout: -------------------------------------------------------------------------------- 1 | True 2 | False 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/generics/GenNewtype.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DeriveGeneric #-} 2 | 3 | module Main where 4 | 5 | import GHC.Generics 6 | 7 | data X = X deriving Generic 8 | newtype Y = Y X deriving Generic 9 | 10 | main = print [isNewtype (from X), isNewtype (from (Y X))] 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/generics/GenNewtype.stdout: -------------------------------------------------------------------------------- 1 | [False,True] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/generics/T10030.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import GHC.Generics 4 | 5 | main = do 6 | putStrLn $ packageName $ from $ Just True 7 | putStrLn $ packageName $ from $ True 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/generics/T10030.stdout: -------------------------------------------------------------------------------- 1 | base 2 | ghc-prim 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/generics/T11358.stdout: -------------------------------------------------------------------------------- 1 | Prefix, Infix LeftAssociative 9 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/indexed-types/GMapAssoc.stdout: -------------------------------------------------------------------------------- 1 | This is the one! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/indexed-types/GMapTop.stdout: -------------------------------------------------------------------------------- 1 | This is the one! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/indexed-types/T11465a.stdout: -------------------------------------------------------------------------------- 1 | 'c' 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/indexed-types/T2985.stdout: -------------------------------------------------------------------------------- 1 | (0,4) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/indexed-types/T4235.stdout: -------------------------------------------------------------------------------- 1 | [R,S,T] 2 | [False,True,True] 3 | [True,False] 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/indexed-types/T5719.stdout: -------------------------------------------------------------------------------- 1 | [2,3,4] 2 | fromList [2,3,4] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/integer/gcdInteger.stdout: -------------------------------------------------------------------------------- 1 | 9223372036854775808 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/integer/gcdInteger.stdout-ws-32: -------------------------------------------------------------------------------- 1 | 2147483648 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/integer/integerBits.stdout: -------------------------------------------------------------------------------- 1 | Start 2 | End 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/integer/plusMinusInteger.stdout: -------------------------------------------------------------------------------- 1 | 0 -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/mdo/mdorun001.stdout: -------------------------------------------------------------------------------- 1 | Before: 2 | [12.0,12.0,12.0,12.0,12.0,12.0,12.0,12.0,12.0,12.0] 3 | After: 4 | [0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1] 5 | Normalized sum: 1.0000001 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/mdo/mdorun002.stdout: -------------------------------------------------------------------------------- 1 | [1,13,12,2,3,4,5,6,7,8,9,10] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/mdo/mdorun003.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DoRec #-} 2 | 3 | main :: IO () 4 | main = do x <- return (length [1 .. 42 :: Int]) 5 | rec b <- return x 6 | let a = const c 7 | c <- print "x" 8 | print (b, a b) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/mdo/mdorun003.stdout: -------------------------------------------------------------------------------- 1 | "x" 2 | (42,()) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/mdo/mdorun004.stdout: -------------------------------------------------------------------------------- 1 | 10 2 | [1,1,1,1,1,1,1,1,1,1] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/mdo/mdorun005.stdout: -------------------------------------------------------------------------------- 1 | 10 2 | [1,1,1,1,1,1,1,1,1,1] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/CarryOverflow.stdout: -------------------------------------------------------------------------------- 1 | Passed 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/NumDecimals.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE NumDecimals #-} 2 | 3 | main :: IO () 4 | main = print (1.2e6 :: Integer) 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/NumDecimals.stdout: -------------------------------------------------------------------------------- 1 | 1200000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T10011.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T10962.stdout-ws-32: -------------------------------------------------------------------------------- 1 | (4294967294,1) 2 | (4294967294,1) 3 | (2,1) 4 | (2,1) 5 | (3,0) 6 | (3,0) 7 | (4294967295,0) 8 | (4294967295,0) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T10962.stdout-ws-64: -------------------------------------------------------------------------------- 1 | (18446744073709551614,1) 2 | (18446744073709551614,1) 3 | (2,1) 4 | (2,1) 5 | (3,0) 6 | (3,0) 7 | (18446744073709551615,0) 8 | (18446744073709551615,0) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T11702.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | testfn :: Word -> IO () 4 | testfn wseq = do 5 | print $ wseq `mod` 1 6 | 7 | main = do 8 | testfn 5 9 | print $ (5 :: Word) `mod` 1 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T11702.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 0 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T12136.stdout: -------------------------------------------------------------------------------- 1 | -18446744073709551616 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T15271.hs: -------------------------------------------------------------------------------- 1 | main = do 2 | print 1e646457008 3 | print 1e646457009 -- T15271: This incorrectly printed 0.0 4 | print 1e1555550000 -- This is still infinity 5 | print 1e1000000000 -- T15271: This incorrectly printed 0.0 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T15271.stdout: -------------------------------------------------------------------------------- 1 | Infinity 2 | Infinity 3 | Infinity 4 | Infinity 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T15301.hs: -------------------------------------------------------------------------------- 1 | import Numeric 2 | import GHC.Natural 3 | 4 | main = do 5 | -- test that GHC correctly compiles big Natural literals 6 | let x = 0xffffffffffffffffffffffff :: Natural 7 | print (showHex x "" == "ffffffffffffffffffffffff") 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T15301.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T1603.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = print (syn [-1]) 4 | 5 | syn :: [Int] -> [Int] 6 | syn (d:ds) = rem d 0x40000000 : syn ds 7 | syn [] = [] 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T1603.stdout: -------------------------------------------------------------------------------- 1 | [-1] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T4381.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = do 4 | print (scaleFloat 30000 1) 5 | print (scaleFloat (maxBound :: Int) 1) 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T4381.stdout: -------------------------------------------------------------------------------- 1 | Infinity 2 | Infinity 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T4383.hs: -------------------------------------------------------------------------------- 1 | main = print (0.5 ^ 1030) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T4383.stdout: -------------------------------------------------------------------------------- 1 | 8.691694759794e-311 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T5863.hs: -------------------------------------------------------------------------------- 1 | import Text.Printf 2 | 3 | main :: IO () 4 | main = do 5 | putStrLn $ printf "%.1f" (0.45 :: Double) 6 | putStrLn $ printf "%.1f" (0.55 :: Double) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T5863.stdout: -------------------------------------------------------------------------------- 1 | 0.4 2 | 0.6 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T7014.primops: -------------------------------------------------------------------------------- 1 | and# 2 | or# 3 | uncheckedShift.*# 4 | \+# 5 | \-# 6 | \*# 7 | quotInt# 8 | remInt# 9 | plusFloat# 10 | minusFloat# 11 | timesFloat# 12 | divideFloat# 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T7014.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 0 3 | 44 4 | 45 5 | 46 6 | 47 7 | 48 8 | 49 9 | 50 10 | 0 11 | 52 12 | 53 13 | 0 14 | 55 15 | 0 16 | 57.0 17 | 58.0 18 | 59.0 19 | 60.0 20 | 61.0 21 | 62.0 22 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T9407.stdout: -------------------------------------------------------------------------------- 1 | Just (Vec3 0.0 0.0 1.0) -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/T9810.stdout: -------------------------------------------------------------------------------- 1 | ## Double ## 2 | Infinity 3 | -Infinity 4 | Infinity 5 | Infinity 6 | -Infinity 7 | Infinity 8 | ## Float ## 9 | Infinity 10 | -Infinity 11 | Infinity 12 | Infinity 13 | -Infinity 14 | Infinity 15 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith001.stdout: -------------------------------------------------------------------------------- 1 | 42 % 1 2 | 42, 1 3 | 42.0, 1.0 4 | 5910974510923776, -47 5 | 5910974510923776, -47 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith002.stdout: -------------------------------------------------------------------------------- 1 | [0 % 1,0 % 1,0 % 1,2 % 1,2 % 1,(-2) % 1,(-2) % 1,22 % 7,1 % 5000] 2 | [0,0,0,2,2,-2,-2,22,1,1,1,1,1,1,1,1,7,5000] 3 | [0 % 1,0 % 1,0 % 1,2 % 1,2 % 1,(-2) % 1,(-2) % 1,22 % 7,1 % 5000] 4 | [0,0,0,2,2,-2,-2,22,1,1,1,1,1,1,1,1,7,5000] 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith006.hs: -------------------------------------------------------------------------------- 1 | -- !!! printing Floats; was a bug in hbc (reported by andy) 2 | -- 3 | 4 | main = print ((fromIntegral (42 :: Int)) :: Float) 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith006.stdout: -------------------------------------------------------------------------------- 1 | 42.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith009.hs: -------------------------------------------------------------------------------- 1 | -- a prefix minus precedence test 2 | 3 | f :: Int -> Int -> Int -> Int 4 | f x y z = - x * y ^ z 5 | 6 | main = putStr (shows (f 5 2 3) "\n") 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith009.stdout: -------------------------------------------------------------------------------- 1 | -40 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith010.stdout: -------------------------------------------------------------------------------- 1 | [1,2,3,4,5,6,7,8,9,10] 2 | [] 3 | [1,3,5,7,9] 4 | [10,8,6,4,2] 5 | "abcdef" 6 | "" 7 | "acegikm" 8 | "mlkjihgfedcba" 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith014.stdout: -------------------------------------------------------------------------------- 1 | [-2,2] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith015.hs: -------------------------------------------------------------------------------- 1 | main = do 2 | print (map read strange_nums :: [Float]) 3 | print (map read strange_nums :: [Double]) 4 | where 5 | strange_nums = ["Infinity","NaN", "-Infinity"] 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith015.stdout: -------------------------------------------------------------------------------- 1 | [Infinity,NaN,-Infinity] 2 | [Infinity,NaN,-Infinity] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith017.stdout: -------------------------------------------------------------------------------- 1 | -1 2 | 18446744073709551615 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith018.stdout: -------------------------------------------------------------------------------- 1 | [-5,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,-1,-1,0,0,0] 2 | [-2,-2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/arith019.stdout: -------------------------------------------------------------------------------- 1 | 9301283852250390625 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/expfloat.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash #-} 2 | -- tests that expFloat# works (had linking problems on Windows) 3 | 4 | import GHC.Exts 5 | 6 | main = do 7 | print (F# (expFloat# 3.45#)) 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/expfloat.stdout: -------------------------------------------------------------------------------- 1 | 31.500393 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun009.stdout: -------------------------------------------------------------------------------- 1 | -2147483648 2 | -2147483648 3 | -2147483648 4 | False 5 | False 6 | -2147483648 7 | -2147483648 8 | -2147483648 9 | 2147483648 10 | 2147483648 11 | -2147483648 12 | -2147483648 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun009.stdout-alpha-dec-osf3: -------------------------------------------------------------------------------- 1 | -2147483648 2 | -2147483648 3 | -2147483648 4 | False 5 | False 6 | 2147483648 7 | 2147483648 8 | 2147483648 9 | 2147483648 10 | 2147483648 11 | -2147483648 12 | -2147483648 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun009.stdout-mips-sgi-irix: -------------------------------------------------------------------------------- 1 | -2147483648 2 | -2147483648 3 | -2147483648 4 | False 5 | False 6 | 2147483648 7 | 2147483648 8 | 2147483648 9 | 2147483648 10 | 2147483648 11 | -2147483648 12 | -2147483648 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun009.stdout-ws-64: -------------------------------------------------------------------------------- 1 | -2147483648 2 | -2147483648 3 | -2147483648 4 | False 5 | False 6 | 2147483648 7 | 2147483648 8 | 2147483648 9 | 2147483648 10 | 2147483648 11 | -2147483648 12 | -2147483648 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun009.stdout-x86_64-unknown-openbsd: -------------------------------------------------------------------------------- 1 | -2147483648 2 | -2147483648 3 | -2147483648 4 | False 5 | False 6 | 2147483648 7 | 2147483648 8 | 2147483648 9 | 2147483648 10 | 2147483648 11 | -2147483648 12 | -2147483648 13 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun010.stdout: -------------------------------------------------------------------------------- 1 | 11 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun011.hs: -------------------------------------------------------------------------------- 1 | import Data.Ratio 2 | main = print (fromRational (1 % 85070591730234615865843651857942052864) :: Float) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun011.stdout: -------------------------------------------------------------------------------- 1 | 1.1754944e-38 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun012.stdout: -------------------------------------------------------------------------------- 1 | [0,1,5,9,10,14,31,31,32,32,33] 2 | -2.147483648e9 3 | -2.1474836e9 4 | -2.147483648e9 5 | -2.1474836e9 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun012.stdout-ws-64: -------------------------------------------------------------------------------- 1 | [0,1,5,9,10,14,31,31,32,32,33] 2 | 2.147483648e9 3 | 8589934592 4 | 2.1474836e9 5 | 8589934592 6 | 2.147483648e9 7 | 8589934592 8 | 2.1474836e9 9 | 8589934592 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun013.stdout: -------------------------------------------------------------------------------- 1 | arithmetic overflow 2 | arithmetic overflow 3 | arithmetic overflow 4 | arithmetic overflow 5 | arithmetic overflow 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun015.stdout: -------------------------------------------------------------------------------- 1 | Infinity 2 | Infinity 3 | 1.0 4 | 1.0 5 | 1.0 6 | 1.0 7 | Infinity 8 | Infinity 9 | NaN 10 | NaN 11 | NaN 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun016.hs: -------------------------------------------------------------------------------- 1 | -- test for trac #8532 2 | 3 | import Data.Complex 4 | 5 | main :: IO () 6 | main = do 7 | print $ acosh ((-1)::Complex Double) 8 | print $ acosh ((-1)::Complex Float) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/numrun016.stdout: -------------------------------------------------------------------------------- 1 | 0.0 :+ 3.141592653589793 2 | 0.0 :+ 3.1415927 -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/numeric/quotRem2.stdout: -------------------------------------------------------------------------------- 1 | Worked 2 | Worked 3 | Worked 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedlists/overloadedlistsrun01.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedLists #-} 2 | 3 | main = do print ([] :: [Int]) 4 | print ([1,2,3] :: [Int]) 5 | print ((take 10 [1..]) :: [Int]) 6 | print (['a'..'e'] :: [Char]) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedlists/overloadedlistsrun01.stdout: -------------------------------------------------------------------------------- 1 | [] 2 | [1,2,3] 3 | [1,2,3,4,5,6,7,8,9,10] 4 | "abcde" 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedlists/overloadedlistsrun02.stdout: -------------------------------------------------------------------------------- 1 | fromList [] 2 | fromList "abc" 3 | fromList "aceg" 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedlists/overloadedlistsrun03.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 5 3 | 0 4 | 1 5 | 0 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedlists/overloadedlistsrun04.stdout: -------------------------------------------------------------------------------- 1 | empty 2 | two elements, the bigger one is 2 3 | two elements, the bigger one is 2 4 | two elements, the smaller one is 2 5 | two elements, the smaller one is 2 6 | one element 7 | else 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedlists/overloadedlistsrun05.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 7 3 | 1 4 | 6 5 | 2 6 | 3 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/T12243.stdout: -------------------------------------------------------------------------------- 1 | () 2 | "bar" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/hasfieldrun01.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | True 3 | 'x' 4 | "virtual" 5 | (42,'x',True,False) 6 | True 7 | True 8 | True 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/hasfieldrun02.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedlabelsrun01.stdout: -------------------------------------------------------------------------------- 1 | True 2 | False 3 | True 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedlabelsrun02.stdout: -------------------------------------------------------------------------------- 1 | Lam (Var Top) 2 | Lam (Lam (App (Var (Pop Top)) (Var Top))) 3 | App (Var Top) (Var Top) 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedlabelsrun03.stdout: -------------------------------------------------------------------------------- 1 | x 2 | "xy" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecflds_generics.stdout: -------------------------------------------------------------------------------- 1 | "foo" 2 | "foo" 3 | ["foo"] 4 | ["foo","bar"] 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecfldsrun01.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecfldsrun03.stdout: -------------------------------------------------------------------------------- 1 | True 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecfldsrun04.stdout: -------------------------------------------------------------------------------- 1 | data Main.R = Main.MkR {Main.foo :: GHC.Types.Int} 2 | Main.foo :: Main.R -> GHC.Types.Int 3 | Main.foo :: Main.R -> GHC.Types.Int 4 | Main.foo :: Main.R -> GHC.Types.Int 5 | 42 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecfldsrun05.stdout: -------------------------------------------------------------------------------- 1 | MkS {foo = 42} 2 | MkT {foo = 42} 3 | MkS {foo = 42} 4 | MkS {foo = 6} 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecfldsrun06.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedrecflds/overloadedrecfldsrun07.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | True 3 | 'x' 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedstrings/overloadedstringsrun01.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE OverloadedStrings #-} 2 | 3 | main = print $ "hello" ++ " world." 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/overloadedstrings/overloadedstringsrun01.stdout: -------------------------------------------------------------------------------- 1 | "hello world." 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/BinaryLiterals0.stdout: -------------------------------------------------------------------------------- 1 | [(0,60),(0,61),(0,610),(0,611),(0,60),(0,61),(0,610),(0,611)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/BinaryLiterals1.stdout: -------------------------------------------------------------------------------- 1 | [0,0,1,-1,1,-1,-201,-201,-255,-255] 2 | [0,1,201,3,255,1] 3 | [0,1,2,3,4,5,6,7,0,-1,-2,-3,-4,-5,-6,-7,340282366920938463463374607431768211455,-340282366920938463463374607431768211455] 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/BinaryLiterals2.stdout: -------------------------------------------------------------------------------- 1 | [0,0,1,-1,1,-1,-201,-201,-255,-255] 2 | [0,1,201,3,255,1] 3 | [0,1,2,3,4,5,6,7,0,-1,-2,-3,-4,-5,-6,-7,340282366920938463463374607431768211455,-340282366920938463463374607431768211455] 4 | [-128,127] 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/HexFloatLiterals.stdout: -------------------------------------------------------------------------------- 1 | [15.0,15.0625,15.00390625,15.0625,15.00390625,15.0625,15.00390625] 2 | 0x1.a86b851eb851fp7 3 | -0x1.9851ecp3 4 | -0x0p+0 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/NegativeZero.stdout: -------------------------------------------------------------------------------- 1 | False 2 | False 3 | True 4 | True 5 | False 6 | False 7 | True 8 | True 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/ParserMultiWayIf.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/T10807.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | 1 3 | 3 4 | 1 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/T1344.stdout: -------------------------------------------------------------------------------- 1 | '\1114111' 2 | Hello, World! 3 | "\9839\NUL00\NUL" 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/operator.stdout: -------------------------------------------------------------------------------- 1 | Hash {(#) = 3} 2 | Hash {(#) = 3} 3 | Hash {(#) = 3} 4 | Hash {(#) = 3} 5 | Hash {(#) = 3} 6 | Hash {(#) = 3} 7 | Hash {(#) = 3} 8 | Hash {(#) = 3} 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/operator2.hs: -------------------------------------------------------------------------------- 1 | 2 | (|..) :: a -> a -> a 3 | x |.. y = y 4 | 5 | f = [2|..3] 6 | 7 | main = putStrLn (show f) 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/operator2.stdout: -------------------------------------------------------------------------------- 1 | [3] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/readRun001.stdout: -------------------------------------------------------------------------------- 1 | -7 2 | -81 3 | -3 4 | -7 5 | 1 6 | -1 7 | -1 8 | True 9 | True 10 | -12 11 | 1 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/readRun002.stdout: -------------------------------------------------------------------------------- 1 | -1 2 | -1.0 3 | -1.0 4 | 81 5 | True 6 | False 7 | True 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/readRun003.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | 3.0 3 | 3.0 4 | True 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/parser/readRun004.stdout: -------------------------------------------------------------------------------- 1 | (3,(),4.0,'f',5.0,32,9.0,'t') 2 | [(True,'a'),(True,'b'),(True,'c')] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/T11224.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | 6 3 | 666 4 | 1 5 | 6 6 | 666 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/T11985.script: -------------------------------------------------------------------------------- 1 | :set -XPatternSynonyms 2 | 3 | pattern Point{x, y} = (x, y) 4 | (1, 2) { x = 3} 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/T11985.stdout: -------------------------------------------------------------------------------- 1 | (3,2) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/T14228.stdout: -------------------------------------------------------------------------------- 1 | Nothing' 2 | nothing 3 | Just' 4 | just 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/T9783.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | 44 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/bidir-explicit-scope.stdout: -------------------------------------------------------------------------------- 1 | () 2 | () 3 | () 4 | () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/bidir-explicit.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE PatternSynonyms #-} 2 | module Main where 3 | 4 | pattern First x <- x:_ where 5 | First x = [x] 6 | 7 | main = mapM_ print $ First () 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/bidir-explicit.stdout: -------------------------------------------------------------------------------- 1 | () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/eval.stdout: -------------------------------------------------------------------------------- 1 | True 2 | False 3 | False 4 | 5 | True 6 | False 7 | False 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/ex-prov-run.stdout: -------------------------------------------------------------------------------- 1 | True 2 | False 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/ghci.script: -------------------------------------------------------------------------------- 1 | :set -XPatternSynonyms 2 | 3 | pattern Single x = [x] 4 | :i Single 5 | let foo (Single x) = Single (not x) 6 | :t foo 7 | foo [True] 8 | foo [True, False] 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/ghci.stderr: -------------------------------------------------------------------------------- 1 | *** Exception: :5:5-35: Non-exhaustive patterns in function foo 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/ghci.stdout: -------------------------------------------------------------------------------- 1 | pattern Single :: a -> [a] -- Defined at :3:1 2 | foo :: [Bool] -> [Bool] 3 | [False] 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/match-unboxed.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | 44 3 | 42 4 | 44 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/match.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | 0 3 | 4 4 | 3 5 | 4 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/records-run.stdout: -------------------------------------------------------------------------------- 1 | ("a","b") 2 | "a" 3 | "b" 4 | ("c","b") 5 | ("fst","snd") 6 | 5 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/unboxed-wrapper.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE PatternSynonyms, MagicHash #-} 2 | module Main where 3 | 4 | import GHC.Base 5 | 6 | pattern P1 = 42# 7 | 8 | main = do 9 | print $ I# P1 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/patsyn/unboxed-wrapper.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/Conversions.stdout: -------------------------------------------------------------------------------- 1 | 4.9994036e11 2 | 4.999995e11 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/DeriveNull.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/DeriveNullTermination.stdout: -------------------------------------------------------------------------------- 1 | False 2 | False 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/MethSharing.stdout: -------------------------------------------------------------------------------- 1 | 1.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T10359.stdout: -------------------------------------------------------------------------------- 1 | 2000.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T12791.stdout: -------------------------------------------------------------------------------- 1 | 200010000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T12996.stdout: -------------------------------------------------------------------------------- 1 | [1] 2 | [1] 3 | [1] 4 | [1] 5 | [1] 6 | [1] 7 | [1] 8 | [1] 9 | [1] 10 | [1] 11 | [1] 12 | [1] 13 | [1] 14 | [1] 15 | [1] 16 | [1] 17 | [1] 18 | [1] 19 | [1] 20 | [1] 21 | [1] 22 | [1] 23 | [1] 24 | [1] 25 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T13001.hs: -------------------------------------------------------------------------------- 1 | import Data.IORef 2 | 3 | main :: IO () 4 | main = do 5 | ref <- newIORef 10000 6 | n <- readIORef ref 7 | print $ length $ [0::Int, 2 .. n] 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T13001.stdout: -------------------------------------------------------------------------------- 1 | 5001 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T13623.stdout: -------------------------------------------------------------------------------- 1 | 575740560 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T14936.stdout: -------------------------------------------------------------------------------- 1 | "Done" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T15263.stdout: -------------------------------------------------------------------------------- 1 | zip3: 200020000 2 | zipWith3: 200020000 3 | zipWith4: 400040000 4 | zipWith5: 800080000 5 | zipWith6: 1600160000 6 | zipWith7: 3200320000 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T3245.stdout: -------------------------------------------------------------------------------- 1 | count1 2 | Result: 0 3 | Time(sec): 0 4 | Result: 0 5 | Time(sec): 0 6 | Result: 0 7 | Time(sec): 0 8 | 9 | count2 10 | Result: 0 11 | Time(sec): 0 12 | Result: 0 13 | Time(sec): 0 14 | Result: 0 15 | Time(sec): 0 16 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T3586.stdout: -------------------------------------------------------------------------------- 1 | 2.79999863e8 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T3736.stdout: -------------------------------------------------------------------------------- 1 | Match 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T4321.stdout: -------------------------------------------------------------------------------- 1 | 3.1415926535897643 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T4474a.stdout: -------------------------------------------------------------------------------- 1 | 67108864 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T4474b.stdout: -------------------------------------------------------------------------------- 1 | 67108864 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T4474c.stdout: -------------------------------------------------------------------------------- 1 | 67108864 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T4830.stdout: -------------------------------------------------------------------------------- 1 | 3.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T4978.stdout: -------------------------------------------------------------------------------- 1 | 10000000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T5113.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T5205.stdout: -------------------------------------------------------------------------------- 1 | Done 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T5237.stdout: -------------------------------------------------------------------------------- 1 | 1.082323233710861 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T5536.hs: -------------------------------------------------------------------------------- 1 | 2 | main :: IO () 3 | main = do writeFile "T5536.data" (replicate 10000000 'a') 4 | readFile "T5536.data" >>= putStr 5 | 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T5835.stdout: -------------------------------------------------------------------------------- 1 | 200010000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7257.stdout: -------------------------------------------------------------------------------- 1 | 100001 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7436.stdout: -------------------------------------------------------------------------------- 1 | "end" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7507.stdout: -------------------------------------------------------------------------------- 1 | 10485760 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7850.hs: -------------------------------------------------------------------------------- 1 | 2 | {-# LANGUAGE BangPatterns #-} 3 | 4 | main :: IO () 5 | main = print $ ack 4 1 6 | 7 | ack :: Int -> Int -> Int 8 | ack 0 !n = n+1 9 | ack m 0 = ack (m-1) 1 10 | ack m n = ack (m-1) $ ack m (n-1) 11 | 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7850.stdout: -------------------------------------------------------------------------------- 1 | 65533 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7954.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | norm :: [Double] -> Double 4 | norm = sqrt . sum . map (\x -> x*x) 5 | 6 | main :: IO () 7 | main = print (norm (enumFromTo 0 10000000) > 100) 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T7954.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T8472.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T876.stdout: -------------------------------------------------------------------------------- 1 | 50005000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T9203.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Data.Typeable 4 | 5 | f :: Typeable a => Int -> a -> TypeRep 6 | f 0 a = typeOf a 7 | f n a = f (n-1) [a] 8 | 9 | main = print (f 50000 () == f 50001 ()) 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T9203.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T9339.hs: -------------------------------------------------------------------------------- 1 | -- Tests that `last` successfully fuses. 2 | 3 | main :: IO () 4 | main = print $ last $ filter odd $ [1::Int ..10000000] 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/T9339.stdout: -------------------------------------------------------------------------------- 1 | 9999999 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/perf/lazy-bs-alloc.hs: -------------------------------------------------------------------------------- 1 | module Main (main) where 2 | 3 | import System.Environment (getArgs) 4 | import qualified Data.ByteString.Lazy as L 5 | 6 | main :: IO () 7 | main = do 8 | (file : _) <- getArgs 9 | L.readFile file >>= L.putStr 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/polykinds/Freeman.stdout: -------------------------------------------------------------------------------- 1 | Succ1 0 (Succ2 1 (Succ1 2 (Succ2 3 (Succ1 4 (Succ2 5 Zero))))) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/polykinds/MonoidsFD.stdout: -------------------------------------------------------------------------------- 1 | Sum 2 2 | Product 6 3 | Wrapper {runWrapper = "hello, world"} 4 | Sum 7 5 | Sum 2 6 | Product 6 7 | Wrapper {runWrapper = "hello"} 8 | Wrapper {runWrapper = "hello, world"} 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/polykinds/MonoidsTF.stdout: -------------------------------------------------------------------------------- 1 | Sum 2 2 | Product 6 3 | Wrapper {runWrapper = "hello, world"} 4 | Sum 7 5 | Sum 2 6 | Product 6 7 | Wrapper {runWrapper = "hello"} 8 | Wrapper {runWrapper = "hello, world"} 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/polykinds/PolyKinds09.stdout: -------------------------------------------------------------------------------- 1 | 9 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/polykinds/PolyKinds10.stdout: -------------------------------------------------------------------------------- 1 | ["1","2","3","4","5","6","7","8","9","10"] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/ArithInt16.stdout: -------------------------------------------------------------------------------- 1 | Pass: passing Int16# on the stack 2 | Pass: negateInt16# 3 | Pass: plusInt16# 4 | Pass: subInt16# 5 | Pass: timesInt16# 6 | Pass: remInt16# 7 | Pass: quotInt16# 8 | Pass: quotRemInt16# 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/ArithInt8.stdout: -------------------------------------------------------------------------------- 1 | Pass: passing Int8# on the stack 2 | Pass: negateInt8# 3 | Pass: plusInt8# 4 | Pass: subInt8# 5 | Pass: timesInt8# 6 | Pass: remInt8# 7 | Pass: quotInt8# 8 | Pass: quotRemInt8# 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/ArithWord16.stdout: -------------------------------------------------------------------------------- 1 | Pass: passing Word16# on the stack 2 | Pass: notWord16# 3 | Pass: plusWord16# 4 | Pass: subWord16# 5 | Pass: timesWord16# 6 | Pass: remWord16# 7 | Pass: quotWord16# 8 | Pass: quotRemWord16# 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/ArithWord8.stdout: -------------------------------------------------------------------------------- 1 | Pass: passing Word8# on the stack 2 | Pass: notWord8# 3 | Pass: plusWord8# 4 | Pass: subWord8# 5 | Pass: timesWord8# 6 | Pass: remWord8# 7 | Pass: quotWord8# 8 | Pass: quotRemWord8# 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/CmpInt16.stdout: -------------------------------------------------------------------------------- 1 | Pass: (==) 2 | Pass: (/=) 3 | Pass: (<) 4 | Pass: (>) 5 | Pass: (<=) 6 | Pass: (>=) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/CmpInt8.stdout: -------------------------------------------------------------------------------- 1 | Pass: (==) 2 | Pass: (/=) 3 | Pass: (<) 4 | Pass: (>) 5 | Pass: (<=) 6 | Pass: (>=) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/CmpWord16.stdout: -------------------------------------------------------------------------------- 1 | Pass: (==) 2 | Pass: (/=) 3 | Pass: (<) 4 | Pass: (>) 5 | Pass: (<=) 6 | Pass: (>=) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/CmpWord8.stdout: -------------------------------------------------------------------------------- 1 | Pass: (==) 2 | Pass: (/=) 3 | Pass: (<) 4 | Pass: (>) 5 | Pass: (<=) 6 | Pass: (>=) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/ShowPrim.stdout: -------------------------------------------------------------------------------- 1 | Test1 (narrowInt8# 1#) (narrowWord8# 2##) 2 | Test2 (narrowInt16# 1#) (narrowWord16# 2##) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/T10481.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash #-} 2 | 3 | import GHC.Exts 4 | import Control.Exception 5 | 6 | f :: ArithException -> Int# 7 | f x = raise# (toException x) 8 | 9 | main = print (I# (f Overflow)) 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/primops/T10481.stderr: -------------------------------------------------------------------------------- 1 | T10481: arithmetic overflow 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rebindable/RebindableFailA.stderr: -------------------------------------------------------------------------------- 1 | RebindableFailA: Failed with error 2 | CallStack (from HasCallStack): 3 | error, called at RebindableFailA.hs:10:10 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rebindable/RebindableFailB.stdout: -------------------------------------------------------------------------------- 1 | Just () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rebindable/T5038.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE RebindableSyntax #-} 2 | module Main (main) where 3 | 4 | import Prelude 5 | 6 | ifThenElse True t f = f 7 | ifThenElse False t f = t 8 | 9 | main = print (if True then 1 else 2 :: Int) 10 | -- Should print 2! 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rebindable/T5038.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rebindable/rebindable10.stdout: -------------------------------------------------------------------------------- 1 | "this works" 2 | "this works" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rebindable/rebindable7.stdout: -------------------------------------------------------------------------------- 1 | 6 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/EventlogOutput.hs: -------------------------------------------------------------------------------- 1 | main = return () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/GcStaticPointers.stdout: -------------------------------------------------------------------------------- 1 | 400 2 | 400 3 | 800 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/InternalCounters.stdout: -------------------------------------------------------------------------------- 1 | Internal Counters: -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T10017.stdout: -------------------------------------------------------------------------------- 1 | Received my signal 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T10728.stdout: -------------------------------------------------------------------------------- 1 | maxN Successful 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T11108.stdout: -------------------------------------------------------------------------------- 1 | 1001 2 | 1002 3 | 1003 4 | 1004 5 | 1005 6 | 1006 7 | 1007 8 | 1008 9 | 1009 10 | 1010 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T11788.c: -------------------------------------------------------------------------------- 1 | int a() 2 | { 3 | return 4; 4 | } 5 | 6 | int b() 7 | { 8 | return a()*a(); 9 | } 10 | 11 | int c() 12 | { 13 | return a()*b(); 14 | } 15 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T11788.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | foreign import ccall "c" c_exp :: Int 4 | 5 | main = print c_exp 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T11788.stdout: -------------------------------------------------------------------------------- 1 | 64 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T12497.stdout: -------------------------------------------------------------------------------- 1 | "Hello World!" 2 | "Hello Again World!" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T12903.stdout: -------------------------------------------------------------------------------- 1 | caught 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T13287.hs: -------------------------------------------------------------------------------- 1 | import System.Environment (getArgs) 2 | 3 | main :: IO () 4 | main = getArgs >>= print 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T13287.stdout: -------------------------------------------------------------------------------- 1 | ["a1","--","a2","+RTS","-RTS","a3"] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T13617.c: -------------------------------------------------------------------------------- 1 | int mult(int a[], int b[], int N) 2 | { 3 | int sum = 0; 4 | for(int i=0; i Integer 6 | fuc 0 = 1 7 | fuc n = n * fuc (n - 1) 8 | 9 | main :: IO () 10 | main = do 11 | let x = fuc 30000 12 | timeout 1000 (print x) 13 | print (x > 0) 14 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T14497.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T15261a.hs: -------------------------------------------------------------------------------- 1 | main :: IO () 2 | main = putStrLn "T15261a" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T15261a.stdout: -------------------------------------------------------------------------------- 1 | ,("Flag -with-rtsopts", "-t -s") 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T15261b.hs: -------------------------------------------------------------------------------- 1 | main :: IO () 2 | main = putStrLn "T15261b" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T15261b.stdout: -------------------------------------------------------------------------------- 1 | ,("Flag -with-rtsopts", "") 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T2783.hs: -------------------------------------------------------------------------------- 1 | main = print $ do x <- [ 0 .. 5 ] ; let { y = 5 - y } ; return y 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T2783.stderr: -------------------------------------------------------------------------------- 1 | T2783: <> 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T3236.c: -------------------------------------------------------------------------------- 1 | #include "Rts.h" 2 | 3 | int main (int argc, char *argv[]) 4 | { 5 | // should fail: RTS is not initialised 6 | rts_lock(); 7 | } 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T3236.stderr: -------------------------------------------------------------------------------- 1 | newBoundTask: RTS is not initialised; call hs_init() first 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T4059.stdout: -------------------------------------------------------------------------------- 1 | 7.0 2 | 92.0 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T4059_c.c: -------------------------------------------------------------------------------- 1 | 2 | double deriv(double f(double), double x, double h) { 3 | return f(x) + h; 4 | } 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T4850.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5423.stdout: -------------------------------------------------------------------------------- 1 | 120 2 | 111 112 113 114 115 116 117 118 119 120 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_dyn_asm.stdout: -------------------------------------------------------------------------------- 1 | initArray1 2 | initArray2 3 | success 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_dyn_asm.stdout-darwin: -------------------------------------------------------------------------------- 1 | modInitFunc1 2 | modInitFunc2 3 | success 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_dyn_asm.stdout-mingw32: -------------------------------------------------------------------------------- 1 | ctors1 2 | ctors2 3 | success 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_dyn_gcc.stdout: -------------------------------------------------------------------------------- 1 | initializer run 2 | success 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_gcc.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | static void initializer(void) __attribute__((constructor)); 4 | static void initializer(void) 5 | { 6 | printf("initializer run\n"); 7 | fflush(stdout); 8 | } 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_v_asm.stdout: -------------------------------------------------------------------------------- 1 | initArray1 2 | initArray2 3 | ctors1 4 | ctors2 5 | success 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_v_asm_a.stdout: -------------------------------------------------------------------------------- 1 | initArray1 2 | initArray2 3 | success -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_v_asm_a.stdout-darwin: -------------------------------------------------------------------------------- 1 | modInitFunc1 2 | modInitFunc2 3 | success 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_v_asm_a.stdout-mingw32: -------------------------------------------------------------------------------- 1 | ctors1 2 | ctors2 3 | success 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_v_asm_b.stdout: -------------------------------------------------------------------------------- 1 | ctors1 2 | ctors2 3 | success -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5435_v_gcc.stdout: -------------------------------------------------------------------------------- 1 | initializer run 2 | success 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5993.hs: -------------------------------------------------------------------------------- 1 | import Control.Concurrent 2 | main = do 3 | m <- newEmptyMVar 4 | forkIO $ putStrLn "Hello World!" >> putMVar m () 5 | takeMVar m 6 | 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T5993.stdout: -------------------------------------------------------------------------------- 1 | Hello World! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7037.hs: -------------------------------------------------------------------------------- 1 | main = print "ok" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7037.stdout: -------------------------------------------------------------------------------- 1 | "ok" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7037_main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) { 5 | char * T7037_CONST args[2] = {"T7037", NULL}; 6 | execv("./T7037", args); 7 | } 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ForeignFunctionInterface #-} 2 | 3 | module Main where 4 | 5 | foreign import ccall "global.h printx" 6 | c_printx :: IO () 7 | 8 | main = do 9 | c_printx 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040.stdout: -------------------------------------------------------------------------------- 1 | x: 0 2 | x: 1 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040_c.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "T7040_c.h" 3 | 4 | int x = 0; 5 | 6 | void printx() { 7 | printf("x: %d\n", x); 8 | x = 1; 9 | printf("x: %d\n", x); 10 | } 11 | 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040_c.h: -------------------------------------------------------------------------------- 1 | void printx(); 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040_ghci.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ForeignFunctionInterface #-} 2 | 3 | module Main where 4 | 5 | foreign import ccall "global.h printx" 6 | c_printx :: IO () 7 | 8 | main = do 9 | c_printx 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040_ghci.stdout: -------------------------------------------------------------------------------- 1 | x: 0 2 | x: 1 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7040_ghci_c.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "T7040_c.h" 3 | 4 | int x = 0; 5 | 6 | void printx() { 7 | printf("x: %d\n", x); 8 | x = 1; 9 | printf("x: %d\n", x); 10 | } 11 | 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7087.stderr: -------------------------------------------------------------------------------- 1 | T7087: thread killed 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7160.stderr: -------------------------------------------------------------------------------- 1 | finalizer 2 (p) 2 | finalizer 1 (p) 3 | finalizer 2 (q) 4 | finalizer 1 (q) 5 | finalizer 2 (r) 6 | finalizer 1 (r) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7227.hs: -------------------------------------------------------------------------------- 1 | main = return () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7636.hs: -------------------------------------------------------------------------------- 1 | import GHC.Conc.Sync 2 | import System.Environment 3 | 4 | test n = atomically $ f [1..n] 5 | where 6 | f [] = retry 7 | f (x:xs) = do 8 | ys <- f xs 9 | return (x:ys) 10 | 11 | main = do 12 | [n] <- getArgs 13 | test (read n) 14 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T7636.stderr: -------------------------------------------------------------------------------- 1 | T7636: thread blocked indefinitely in an STM transaction 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T8035.stdout: -------------------------------------------------------------------------------- 1 | ok 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T8308.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE BangPatterns #-} 2 | data Test = Test !Int 3 | 4 | {-# NOINLINE f #-} 5 | f a = Test (a + 1) 6 | 7 | main = let (Test x) = f 1 in print x 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T8308.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9078.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Control.Monad 4 | import System.Mem.StableName 5 | 6 | main :: IO () 7 | main = replicateM_ 500000 (makeStableName foo) 8 | 9 | foo :: Int 10 | foo = 1 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9405.hs: -------------------------------------------------------------------------------- 1 | import Control.Concurrent 2 | 3 | main = threadDelay 2000000 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9405.stdout: -------------------------------------------------------------------------------- 1 | [1 of 1] Compiling Main ( T9405.hs, T9405.o ) 2 | Linking T9405 ... 3 | Ticky-Ticky 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_01.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main :: IO () 4 | main = return () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_01.stderr: -------------------------------------------------------------------------------- 1 | T9839_01: flag -T given an argument when none was expected: -T-s 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_02.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main :: IO () 4 | main = return () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_02.stderr: -------------------------------------------------------------------------------- 1 | T9839_02: flag -Pa given an argument when none was expected: -Pax 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_03.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main :: IO () 4 | main = return () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_03.stderr: -------------------------------------------------------------------------------- 1 | T9839_03: flag -P given an argument when none was expected: -Px 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_04.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main :: IO () 4 | main = return () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_05.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main :: IO () 4 | main = return () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_05.stderr: -------------------------------------------------------------------------------- 1 | T9839_05: flag -x given an argument when none was expected: -xcx 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_06.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main :: IO () 4 | main = return () 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/T9839_06.stderr: -------------------------------------------------------------------------------- 1 | T9839_06: flag -x given an argument when none was expected: -xtx 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/alloccounter1.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/atomicxchg.c: -------------------------------------------------------------------------------- 1 | #include "Rts.h" 2 | 3 | StgWord i; 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | StgWord j; 8 | 9 | i = 0; 10 | j = xchg(&i,42); 11 | CHECK(j == 0); 12 | CHECK(i == 42); 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/bug1010.stdout: -------------------------------------------------------------------------------- 1 | 10020 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/derefnull.stderr-x86_64-unknown-openbsd: -------------------------------------------------------------------------------- 1 | Segmentation fault 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/divbyzero.stderr-x86_64-unknown-openbsd: -------------------------------------------------------------------------------- 1 | Floating point exception 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/ffishutdown.stderr: -------------------------------------------------------------------------------- 1 | ffishutdown: Main_dui: interrupted 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/keep-cafs.stdout: -------------------------------------------------------------------------------- 1 | 1000 2 | 1001 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/libfoo_T2615.c: -------------------------------------------------------------------------------- 1 | void foo( void ); 2 | void foo() {} 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/libfoo_script_T2615.so: -------------------------------------------------------------------------------- 1 | /* GNU ld script 2 | Use the shared library, but some functions are only in 3 | the static library, so try that secondarily. */ 4 | OUTPUT_FORMAT(elf64-x86-64) 5 | GROUP ( libfoo_T2615.so ) 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/linker_error2.c: -------------------------------------------------------------------------------- 1 | extern int bar; 2 | 3 | int foo(void) 4 | { 5 | return bar; 6 | } 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/linker_error3.c: -------------------------------------------------------------------------------- 1 | extern int bar; 2 | 3 | int stg_upd_frame_info(void) 4 | { 5 | return bar; 6 | } 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | import Data.Array.IO 3 | import Control.Monad 4 | main = do 5 | arrs <- sequence $ repeat $ (newArray_ (0,2^28) :: IO (IOUArray Int Int)) 6 | -- larger than 2^28 causes other problems... 7 | print (length arrs) 8 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr: -------------------------------------------------------------------------------- 1 | outofmem.exe: Out of memory 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr-i386-apple-darwin: -------------------------------------------------------------------------------- 1 | outofmem: memory allocation failed (requested 1074790400 bytes) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr-i386-unknown-mingw32: -------------------------------------------------------------------------------- 1 | outofmem.exe: Out of memory 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr-powerpc-apple-darwin: -------------------------------------------------------------------------------- 1 | outofmem: memory allocation failed (requested 1074790400 bytes) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr-ws-32: -------------------------------------------------------------------------------- 1 | outofmem: out of memory (requested 1074790400 bytes) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr-ws-64: -------------------------------------------------------------------------------- 1 | outofmem: out of memory 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stderr-x86_64-unknown-mingw32: -------------------------------------------------------------------------------- 1 | outofmem.exe: getMBlocks: VirtualAlloc MEM_COMMIT failed: The paging file is too small for this operation to complete. 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem.stdout: -------------------------------------------------------------------------------- 1 | exit(251) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem2.stderr: -------------------------------------------------------------------------------- 1 | outofmem2: Heap exhausted; 2 | outofmem2: Current maximum heap size is 5242880 bytes (5 MB). 3 | outofmem2: Use `+RTS -M' to increase it. 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/outofmem2.stdout: -------------------------------------------------------------------------------- 1 | exit(251) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/overflow1.stderr: -------------------------------------------------------------------------------- 1 | overflow1: Out of memory 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/overflow2.stderr: -------------------------------------------------------------------------------- 1 | overflow2: Out of memory 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/overflow3.stderr: -------------------------------------------------------------------------------- 1 | overflow3: Out of memory 2 | 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/rtsflags001.hs: -------------------------------------------------------------------------------- 1 | main = return () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/rtsflags001.stderr-ws-32: -------------------------------------------------------------------------------- 1 | rtsflags001: error in RTS option -H0m: size outside allowed range (4096 - 4294967295) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/rtsflags001.stderr-ws-64: -------------------------------------------------------------------------------- 1 | rtsflags001: error in RTS option -H0m: size outside allowed range (4096 - 18446744073709551615) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/rtsflags002.hs: -------------------------------------------------------------------------------- 1 | main = return () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/rtsflags002.stderr: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/stablename001.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/stack002.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE CPP #-} 2 | #include "stack001.hs" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/stack003.stdout: -------------------------------------------------------------------------------- 1 | 500001 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/stack004.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | import Control.Monad 4 | import GHC.RTS.Flags 5 | 6 | -- Ensure that +RTS -K0 is parsed 7 | main :: IO () 8 | main = do 9 | flags <- getGCFlags 10 | unless (maxStkSize flags == 0) $ putStrLn "uh oh" 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/traceBinaryEvent.stderr: -------------------------------------------------------------------------------- 1 | traceBinaryEvent: Event size exceeds EVENT_PAYLOAD_SIZE_MAX, bail out 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/traceEvent.hs: -------------------------------------------------------------------------------- 1 | import Data.Word 2 | import Debug.Trace 3 | 4 | main = do 5 | traceEventIO "testing" 6 | traceEventIO "%s" -- see #3874 7 | traceEventIO $ replicate (maxSize + 1) 'A' 8 | 9 | maxSize :: Int 10 | maxSize = fromIntegral (maxBound :: Word16) 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/rts/traceEvent.stderr: -------------------------------------------------------------------------------- 1 | traceEvent: Event size exceeds EVENT_PAYLOAD_SIZE_MAX, bail out 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/safeHaskell/SafeLang04.stdout: -------------------------------------------------------------------------------- 1 | looking for T3 2 | in space [(T1,"a"),(T2,"b"),(T3,"c")] 3 | Found: "a" 4 | Rules Disabled: NO 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/safeHaskell/SafeLang05.stdout: -------------------------------------------------------------------------------- 1 | looking for T3 2 | in space [(T1,"a"),(T2,"b"),(T3,"c")] 3 | Found: "c" 4 | Rules Disabled: YES 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/AmapCoerce.stdout: -------------------------------------------------------------------------------- 1 | yes 2 | yes 3 | yes 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/SeqRule.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T10830.hs: -------------------------------------------------------------------------------- 1 | import GHC.OldList 2 | main :: IO () 3 | main = maximumBy compare [1..10000] `seq` return () 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T11172.stdout: -------------------------------------------------------------------------------- 1 | Right (Left (),JSONState [] () ()) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T11731.stderr: -------------------------------------------------------------------------------- 1 | Evaluated (should only happen once) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T12689a.stdout: -------------------------------------------------------------------------------- 1 | MkT1Good 2 | MkT2Good 42 3 | MkT3Good 42 4 | MkT4Good 42 5 | MkT5Good 42 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T12689broken.hs: -------------------------------------------------------------------------------- 1 | data T6 = MkT6Bad {-# UNPACK #-} !Int | MkT6Good {-# UNPACK #-} !Int deriving Show 2 | 3 | {-# RULES 4 | 5 | "T6" [1] forall x. MkT6Bad x = MkT6Good x 6 | #-} 7 | 8 | main = do 9 | print (MkT6Bad 42) -- late rule 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T12689broken.stdout: -------------------------------------------------------------------------------- 1 | MkT6Good 42 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T13172.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | f :: Word -> Bool 4 | f n = case n+1 of 5 | 0 -> True 6 | _ -> False 7 | {-# NOINLINE f #-} 8 | 9 | main = do 10 | putStrLn "Word: wrap (0-1)" 11 | print (f (-1)) 12 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T13172.stdout: -------------------------------------------------------------------------------- 1 | Word: wrap (0-1) 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T13227.hs: -------------------------------------------------------------------------------- 1 | import Debug.Trace 2 | 3 | g x expensive ys = let h = \y -> y + expensive x 4 | in map h ys 5 | {-# NOINLINE g #-} 6 | 7 | foo x = trace "Evaluate me only once!" x 8 | 9 | main = sum (g 1 foo [1,2,3]) `seq` return () 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T13227.stderr: -------------------------------------------------------------------------------- 1 | Evaluate me only once! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T13733.stdout: -------------------------------------------------------------------------------- 1 | ok 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T14178.stdout: -------------------------------------------------------------------------------- 1 | 8 2 | OK 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T14868.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS -O -g #-} 2 | main = print (4, "foo") 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T14868.stdout: -------------------------------------------------------------------------------- 1 | (4,"foo") 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T14894.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -g1 -O #-} 2 | import System.Environment 3 | summap :: (Int -> Int) -> (Int -> Int) 4 | summap f n = f 10 5 | {-# NOINLINE summap #-} 6 | 7 | main = do 8 | n <- length `fmap` getArgs 9 | print $ summap (+ n) n 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T14894.stdout: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T15114.stdout: -------------------------------------------------------------------------------- 1 | all is well 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T15436.stdout: -------------------------------------------------------------------------------- 1 | [X AL,X AK,X AZ,X AR,X CA,X CO,X CT,X DE,X FL] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T15840.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T15840a.stdout: -------------------------------------------------------------------------------- 1 | Case-of-known-constructor triggered (good!) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T16208.stdout: -------------------------------------------------------------------------------- 1 | good 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T2110.stdout: -------------------------------------------------------------------------------- 1 | yes 2 | yes 3 | yes 4 | yes 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T2486.stderr: -------------------------------------------------------------------------------- 1 | 2 | ==================== Tidy Core rules ==================== 3 | 4 | 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T3403.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 0 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T3437.stdout: -------------------------------------------------------------------------------- 1 | [] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T3591.stdout: -------------------------------------------------------------------------------- 1 | ((5,2),(1,2,6)) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T3959.stdout: -------------------------------------------------------------------------------- 1 | () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T457.hs: -------------------------------------------------------------------------------- 1 | f x = case x of 2 | x@True -> \y -> x && y 3 | x@False -> \y -> x && y 4 | 5 | main = putStrLn $ f (error "Correct") `seq` "Error" 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T457.stderr: -------------------------------------------------------------------------------- 1 | T457: Correct 2 | CallStack (from ImplicitParams): 3 | error, called at T457.hs:5:22 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T4814.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5315.stdout: -------------------------------------------------------------------------------- 1 | Test 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5453.stdout: -------------------------------------------------------------------------------- 1 | OK 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5587.stderr: -------------------------------------------------------------------------------- 1 | T5587: hidden error 2 | CallStack (from ImplicitParams): 3 | error, called at T5587.hs:7:15 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5625.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | main = do { let a = \x -> seq undefined (+1) 4 | ; print $ (a `seq` a [] `seq` id) [0] } 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5625.stderr: -------------------------------------------------------------------------------- 1 | T5625: Prelude.undefined 2 | CallStack (from ImplicitParams): 3 | error, called at libraries/base/GHC/Err.hs:43:14 in base:GHC.Err 4 | undefined, called at T5625.hs:3:31 in main:Main 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5915.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | test = seq (seq id (\a -> undefined a)) 4 | 5 | main = print (test [0]) 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5915.stdout: -------------------------------------------------------------------------------- 1 | [0] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5920.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T5997.stdout: -------------------------------------------------------------------------------- 1 | 1.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T7101.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T7611.stdout: -------------------------------------------------------------------------------- 1 | yes 2 | yes 3 | yes 4 | yes 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T7924.stderr: -------------------------------------------------------------------------------- 1 | T7924: Boom 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T9128.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/T9390.stdout: -------------------------------------------------------------------------------- 1 | 'B' 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/runST.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun001.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun002.stderr: -------------------------------------------------------------------------------- 1 | Yes 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun002.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun003.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun004.stdout: -------------------------------------------------------------------------------- 1 | (62502999915,62502999915) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun005.stdout: -------------------------------------------------------------------------------- 1 | 354224848179261915075 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun007.stdout: -------------------------------------------------------------------------------- 1 | -0x14 2 | -0x3 3 | 0x7ffffffd 4 | 0xffffffec 5 | 0x7ffffffd 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun007.stdout-ws-64: -------------------------------------------------------------------------------- 1 | -0x14 2 | -0x3 3 | 0x7ffffffffffffffd 4 | 0xffffffffffffffec 5 | 0x7ffffffffffffffd 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun008.stdout: -------------------------------------------------------------------------------- 1 | "RULE FIRED" 2 | "NOT FIRED" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun009.stdout: -------------------------------------------------------------------------------- 1 | 20 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun010.stderr: -------------------------------------------------------------------------------- 1 | simplrun010: Heap exhausted; 2 | simplrun010: Current maximum heap size is 10485760 bytes (10 MB). 3 | simplrun010: Use `+RTS -M' to increase it. 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplCore/simplrun011.stdout: -------------------------------------------------------------------------------- 1 | fired: f1 2 | fired: f1 3 | not fired: f2 4 | not fired: f2 5 | fired: f3 6 | fired: f3 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplStg/T13536.stderr: -------------------------------------------------------------------------------- 1 | evaluated once, as it should 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplStg/T13536.stdout: -------------------------------------------------------------------------------- 1 | Just 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplStg/T13536a.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/simplStg/T9291.stdout: -------------------------------------------------------------------------------- 1 | yes 2 | yes 3 | yes 4 | yes 5 | no 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T10148.stderr: -------------------------------------------------------------------------------- 1 | adj 99 2 | adj 99 3 | adj 99 4 | adj 99 5 | adj 99 6 | adj 99 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T10218.stdout: -------------------------------------------------------------------------------- 1 | 14 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T11555a.stdout: -------------------------------------------------------------------------------- 1 | CAUGHT 2 | CAUGHT 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T12368.stderr: -------------------------------------------------------------------------------- 1 | T12368: This is good! 2 | CallStack (from HasCallStack): 3 | error, called at T12368.hs:24:22 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T12368a.stderr: -------------------------------------------------------------------------------- 1 | T12368a: This is good! 2 | CallStack (from HasCallStack): 3 | error, called at T12368a.hs:22:17 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T13380.stderr: -------------------------------------------------------------------------------- 1 | T13380: user error (What) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T16197.stdout: -------------------------------------------------------------------------------- 1 | Evaluated True 2 | Evaluated True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T7649.stdout: -------------------------------------------------------------------------------- 1 | "Got Nothing" 2 | "Got Just 5" 3 | "g Got something" 4 | h exception 5 | i exception 6 | Done 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/T9254.stdout: -------------------------------------------------------------------------------- 1 | () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/strun001.stdout: -------------------------------------------------------------------------------- 1 | (('a',True),True) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/strun002.stderr: -------------------------------------------------------------------------------- 1 | strun002: Variable not found: (2) hello 2 | CallStack (from ImplicitParams): 3 | error, called at strun002.hs:7:11 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/strun003.stdout: -------------------------------------------------------------------------------- 1 | ok 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/strun004.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | f 0 = 0 4 | f x = x + g (x-1) 5 | 6 | g 0 = 0 7 | g x = x - f (x-1) 8 | 9 | main = print (f 300) 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/strAnal/strun004.stdout: -------------------------------------------------------------------------------- 1 | 300 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/Defer01.stdout: -------------------------------------------------------------------------------- 1 | "No errors!" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/EtaExpandLevPoly.stdout: -------------------------------------------------------------------------------- 1 | True 2 | 3 3 | 8 4 | 8 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/IPRun.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | 5 3 | 5 4 | 5 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/KindInvariant.stderr: -------------------------------------------------------------------------------- 1 | 2 | :1:3: error: 3 | • Expected kind ‘* -> *’, 4 | but ‘State#’ has kind ‘* -> TYPE ('TupleRep '[])’ 5 | • In the first argument of ‘T’, namely ‘State#’ 6 | In the type ‘T State#’ 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/KindInvariant.stdout: -------------------------------------------------------------------------------- 1 | T State# :: * 2 | T State# :: * 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T10284.stderr: -------------------------------------------------------------------------------- 1 | T10284: T10284.hs:7:5: error: 2 | • Couldn't match expected type ‘Int’ with actual type ‘Char’ 3 | • In the expression: 'a' 4 | In an equation for ‘a’: a = 'a' 5 | (deferred type error) 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T10284.stdout: -------------------------------------------------------------------------------- 1 | As expected, TypeError: T10284.hs:7:5: error: 2 | • Couldn't match expected type ‘Int’ with actual type ‘Char’ 3 | • In the expression: 'a' 4 | In an equation for ‘a’: a = 'a' 5 | (deferred type error) 6 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T10845.stdout: -------------------------------------------------------------------------------- 1 | CallStack (from HasCallStack): 2 | f1, called at T10845.hs:13:38 in main:Main 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T10846.stdout: -------------------------------------------------------------------------------- 1 | [18] 2 | [19] 3 | [20] 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T11049.stderr: -------------------------------------------------------------------------------- 1 | T11049: look ma, no stack! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T11049.stdout: -------------------------------------------------------------------------------- 1 | [8] 2 | [] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T11120.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash, DataKinds #-} 2 | -- See also TypeOf.hs 3 | 4 | import GHC.Prim 5 | import Data.Typeable 6 | 7 | data CharHash = CharHash Char# 8 | 9 | main :: IO () 10 | main = print $ typeRep (Proxy :: Proxy 'CharHash) 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T11120.stdout: -------------------------------------------------------------------------------- 1 | 'CharHash 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T11230.stdout: -------------------------------------------------------------------------------- 1 | representational(Success): exception found 2 | phantom(Success): exception found 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T11715.stderr: -------------------------------------------------------------------------------- 1 | T11715: No more bug! 2 | CallStack (from HasCallStack): 3 | error, called at T11715.hs:15:31 in main:Main 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T12809.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | True 3 3 | False 7 4 | 3.14 5 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T13435.stdout: -------------------------------------------------------------------------------- 1 | I#3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T13594a.script: -------------------------------------------------------------------------------- 1 | :set -XBangPatterns -XRankNTypes -XTypeFamilies 2 | let x :: forall a . a ~ Integer => forall b. b ~ Integer => (a, b); !x = (1, 2) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T13838.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -fdefer-type-errors #-} 2 | 3 | module Main where 4 | 5 | main :: () -> () 6 | main = undefined 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T14218.stdout: -------------------------------------------------------------------------------- 1 | 4 2 | ["callStack","f"] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T14236.stdout: -------------------------------------------------------------------------------- 1 | ((->) 'LiftedRep 'LiftedRep Int,Char) 2 | ((->) 'IntRep 'LiftedRep Int#,Char) 3 | Int# -> [Char] 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T14341.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE TypeApplications #-} 2 | 3 | import Type.Reflection 4 | 5 | main :: IO () 6 | main = do 7 | print $ typeRep @((,,)) 8 | print $ typeRep @((,,) Int) 9 | print $ typeRep @((,,) Int Int Int) 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T14341.stdout: -------------------------------------------------------------------------------- 1 | (,,) 2 | (,,) Int 3 | (Int,Int,Int) -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T14925.hs: -------------------------------------------------------------------------------- 1 | import Data.Typeable 2 | 3 | data Ω = Ω 4 | 5 | main :: IO () 6 | main = print $ typeOf Ω 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T14925.stdout: -------------------------------------------------------------------------------- 1 | Ω 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T1624.stdout: -------------------------------------------------------------------------------- 1 | Nothing 2 | 'y' 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T2722.stdout: -------------------------------------------------------------------------------- 1 | [()] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T3500a.stdout: -------------------------------------------------------------------------------- 1 | 2 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T3500b.stdout: -------------------------------------------------------------------------------- 1 | "Right Left ()" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T3731-short.stdout: -------------------------------------------------------------------------------- 1 | Hurray2! 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T3731.stdout: -------------------------------------------------------------------------------- 1 | Proposition (Conjunction []) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T5573a.stdout: -------------------------------------------------------------------------------- 1 | 30 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T5573b.stdout: -------------------------------------------------------------------------------- 1 | 3.0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T5751.stdout: -------------------------------------------------------------------------------- 1 | before 2 | in genElement 3 | done. 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T5759.stdout: -------------------------------------------------------------------------------- 1 | Cont 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T5913.stdout: -------------------------------------------------------------------------------- 1 | WorksfineToo 2 | WorksfineToo 3 | LoopsAtRuntime 4 | LoopsAtRuntime 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T6117.stdout: -------------------------------------------------------------------------------- 1 | 1234567890 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T7023.hs: -------------------------------------------------------------------------------- 1 | {-# OPTIONS_GHC -fdefer-type-errors #-} 2 | 3 | module Main where 4 | 5 | a = ["x", 1 :: Int] 6 | 7 | main :: IO () 8 | main = putStrLn "Hello World" 9 | 10 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T7023.stdout: -------------------------------------------------------------------------------- 1 | Hello World 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T7126.stdout: -------------------------------------------------------------------------------- 1 | "1" 2 | "1" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T7748.stdout: -------------------------------------------------------------------------------- 1 | () 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T7861.stdout: -------------------------------------------------------------------------------- 1 | "Hello 1" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T8492.hs: -------------------------------------------------------------------------------- 1 | module Main where 2 | 3 | x :: ((->) Int) Bool 4 | x = (==0) 5 | 6 | main = print $ x 0 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T8492.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T8739.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MagicHash #-} 2 | module Main where 3 | import GHC.Exts 4 | 5 | go :: () -> Int# 6 | go () = 0# 7 | 8 | main = print (lazy (I# (go $ ()))) 9 | 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T8739.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T9858c.stdout: -------------------------------------------------------------------------------- 1 | (False,False) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T9858d.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE DataKinds #-} 2 | module Main where 3 | 4 | import Data.Typeable 5 | 6 | data A = A 7 | 8 | main = print $ typeRep (Proxy :: Proxy A) == typeRep (Proxy :: Proxy 'A) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/T9858d.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/TcNullaryTC.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MultiParamTypeClasses #-} 2 | 3 | module Main where 4 | 5 | class R where 6 | f :: Int -> Int 7 | g :: a -> a 8 | 9 | instance R where 10 | f = (+1) 11 | g = id 12 | 13 | main = print (g (f 0)) 14 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/TcNullaryTC.stdout: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/TcTypeNatSimpleRun.stdout: -------------------------------------------------------------------------------- 1 | [True,True,True,True,True,True,True] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/TcTypeSymbolSimpleRun.stdout: -------------------------------------------------------------------------------- 1 | [True,True] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/church.stdout: -------------------------------------------------------------------------------- 1 | 74 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/mc17.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE MonadComprehensions, ParallelListComp #-} 2 | 3 | -- !!! Parallel list comprehensions 4 | 5 | module Main where 6 | 7 | f xs = [ (x,y) | x <- xs, x>3 | y <- xs ] 8 | 9 | main = print (f [0..10]) 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/mc17.stdout: -------------------------------------------------------------------------------- 1 | [(4,0),(5,1),(6,2),(7,3),(8,4),(9,5),(10,6)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun.stderr: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun001.stdout: -------------------------------------------------------------------------------- 1 | 4 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun002.stdout: -------------------------------------------------------------------------------- 1 | -1474736480 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun002.stdout-alpha-dec-osf3: -------------------------------------------------------------------------------- 1 | 20000100000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun002.stdout-mips-sgi-irix: -------------------------------------------------------------------------------- 1 | 20000100000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun002.stdout-ws-64: -------------------------------------------------------------------------------- 1 | 20000100000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun002.stdout-x86_64-unknown-openbsd: -------------------------------------------------------------------------------- 1 | 20000100000 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun003.stdout: -------------------------------------------------------------------------------- 1 | 3 % 1 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun004.stdout: -------------------------------------------------------------------------------- 1 | Sphere 2 | Cube 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun005.stdout: -------------------------------------------------------------------------------- 1 | "ok" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun006.stdout: -------------------------------------------------------------------------------- 1 | "ok new ok data" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun008.stdout: -------------------------------------------------------------------------------- 1 | [3,3,3] 2 | [True,False] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun009.stdout: -------------------------------------------------------------------------------- 1 | "f" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun010.stdout: -------------------------------------------------------------------------------- 1 | "(ERR No,111)" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun011.stdout: -------------------------------------------------------------------------------- 1 | [3,-3] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun012.stdout: -------------------------------------------------------------------------------- 1 | 13 2 | 14 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun013.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE ParallelListComp #-} 2 | 3 | -- !!! Parallel list comprehensions 4 | 5 | module Main where 6 | 7 | f xs = [ (x,y) | x <- xs, x>3 | y <- xs ] 8 | 9 | main = print (f [0..10]) 10 | 11 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun013.stdout: -------------------------------------------------------------------------------- 1 | [(4,0),(5,1),(6,2),(7,3),(8,4),(9,5),(10,6)] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun014.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun015.stdout: -------------------------------------------------------------------------------- 1 | [["n"],["n"],["n"],["n"],["n"],["n"],["n"],["n"],["n"],["n"]] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun016.stdout: -------------------------------------------------------------------------------- 1 | Just 4 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun017.stdout: -------------------------------------------------------------------------------- 1 | 42 2 | 45 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun018.stdout: -------------------------------------------------------------------------------- 1 | Just True 2 | Just True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun019.stdout: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun020.stdout: -------------------------------------------------------------------------------- 1 | Just True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun021.stdout: -------------------------------------------------------------------------------- 1 | fromList [(Left [],File []),(Left ["home"],File ["home"])] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun022.stdout: -------------------------------------------------------------------------------- 1 | rewrite rule did fire 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun023.stdout: -------------------------------------------------------------------------------- 1 | 5 2 | 8 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun024.stdout: -------------------------------------------------------------------------------- 1 | ok1 2 | ok2 3 | [Just "bill",Just "fred"] 4 | [Just "bill",Just "fred"] 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun026.stdout: -------------------------------------------------------------------------------- 1 | "foo" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun027.stdout: -------------------------------------------------------------------------------- 1 | [3.4] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun028.stdout: -------------------------------------------------------------------------------- 1 | V [] 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun029.stdout: -------------------------------------------------------------------------------- 1 | Node {color = Black, key = 1, item = 2, left = None, right = None} 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun030.stdout: -------------------------------------------------------------------------------- 1 | True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun031.stdout: -------------------------------------------------------------------------------- 1 | 'x' 2 | T 'y' 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun032.stdout: -------------------------------------------------------------------------------- 1 | In Nil 2 | True 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun033.stdout: -------------------------------------------------------------------------------- 1 | "hello" 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun034.stdout: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun036.stdout: -------------------------------------------------------------------------------- 1 | 20 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun037.stdout: -------------------------------------------------------------------------------- 1 | True 'x' 2 | False 3 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun039.stdout: -------------------------------------------------------------------------------- 1 | 7 2 | [3,4,5] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun040.stdout: -------------------------------------------------------------------------------- 1 | *** main 1 2 | *** main 2 3 | 12345 4 | *** main 3 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun041.stdout: -------------------------------------------------------------------------------- 1 | ((1,True),(1,False),("Hello",True),(1337,True),("Yeah",1,"Baby")) 2 | (1,True,1,False,"Hello",True,1337,True,"Yeah",1,"Baby") 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun043.stdout: -------------------------------------------------------------------------------- 1 | "99" 2 | "TrueTrue" 3 | Left "10" 4 | Left "False" 5 | Right 12 6 | Right 13.0 7 | "14" 8 | "15.0" 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun044.stdout: -------------------------------------------------------------------------------- 1 | [2,3,3,4] 2 | fromList [2,3,4] 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun046.stdout: -------------------------------------------------------------------------------- 1 | False 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun047.stdout: -------------------------------------------------------------------------------- 1 | 10 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun048.stdout: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun049.stdout: -------------------------------------------------------------------------------- 1 | 7 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun050.stdout: -------------------------------------------------------------------------------- 1 | 21 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/tcrun051.stdout: -------------------------------------------------------------------------------- 1 | (21,21) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/typecheck/testeq2.stdout: -------------------------------------------------------------------------------- 1 | (HTrue,HFalse) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/T12375.stdout: -------------------------------------------------------------------------------- 1 | (# (# #), (# #) #) 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/T12711.script: -------------------------------------------------------------------------------- 1 | :set -XUnboxedSums -XPartialTypeSignatures -fno-warn-partial-type-signatures 2 | :kind (# _ | _ #) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/T12711.stdout: -------------------------------------------------------------------------------- 1 | (# _ | _ #) :: TYPE 2 | ('GHC.Types.SumRep '[ 'GHC.Types.LiftedRep, 'GHC.Types.LiftedRep]) 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/empty_sum.stdout: -------------------------------------------------------------------------------- 1 | (# #) 2 | (# (# #) | #) 3 | (# | (# #) #) 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/thunk.hs: -------------------------------------------------------------------------------- 1 | {-# LANGUAGE UnboxedTuples #-} 2 | 3 | {-# NOINLINE f #-} 4 | f :: (# #) -> [Int] 5 | f (# #) = [ 1 .. ] 6 | 7 | main :: IO () 8 | main = print (sum (take 10 (f (# #)))) 9 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/thunk.stdout: -------------------------------------------------------------------------------- 1 | 55 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unarise.stdout: -------------------------------------------------------------------------------- 1 | ok 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums1.stdout: -------------------------------------------------------------------------------- 1 | Left "error" 2 | Right 10 3 | Left 10 4 | Right 1.2 5 | Left "OK" 6 | Right 123 7 | Alt0: 10 8 | Alt1: False 9 | Alt2: "ok" 10 | Alt3: 'a' 11 | Alt4: Right True 12 | Alt5: 123 13 | Alt6: 54.3 14 | Left "error" 15 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums10.stdout: -------------------------------------------------------------------------------- 1 | 0 2 | 3 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums11.stdout: -------------------------------------------------------------------------------- 1 | "(# _ | #)" 2 | "(# | () #)" 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums2.stdin: -------------------------------------------------------------------------------- 1 | 20.123 2 | 10 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums2.stdout: -------------------------------------------------------------------------------- 1 | 21 2 | 10.0 3 | D 20.123 4 | D 10 5 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums3.stdout: -------------------------------------------------------------------------------- 1 | (# | (# #) | #) 2 | (# | | () #) 3 | (# Void | #) 4 | (# | 8.1# #) 5 | (# | (# #) | #) 6 | (# | 1.2# #) 7 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums6.stdout: -------------------------------------------------------------------------------- 1 | 123True 2 | 1.2 3 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums7.stdout: -------------------------------------------------------------------------------- 1 | Right 10 True 2 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums8.stdout: -------------------------------------------------------------------------------- 1 | 123456 2 | 876543 3 | 123456 4 | -------------------------------------------------------------------------------- /asterius/test/ghc-testsuite/unboxedsums/unboxedsums9.stdout: -------------------------------------------------------------------------------- 1 | True 2 | False 3 | True 4 | False 5 | -------------------------------------------------------------------------------- /asterius/test/jsffi/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | jsffi 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /asterius/test/largenum.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/largenum/largenum.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/parsec.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/parsec/parsec.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/primitive.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ ["--input-hs", "test/primitive/primitive.hs", "--run"] <> args 8 | -------------------------------------------------------------------------------- /asterius/test/regression60.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/regression60/regression60.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/sizeof_md5context.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/sizeof_md5context/sizeof_md5context.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/stableptr.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/stableptr/stableptr.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/teletype.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ 8 | ["--input-hs", "test/teletype/teletype.hs", "--run"] 9 | <> args 10 | -------------------------------------------------------------------------------- /asterius/test/text.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ ["--input-hs", "test/text/text.hs", "--run"] <> args 8 | -------------------------------------------------------------------------------- /asterius/test/th.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ ["--input-hs", "test/th/th.hs", "--run"] <> args 8 | -------------------------------------------------------------------------------- /asterius/test/th/Fib.hs: -------------------------------------------------------------------------------- 1 | module Fib 2 | ( fib, 3 | ) 4 | where 5 | 6 | fib :: Int -> Int 7 | fib 0 = 0 8 | fib 1 = 1 9 | fib n = fib (n - 2) + fib (n - 1) 10 | -------------------------------------------------------------------------------- /asterius/test/time.hs: -------------------------------------------------------------------------------- 1 | import System.Environment 2 | import System.Process 3 | 4 | main :: IO () 5 | main = do 6 | args <- getArgs 7 | callProcess "ahc-link" $ ["--input-hs", "test/time/time.hs", "--run"] <> args 8 | -------------------------------------------------------------------------------- /asterius/test/todomvc/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "private": true, 3 | "dependencies": { 4 | "todomvc-app-css": "^2.0.0", 5 | "todomvc-common": "^1.0.0" 6 | }, 7 | "browserslist": [ 8 | "last 1 Chrome version" 9 | ] 10 | } 11 | -------------------------------------------------------------------------------- /bazel/nix/BUILD.bazel: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tweag/asterius/641ade855c95818527f1726cc58ea7b49befede1/bazel/nix/BUILD.bazel -------------------------------------------------------------------------------- /bazel/nix/bazel_build_shell.nix: -------------------------------------------------------------------------------- 1 | { pkgs ? import ./bazel_deps.nix {} }: 2 | with pkgs; 3 | mkShell { 4 | LANG="C.UTF-8"; 5 | buildInputs = [gcc cacert git nix bazel_4 ]; 6 | } 7 | -------------------------------------------------------------------------------- /cabal.project: -------------------------------------------------------------------------------- 1 | packages: 2 | asterius 3 | 4 | -------------------------------------------------------------------------------- /docs/.gitignore: -------------------------------------------------------------------------------- 1 | book 2 | -------------------------------------------------------------------------------- /docs/book.toml: -------------------------------------------------------------------------------- 1 | [book] 2 | authors = [] 3 | language = "en" 4 | multilingual = false 5 | src = "src" 6 | -------------------------------------------------------------------------------- /docs/shell.nix: -------------------------------------------------------------------------------- 1 | { sources ? import ../nix/sources.nix { } 2 | , haskellNix ? import sources.haskell-nix { } 3 | , pkgs ? import haskellNix.sources.nixpkgs-unstable haskellNix.nixpkgsArgs 4 | }: 5 | pkgs.callPackage ./. { } 6 | -------------------------------------------------------------------------------- /ghc-toolkit/BUILD.bazel: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tweag/asterius/641ade855c95818527f1726cc58ea7b49befede1/ghc-toolkit/BUILD.bazel -------------------------------------------------------------------------------- /ghc-toolkit/boot-libs/asterius-prelude/CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # CHANGELOG for `asterius-prelude` 2 | -------------------------------------------------------------------------------- /ghc-toolkit/boot-libs/asterius-prelude/README.md: -------------------------------------------------------------------------------- 1 | # `asterius-prelude` 2 | -------------------------------------------------------------------------------- /ghc-toolkit/boot-libs/rts/rts.conf: -------------------------------------------------------------------------------- 1 | name: rts 2 | version: 1.0 3 | id: rts 4 | key: rts 5 | license: BSD-3-Clause 6 | maintainer: glasgow-haskell-users@haskell.org 7 | exposed: True 8 | library-dirs: $topdir/rts 9 | hs-libraries: HSrts 10 | include-dirs: $topdir/include 11 | -------------------------------------------------------------------------------- /nix/BUILD.bazel: -------------------------------------------------------------------------------- 1 | exports_files(glob(["*.nix"])) 2 | -------------------------------------------------------------------------------- /nix/wasi-sdk.nix: -------------------------------------------------------------------------------- 1 | { sources ? import ./sources.nix { } 2 | , ghcAsteriusSources ? import "${sources.ghc-asterius}/nix/sources.nix" { } 3 | }: 4 | ghcAsteriusSources.wasi-sdk 5 | -------------------------------------------------------------------------------- /webpack/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "asdf", 3 | "version": "0.0.1", 4 | "devDependencies": { 5 | "webpack": "^5.58.2", 6 | "webpack-cli": "^4.9.0" 7 | } 8 | } 9 | --------------------------------------------------------------------------------