isomorphism

module A where

import GHCJS.Types

newtype Foo = Foo (JSRef ())

foreign import javascript unsafe "" foo :: IO Foo

{- Output:

isomorphism

module Main where

import GHCJS.DOM
import GHCJS.DOM.Types
import GHCJS.DOM.Document
import GHCJS.DOM.EventM

main = do
    Just doc <- currentDocument
    connect "keydown" doc $ do

isomorphism

module Main where

import Data.Vector.Storable as V

main = do
    print $ V.fromList [1..9 :: Float]

-- output:
-- "fromList [5.831554e-39,5.831554e-39,1.0,1.0,1.0,1.0,1.0,1.0,1.0]"

isomorphism

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE PolyKinds #-}
module A where

import Control.Lens
import Data.Vinyl
import GHC.TypeLits

class A f where

isomorphism

import Prelude hiding ((++), concat)
import Control.Applicative
import Control.Monad
import Data.Maybe
import Data.Monoid
import System.Random
import qualified Data.IntMap as IM
import Graphics.DrawingCombinators
import qualified Graphics.UI.SDL as SDL
import Graphics.UI.SDL.Keysym

isomorphism

----------------------------------------------------------------------
vertex group
0x00004394 - 0x000043c3
0x4394 flags: 1073741826
0x4398 (16 bytes skipped): 
0x43a8 vertex array bytes array, # entries: 135800
0x43ac vertex array bytes array offset: 0x47178
0x43b0 (8 bytes skipped): 
0x43b8 vertex array stride bytes: 40

isomorphism

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
module RotateArgs where

data Z = Z
data S n = S n

class RotateArgs n a where

isomorphism

{-# LANGUAGE TypeOperators #-}
module StreamProc where

import Prelude hiding ((.), id, const)
import Control.Category
import Control.Arrow
import Control.Applicative

const :: (Arrow (~>)) => a -> (b ~> a)
const x = arr (\_ -> x)

isomorphism

module Main where

import Control.Monad.State
import Data.Map (Map)
import qualified Data.Map as M
import Data.Set (Set)
import qualified Data.Set as S
import Data.List (isPrefixOf, intercalate)
import Data.Char (toLower)

isomorphism

import Data.Set (Set)
import qualified Data.Set as S

bindSet :: (Ord a, Ord b) => Set a -> (a -> Set b) -> Set b
bindSet s k = S.unions . S.toList $ S.map k s

foldSet :: (Ord a ) => (a -> b -> Set a) -> a -> [b] -> Set a
foldSet _ a [] = S.singleton a
foldSet f a (x:xs) = bindSet (f a x) (\fax -> foldSet f fax xs)