“A monad is a monoid in the category of endofunctors.” Is there something similar for comonad? Hmm, say, comonoid? What does it looks like if there is?
I tried to flip the arrow of monoid, but it looks strange…

```class Comonoid a where
coidentity :: a -> ()
comultiple :: a -> (a, a)
```

And I cannot find any law of it…

maybe … ?

```class Comonoid a where
v :: a -> ()
p :: a -> a
q :: a -> a

forall x.

((p.p) x, (q.p) x , q x) = (p x, (p.q) x, (q.q) x)

p x = x
q x = x
```

But it’s nearly of no use…
That’s comonoid laws on Haskell (if you think about only in Set)

Haskell has the instance of all types for Comonoid:
```instance Comonoid a where
coidentity _ = ()
comultiple x = (x, x)
```

This instance is trivial and the only.

こういうのも実装できない感じでしょうか

```import Data.Type.Equality

unProd :: a1 :~: a2 -> b1 :~: b2 -> '(a1, b1) :~: '(a2, b2)
unProd r1 r2 = undefined -- Refl
```

```unProd :: a1 :~: a2 -> b1 :~: b2 -> '(a1, b1) :~: '(a2, b2)
unProd Refl Refl = Refl
```
hmmm, so comonoid = droppable ^ clonable?
it make sense if the value can be passed only once

```extractedTuple' :: forall a b t. (t ~ '(a, b)) => '(Fst t, Snd t) :~: t
extractedTuple' = apply (apply Refl (Refl :: Fst t :~: a)) (Refl :: Snd t :~: b)
```
streams 、いいですね！これは使える！
ありがとうございます！

constraintが増えていますが、以下の様な感じでできました：

```{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}

module Foo where

import Data.Singletons.Prelude (Fst, Snd)
import Data.Type.Equality ((:~:)(Refl))

extractedTuple :: forall a fst snd. (fst ~ Fst a, snd ~ Snd a, a ~ '(fst, snd)) => '(Fst a, Snd a) :~: a
extractedTuple = Refl

useExtractedTuple :: ()
useExtractedTuple =
case extractedTuple @'(Int, Bool) of
Refl -> ()
```
お二方ともありがとうございます．どちらも `t ~ '(a, b)` と仮定して `Fst t` / `Snd t``'(a, b)` でパターンマッチできることを教えればできるという感じですかね？やっぱり，そういう感じの制約をつけないと厳しいですかね…

```
hoge :: a -> [a] -> [a]
hoge x = go
where
go :: [b] -> [b]
go xs = x : xs
```

あぁーっ！まさにそのための拡張があるんですが名前が出てこない！！
ScopedTypeVariablesで出来ると思います
それでできると思ったのですけど・・・
ありがちなミスは `forall` を該当の型変数に書き忘れる、とかですかね。（経験者談）
あ、それでした！
OK

```hoge :: forall a. a -> [a] -> [a]
hoge x = go
where
go :: [a] -> [a]
go xs = x : xs
```
ありがとうございました！
また、こういったライブラリを調べる際には、皆さんどういったところから探してきておられるのですかね?

`~` をホームディレクトリに展開してくれるものは分からないですが、ホームディレクトリが参照できればいいのであれば path と path-io パッケージを使って以下のように書けるはずです。
```h <- getHomeDir
readFile \$ toFilePath \$ h </> \$(mkRelFile ".bashrc")
```
そのGabrielさんの、State of the Haskell ecosystem というのもありますね。
https://github.com/Gabriel439/post-rfc/blob/master/sotu.md

interoは何で使ってます？Emacs？
はい,Emacsで使ってます

`Data.Vector.Storable.Mutable.unsafeFromForeignPtr` の説明で、
Modifying data through the ForeignPtr afterwards is unsafe if the vector could have been frozen before the modification.
とあるけれど、 `freeze` なら複製されるはずだし、 `unsafeFreeze` ならそれを呼ぶ側の責任だしで、これがどれくらい危険なのかよく分からず……
どういう場合にどれくらい危険なのか、どなたかご存じないでしょうか?

```-- evilFunを使用する人には"hiroto"がエラーを吐くことがわからない。
evilFun :: Text -> Text
evilFun "hiroto" = error "This is evil function"
evilFun _ = "Everything is alright!"
```

ExceptionはIOのみ処理できる、
`evaluate :: a -> IO a`
ありがとう！なんで全然できないんだろーって思ったらやっぱりややこしいんですね。。この関数を作った人を恨みます。
```import Data.Vector.Storable.Mutable
import Data.Vector.Storable (freeze)
import
import Foreign.ForeignPtr
import Foreign.Storable
import Data.Foldable

main :: IO ()
main = do
fp <- mallocForeignPtrArray 10
withForeignPtr fp \$ \p -> flip traverse_ [0..10] \$ \i -> do
pokeElemOff p i i
let nv = runST \$ freeze (unsafeFromForeignPtr0 fp 10)
withForeignPtr fp \$ \p -> do
poke p 42
pure ()
print nv
pure ()
```
コピーされたとしても、改竄されたあとならあまり変わらないね
おお、なるほどー
`unsafeFromForeignPtr` の結果は `IOVector` に限定されないから、 `STVector` として使うとこんなことができちゃうんですね。

`Text -> Maybe Text`

`MonadError e m => Text -> m Text`
あたりが僕は好きです！

https://aiya000.github.io/posts/2018-06-30-use-mtl-exceptt-no-eithert.html
（宣伝）
なるほど、そもそもその邪悪関数を改変できないことが前提なのかな…

Zipファイルを解凍するライブラリ
を使用してるんですが、どうやらzlibの`decompress`っていう関数を使用しているみたいで、こいつが部分関数ではないかと推測してます