haskell-jp / questions #58

type PersonParams (f :: * -> *) (g :: * -> *) =
  Field Identity :*
  '[ "name" >: f Text
   , "age" >: g Int
   ]

type PersonRequiredParams (f :: * -> *) =
  Field f :*
  '[ "name" >: Text
   ]

type PersonOptionalParams (g :: * -> *) =
  Field g :*
  '[ "age" >: Int
   ]

$ ghci
>>> :set -XOverloadedLabels
>>> import Lens.Micro
>>> a = liftRecord person :: PersonRequiredParams
>>> a ^. #name
"alice"

data Foo = Foo { a :: Int, b :: Int} deriving Generic
instance FromJSON Foo

newtype Default50 = Default50 :: Int
instance FromJSON Default50 where
  parseJSON = withScientific ...

$ ghci
>>> :set -XOverloadedStrings
>>> import Data.Aeson
>>> decode "{ \"a\": 1, \"b\": 2 }" :: Maybe Foo
Just (a @= 1 <: b @= 2 <: nil)
>>> decode "{ \"a\": 1 }" :: Maybe Foo
Nothing
>>> decode "{ \"a\": 1 }" :: Maybe Foo'
Just (Nullable {getNullable = Just (a @= 1)} <: Nullable {getNullable = Nothing} <: nil)
>>> fromNullable defaultFoo <$> decode "{ \"a\": 1 }" :: Maybe Foo
Just (a @= 1 <: b @= 50 <: nil)

data Fuga a Int = Fuga Int

class Hoge h where
  func :: h a -> a

instance Hoge (Fuga a) where
  func (Fuga x) = ...

import Data.Aeson

data Foo = Foo { a :: Int, b :: Int}
  deriving Show

instance FromJSON Foo where
  parseJSON = withObject "Foo" $ \o -> do
    a <- o .: "a"
    b <- o .:? "b" .!= 50
    pure $ Foo a b

-- |
-- >>> run
-- Just (Foo {a = 100, b = 200})
-- Just (Foo {a = 100, b = 50})
run :: IO ()
run = do
  print (decode "{ \"a\":100, \"b\":200}" :: Maybe Foo)
  print (decode "{ \"a\":100}" :: Maybe Foo)

empty :: (Ord a, h ~ LeftistHeap x) => h a
empty = E

isEmpty :: (Ord a, h ~ LeftistHeap x) => h a -> Bool
isEmpty E = True
isEmpty _ = False

insert :: (Ord a, h ~ LeftistHeap x, Heap h) => a -> h a -> h a
insert x h = merge (T 1 x E E) h

find :: (Ord a, h ~ LeftistHeap x) => h a -> Maybe a
find E = Nothing
find (T _ x _ _) = Just x

delete :: (Ord a, h ~ LeftistHeap x, Heap h) => h a -> Maybe (h a)
delete E = Nothing
delete (T _ _ a b) = Just (merge a b)


class Heap h where
  merge :: Ord a => h a -> h a -> h a

instance Heap (LeftistHeap Min) where
  merge h E = h
  merge E h = h
  merge [email protected](T _ x a1 b1) [email protected](T _ y a2 b2)
    = if x <= y
      then makeT x a1 $ merge b1 h2
      else makeT y a2 $ merge h1 b2

instance Heap (LeftistHeap Max) where
  merge h E = h
  merge E h = h
  merge [email protected](T _ x a1 b1) [email protected](T _ y a2 b2)
    = if x >= y
      then makeT x a1 $ merge b1 h2
      else makeT y a2 $ merge h1 b2

(*), (+) :: Num a => a -> a-> a

> ((*) (+)) (+) 1 2 3 :: Integer

<interactive>:4:1: error:
    ? No instance for (Num
                         ((Integer -> Integer)
                          -> (Integer -> Integer) -> Integer -> Integer))
        arising from a use of ‘*’
        (maybe you haven't applied a function to enough arguments?)
    ? In the expression: ((*) (+)) (+) 1 2 3 :: Integer
      In an equation for ‘it’: it = ((*) (+)) (+) 1 2 3 :: Integer

<interactive>:4:6: error:
    ? No instance for (Num (Integer -> Integer))
        arising from a use of ‘+’
        (maybe you haven't applied a function to enough arguments?)
    ? In the first argument of ‘(*)’, namely ‘(+)’
      In the expression: ((*) (+)) (+) 1 2 3 :: Integer
      In an equation for ‘it’: it = ((*) (+)) (+) 1 2 3 :: Integer

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
instance Num a => Num (a -> a -> a) where
  (f + g) x y = f x y + g x y
  (f * g) x y = f x y * g x y
  (f - g) x y = f x y - g x y
  abs f x y = abs (f x y)
  signum f x y = signum (f x y)
  fromInteger i = const (const (fromInteger i))