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 ]
h *: xs の xs のなかに入っているファンクタをフィルターしながら h の方に上げたいのです。PersonParams -> PersonOptionalParams であれば Nullable の wrench に近いやもしれません。wrench は h に作用するだけなので、 xs が不変でないと使えないのです。。。xs が変わってしまう点ですね。(xs ~ [f x1, g x2, f x3], ys ~ [x1, x3], Include xs (f * ys))$ ghci >>> :set -XOverloadedLabels >>> import Lens.Micro >>> a = liftRecord person :: PersonRequiredParams >>> a ^. #name "alice"
aeson についてなんですが{ "a":100, "b":200}
data Foo = Foo { a :: Int, b :: Int} deriving Generic
instance FromJSON Foo
Maybe Int として読んでから変換するとか。FomJSON を別途実装した newtype で囲うとかnewtype Default50 = Default50 :: Int instance FromJSON Default50 where parseJSON = withScientific ...
newtype 使う作戦もありなのか。そっちにしよっと :smile:Maybe な RecordOf 作って各フィールドごとに <|> を適用させるってのをやってましたね。そんで最後に htraverse で Nothing が1つでもあれば全体として mzero になるみたいな
$ 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) = ...
a に応じて func の振る舞いを変更するには、どのようにしたらよいでしょうか？FlexibleInstances 拡張を有効にして2つのインスタンス宣言を書く、というのも手ですが、そうするとほとんど同じ実装（値の比較以外）のインスタンス宣言が2つ出てきてしまいます。func の実装を別途 a ごとに用意しておいて、インスタンス内部で a に応じて適切な実装が選択されるようにできればいいなー、と。a をまた別の型クラスのインスタンスにして比較する処理をメソッドとしてもたせるとかでしょうか :thinking_face:Down という newtype でくるんであげることでも可能ですが... https://hackage.haskell.org/package/base-4.12.0.0/docs/Data-Ord.html#t:DownFromJSON のインスタンスを定義する、というのがよいと思います。
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 h1@(T _ x a1 b1) h2@(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 h1@(T _ x a1 b1) h2@(T _ y a2 b2)
= if x >= y
then makeT x a1 $ merge b1 h2
else makeT y a2 $ merge h1 b2
Proxyの使い方がいまいちわかっていなかったですが、具体的な値を定義せずに型を使いたい時に使用するのですね。ありがとうございます。LeftistHeap に固有の操作は型クラスに含めず、独立に定義するものだと思います。(*), (+) :: Num a => a -> a-> a
(*) に b 型を代入すると b -> b になります。 b が (+) だとすると (a -> a-> a) -> (a-> a-> a) になります。結合性から右のかっこは省略しても良いので (a -> a-> a) -> a -> a -> a となります(*) も (+) も、それぞれ Num 型クラスのインスタンスであればどれでも受け取るようになっています。:t の結果が (Num a, Num (a -> a -> a)) => ... となっているとおり、これらの条件を満たす型が 本当にあれば この式も普通に型チェックを通ります。(Num a, Num (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))