exper.glask

{ infixl 5 +
; infixl 5 *

; int'id :: Int -> Int
; int'id i = i

; maybe :: Maybe a -> a -> a
; maybe (Just x) _ = x
; maybe Nothing y  = y

; class Num a where
  { (+) :: a -> a -> a
  ; (*) :: a -> a -> a }

; instance Num Int where
  { (+) x y = int#+ (x, y)
  ; (*) x y = int#* (x, y) }

; hmmm = 23 + 42

-- ; instance Num Double where
--   { (+) x y = double#+ (x, y)
--   ; (*) x y = double#* (x, y) }

; data Maybe a = Just a | Nothing

; data Bool = True | False

-- ; instance Num a => Num (Maybe a) where
--   { (+) (Just n) (Just m) = Just (n + m)
--   ; (*) (Just n) (Just m) = Just (n * m) }

; numberino :: a -> Int
; numberino _ = int#+ (23, 42)

; testing :: a -> Bool
; testing _ = True

; example :: Int
; example = 23 + 42

-- klic je to trignout u explicitnich funkci taky
-- tenhle example to presne trigne
-- ; fobar :: Num a => Maybe a -> a
-- ; fobar (Just n) = n + n

-- ; overloaded :: Num a => a -> a
-- ; overloaded a = a
-- 
-- ; foo n = let { r = overloaded n
--               ; m = int'id n }
--           in  r


-- ; add'maybe :: Num a => a -> a
-- ; add'maybe :: Int -> Int
-- with, or without the annotation - it seems to be working fine
; add'maybe x = case Just x of
                { Just a -> a + a }

; a'fn :: Num a => a -> a
; a'fn x = x

-- this needs to propagate that constraint
-- and it does
; b'fn x = case a'fn x of
           { n -> n }


-- but this is somehow broken
; c'fn _ = case 23 of
         { n -> n }

-- weird experiments with monomorphism restriction
----  
----  ; eee hole = let { x = 1 + 1 } in x
----  
----  ; func hole = let { two = 1 + 1 }
----                in (two, \ x -> x + two) -- :: (forall a . Num a => (a, a -> a))
----  
----  ; func' hole = let { two :: Num p => p
----                      ; two = 1 + 1 }
----                 in (two, \ x -> x + two) -- :: (forall a . Num a => (a, a -> a))
----  
----  ; func1 hole = let { one = 1 } in (one, one)
----  
----  -- ; baad' hole =  let { fn :: a -> b -> a
----  --                     ; fn x y = x }
----  --                 in (fn, fn)
----  
----  ; baad' hole =  let { fn x y = x }
----                  in (fn, fn)
----  
----  ; baad1 hole =  let { fn = \ x y -> x + y }
----                  in (fn, fn)


-- I wanted to try this because in the infer'expl I have a question about this
-- ; zoar x y = raoz y (x + x)
-- ; raoz y x = zoar (char2num x) y
-- 
-- ; char2num :: Num a => Char -> a
-- ; char2num = char2num

-- stil works fine - it finds the error
-- ; class Woo a
-- 
-- -- ; broken :: a -> a -> a
-- ; broken :: Woo a => a -> a
-- ; broken a = a
-- 
-- ; woo x = broken True


}