-- Haskell: 型クラスによる多相性（ポリモーフィズム）
-- 型クラスはインタフェースに似た概念だが、事後的に追加可能
 
class Describable a where
  describe :: a -> String
 
-- 代数的データ型の定義
data Shape
  = Circle Double          -- 半径
  | Rectangle Double Double -- 幅と高さ
  | Triangle Double Double Double  -- 三辺
  deriving (Show, Eq)
 
-- 型クラスインスタンスの実装
instance Describable Shape where
  describe (Circle r) =
    "半径 " ++ show r ++ " の円（面積: " ++ show (pi * r * r) ++ "）"
  describe (Rectangle w h) =
    show w ++ " x " ++ show h ++ " の矩形（面積: " ++ show (w * h) ++ "）"
  describe (Triangle a b c) =
    "三辺 " ++ show a ++ ", " ++ show b ++ ", " ++ show c ++ " の三角形"
 
-- 型クラス制約を利用した汎用関数
describeAll :: Describable a => [a] -> [String]
describeAll = map describe
 
-- 使用例
-- describeAll [Circle 5.0, Rectangle 3.0 4.0]
-- → ["半径 5.0 の円（面積: 78.53...）", "3.0 x 4.0 の矩形（面積: 12.0）"]

-- Haskell: モナドによる副作用管理の例
-- Maybe モナド: 失敗する可能性のある計算の連鎖
 
import qualified Data.Map as Map
 
type UserName = String
type Email = String
type UserId = Int
 
-- ユーザーデータベース（模擬）
userDb :: Map.Map UserId UserName
userDb = Map.fromList [(1, "alice"), (2, "bob"), (3, "charlie")]
 
emailDb :: Map.Map UserName Email
emailDb = Map.fromList
  [ ("alice", "alice@example.com")
  , ("bob", "bob@example.com")
  ]
 
-- Maybe モナドによるチェイン
-- 各ステップが失敗する可能性があるが、do記法で直線的に書ける
lookupEmail :: UserId -> Maybe Email
lookupEmail uid = do
  name  <- Map.lookup uid userDb     -- ユーザー名を検索
  email <- Map.lookup name emailDb   -- メールアドレスを検索
  return email
 
-- lookupEmail 1  → Just "alice@example.com"
-- lookupEmail 2  → Just "bob@example.com"
-- lookupEmail 3  → Nothing  (charlieのメールが未登録)
-- lookupEmail 99 → Nothing  (ユーザーIDが存在しない)
 
-- IO モナド: 現実世界との対話
-- IO型がついた関数だけが副作用を持てる
main :: IO ()
main = do
  putStrLn "ユーザーIDを入力してください:"
  input <- getLine
  let uid = read input :: UserId
  case lookupEmail uid of
    Just email -> putStrLn ("メールアドレス: " ++ email)
    Nothing    -> putStrLn "メールアドレスが見つかりません"

-- Haskell: 遅延評価の威力
-- 無限リストが自然に扱える
 
-- フィボナッチ数列（無限リスト）
fibs :: [Integer]
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
 
-- 必要な分だけ取得
-- take 10 fibs → [0,1,1,2,3,5,8,13,21,34]
 
-- 素数の無限リスト（エラトステネスの篩）
primes :: [Integer]
primes = sieve [2..]
  where
    sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]
 
-- take 20 primes → [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71]
 
-- 遅延評価による効率的なデータ処理
-- 巨大リストでも最初のN個だけ評価される
firstEvenSquareOver100 :: Maybe Integer
firstEvenSquareOver100 =
  let squares = map (^2) [1..]           -- 無限の平方数
      evenSquares = filter even squares    -- 偶数の平方数だけ
      overHundred = filter (> 100) evenSquares  -- 100超のもの
  in case overHundred of
       (x:_) -> Just x
       []    -> Nothing
-- → Just 144 (12^2)

# Elixir: パターンマッチの多彩な活用
 
# 関数の引数でパターンマッチ
defmodule UserParser do
  # JSON風マップからユーザー情報を抽出
  def parse(%{"name" => name, "age" => age}) when is_binary(name) and age >= 0 do
    {:ok, %{name: name, age: age}}
  end
 
  def parse(%{"name" => name}) when is_binary(name) do
    {:ok, %{name: name, age: :unknown}}
  end
 
  def parse(_invalid) do
    {:error, :invalid_format}
  end
 
  # パイプ演算子でデータ変換パイプラインを構築
  def process_users(raw_data) do
    raw_data
    |> Enum.map(&parse/1)                          # 各要素をパース
    |> Enum.filter(fn {:ok, _} -> true; _ -> false end)  # 成功のみ残す
    |> Enum.map(fn {:ok, user} -> user end)        # ユーザーデータを抽出
    |> Enum.sort_by(& &1.name)                     # 名前順ソート
    |> Enum.map(&format_user/1)                    # フォーマット
  end
 
  defp format_user(%{name: name, age: :unknown}) do
    "#{name} (年齢不明)"
  end
 
  defp format_user(%{name: name, age: age}) do
    "#{name} (#{age}歳)"
  end
end
 
# 使用例
# data = [
#   %{"name" => "Alice", "age" => 30},
#   %{"name" => "Bob"},
#   %{"invalid" => true},
#   %{"name" => "Charlie", "age" => 25}
# ]
# UserParser.process_users(data)
# → ["Alice (30歳)", "Bob (年齢不明)", "Charlie (25歳)"]

# Elixir: GenServer + Supervisor による耐障害設計
 
defmodule Counter do
  use GenServer
 
  # クライアントAPI
  def start_link(initial_value) do
    GenServer.start_link(__MODULE__, initial_value, name: __MODULE__)
  end
 
  def increment, do: GenServer.cast(__MODULE__, :increment)
  def decrement, do: GenServer.cast(__MODULE__, :decrement)
  def value,     do: GenServer.call(__MODULE__, :value)
 
  # サーバーコールバック
  @impl true
  def init(initial_value), do: {:ok, initial_value}
 
  @impl true
  def handle_cast(:increment, state), do: {:noreply, state + 1}
  def handle_cast(:decrement, state), do: {:noreply, state - 1}
 
  @impl true
  def handle_call(:value, _from, state), do: {:reply, state, state}
end
 
defmodule MyApp.Supervisor do
  use Supervisor
 
  def start_link(opts) do
    Supervisor.start_link(__MODULE__, :ok, opts)
  end
 
  @impl true
  def init(:ok) do
    children = [
      {Counter, 0}  # 初期値0でカウンターを起動
    ]
 
    # one_for_one: 子プロセスがクラッシュしたら、そのプロセスだけ再起動
    Supervisor.init(children, strategy: :one_for_one)
  end
end
 
# Counter がクラッシュしても Supervisor が自動で再起動する
# これが "Let it crash" 哲学の具体的な実装

-- Elm: カウンターアプリ（TEAの完全な実装例）
 
module Main exposing (main)
 
import Browser
import Html exposing (Html, button, div, text, h1, p)
import Html.Attributes exposing (style)
import Html.Events exposing (onClick)
 
 
-- MODEL: アプリケーションの状態
 
type alias Model =
    { count : Int
    , history : List Int
    }
 
init : Model
init =
    { count = 0
    , history = []
    }
 
 
-- UPDATE: 状態遷移ロジック
 
type Msg
    = Increment
    | Decrement
    | Reset
    | Double
 
update : Msg -> Model -> Model
update msg model =
    case msg of
        Increment ->
            { model
                | count = model.count + 1
                , history = model.count :: model.history
            }
 
        Decrement ->
            { model
                | count = model.count - 1
                , history = model.count :: model.history
            }
 
        Reset ->
            { model
                | count = 0
                , history = model.count :: model.history
            }
 
        Double ->
            { model
                | count = model.count * 2
                , history = model.count :: model.history
            }
 
 
-- VIEW: 状態を HTML に変換する純粋関数
 
view : Model -> Html Msg
view model =
    div []
        [ h1 [] [ text "Elm カウンター" ]
        , p [] [ text ("現在値: " ++ String.fromInt model.count) ]
        , button [ onClick Decrement ] [ text "-1" ]
        , button [ onClick Increment ] [ text "+1" ]
        , button [ onClick Double ] [ text "x2" ]
        , button [ onClick Reset ] [ text "リセット" ]
        , p [] [ text ("履歴: " ++ historyToString model.history) ]
        ]
 
historyToString : List Int -> String
historyToString history =
    history
        |> List.reverse
        |> List.map String.fromInt
        |> String.join " -> "
 
 
-- MAIN: アプリケーションのエントリポイント
 
main : Program () Model Msg
main =
    Browser.sandbox
        { init = init
        , update = update
        , view = view
        }

// F#: 代数的データ型とパターンマッチ
 
// 判別共用体（Discriminated Union）
type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float
    | Triangle of base_: float * height: float
 
// パターンマッチによる面積計算
let area shape =
    match shape with
    | Circle r -> System.Math.PI * r * r
    | Rectangle (w, h) -> w * h
    | Triangle (b, h) -> 0.5 * b * h
 
// パイプ演算子によるデータ変換
let processShapes shapes =
    shapes
    |> List.map (fun s -> (s, area s))     // 面積を計算
    |> List.sortBy snd                      // 面積順ソート
    |> List.filter (fun (_, a) -> a > 10.0) // 面積10超のみ
    |> List.map (fun (s, a) ->
        sprintf "%A: %.2f" s a)             // 文字列フォーマット
 
// 計算式（Computation Expressions）
// モナド的な計算を読みやすく書ける F# 独自の機能
type MaybeBuilder() =
    member _.Bind(x, f) =
        match x with
        | Some v -> f v
        | None -> None
    member _.Return(x) = Some x
    member _.ReturnFrom(x) = x
    member _.Zero() = None
 
let maybe = MaybeBuilder()
 
// 使用例: Haskell の do記法に相当
let safeDivide x y =
    maybe {
        if y = 0.0 then
            return! None
        else
            return x / y
    }
 
let calculateResult () =
    maybe {
        let! a = safeDivide 100.0 5.0    // Some 20.0
        let! b = safeDivide a 4.0        // Some 5.0
        let! c = safeDivide b 0.0        // None → 全体が None
        return c
    }
// calculateResult() → None

// F#: 非同期ワークフロー
 
open System.Net.Http
 
// 非同期計算式（async CE）
let fetchUrlAsync (url: string) =
    async {
        use client = new HttpClient()
        let! response = client.GetStringAsync(url) |> Async.AwaitTask
        return response.Length
    }
 
// 複数URLの並列フェッチ
let fetchMultiple urls =
    urls
    |> List.map fetchUrlAsync
    |> Async.Parallel        // 並列実行
    |> Async.RunSynchronously
 
// Active Patterns: F#独自の強力なパターンマッチ拡張
let (|Even|Odd|) n =
    if n % 2 = 0 then Even else Odd
 
let (|Positive|Negative|Zero|) n =
    if n > 0 then Positive
    elif n < 0 then Negative
    else Zero
 
let describeNumber n =
    match n with
    | Positive & Even -> sprintf "%d は正の偶数" n
    | Positive & Odd  -> sprintf "%d は正の奇数" n
    | Negative        -> sprintf "%d は負の数" n
    | Zero            -> "ゼロ"

(* OCaml: モジュールとファンクタ *)
 
(* モジュール型（シグネチャ）の定義 *)
module type COMPARABLE = sig
  type t
  val compare : t -> t -> int
  val to_string : t -> string
end
 
(* ファンクタ: モジュールを引数に取り、新しいモジュールを返す *)
module MakeSortedSet (Item : COMPARABLE) = struct
  type element = Item.t
  type t = element list
 
  let empty = []
 
  let rec insert x = function
    | [] -> [x]
    | (h :: _) as l when Item.compare x h < 0 -> x :: l
    | h :: t when Item.compare x h > 0 -> h :: insert x t
    | l -> l  (* x = h の場合、重複を許さない *)
 
  let rec member x = function
    | [] -> false
    | h :: _ when Item.compare x h = 0 -> true
    | h :: t when Item.compare x h > 0 -> member x t
    | _ -> false
 
  let to_list s = s
 
  let to_string s =
    let elements = List.map Item.to_string s in
    "{" ^ String.concat ", " elements ^ "}"
end
 
(* 具体的なモジュールを作る *)
module IntItem : COMPARABLE with type t = int = struct
  type t = int
  let compare = compare
  let to_string = string_of_int
end
 
module IntSortedSet = MakeSortedSet(IntItem)
 
(* 使用例 *)
let example =
  IntSortedSet.empty
  |> IntSortedSet.insert 5
  |> IntSortedSet.insert 3
  |> IntSortedSet.insert 7
  |> IntSortedSet.insert 3  (* 重複は無視される *)
  |> IntSortedSet.to_string
(* → "{3, 5, 7}" *)

(* OCaml 5.0+: エフェクトハンドラとドメイン *)
 
(* ドメインによる並列計算 *)
let parallel_map f lst =
  let n = List.length lst in
  let results = Array.make n None in
  let domains = List.mapi (fun i x ->
    Domain.spawn (fun () ->
      results.(i) <- Some (f x)
    )
  ) lst in
  List.iter Domain.join domains;
  Array.to_list (Array.map (fun x ->
    match x with Some v -> v | None -> failwith "unreachable"
  ) results)
 
(* 使用例 *)
(* let heavy_compute x = (* 重い計算 *) x * x *)
(* let results = parallel_map heavy_compute [1; 2; 3; 4; 5; 6; 7; 8] *)
 
(* パターンマッチの網羅性チェック *)
type color = Red | Green | Blue
 
let color_to_string = function
  | Red   -> "赤"
  | Green -> "緑"
  | Blue  -> "青"
  (* コンパイラが全パターンの網羅を検証する *)
  (* パターンが不足していれば警告が出る *)

-- Haskell: 遅延評価 + 無限リスト
fibs :: [Integer]
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
 
nthFib :: Int -> Integer
nthFib n = fibs !! n

# Elixir: Stream（遅延列挙）+ パイプ
defmodule Fibonacci do
  def stream do
    Stream.unfold({0, 1}, fn {a, b} -> {a, {b, a + b}} end)
  end
 
  def nth(n) do
    stream() |> Enum.at(n)
  end
 
  def first(n) do
    stream() |> Enum.take(n)
  end
end
 
# Fibonacci.first(10) → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

-- Elm: 再帰 + タプル（無限リストなし）
fibonacci : Int -> List Int
fibonacci n =
    let
        helper i (a, b) acc =
            if i >= n then
                List.reverse acc
            else
                helper (i + 1) (b, a + b) (a :: acc)
    in
    helper 0 (0, 1) []
 
-- fibonacci 10 → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

// F#: Seq（遅延シーケンス）+ パイプ
let fibs =
    Seq.unfold (fun (a, b) -> Some(a, (b, a + b))) (0, 1)
 
let nthFib n = fibs |> Seq.item n
let firstFibs n = fibs |> Seq.take n |> Seq.toList
 
// firstFibs 10 → [0; 1; 1; 2; 3; 5; 8; 13; 21; 34]

(* OCaml: Seq（遅延シーケンス）+ パイプ *)
let fibs =
  let rec aux a b () =
    Seq.Cons (a, aux b (a + b))
  in
  aux 0 1
 
let nth_fib n = fibs |> Seq.drop n |> Seq.uncons |> Option.map fst
let first_fibs n = fibs |> Seq.take n |> List.of_seq
 
(* first_fibs 10 → [0; 1; 1; 2; 3; 5; 8; 13; 21; 34] *)

-- アンチパターン: モナド変換子の過剰なネスト
-- 型シグネチャが爆発し、保守不能になる
 
type AppStack a =
  ExceptT AppError
    (StateT AppState
      (ReaderT AppConfig
        (WriterT [LogEntry]
          IO))) a
 
-- 問題点:
-- 1. 型シグネチャが巨大で読解困難
-- 2. lift の連鎖が必要（lift . lift . lift ...）
-- 3. スタックの順序変更が大規模リファクタリングを要求
-- 4. パフォーマンスへの悪影響（各層のオーバーヘッド）

-- 回避策1: ReaderT パターン（シンプルで実用的）
-- 1つの ReaderT + IORef で多くのケースをカバー
 
data AppEnv = AppEnv
  { envConfig :: AppConfig
  , envState  :: IORef AppState
  , envLogger :: LogEntry -> IO ()
  }
 
type App a = ReaderT AppEnv IO a
 
-- クリーンな型シグネチャ
getConfig :: App AppConfig
getConfig = asks envConfig
 
modifyState :: (AppState -> AppState) -> App ()
modifyState f = do
  ref <- asks envState
  liftIO $ modifyIORef ref f
 
logMessage :: LogEntry -> App ()
logMessage entry = do
  logger <- asks envLogger
  liftIO $ logger entry
 
-- 回避策2: 型エイリアスで段階的に抽象化
-- 必要な機能だけを制約として表現
class Monad m => HasConfig m where
  getAppConfig :: m AppConfig
 
class Monad m => HasState m where
  getAppState    :: m AppState
  putAppState    :: AppState -> m ()

# アンチパターン: 管理されないプロセスの起動
 
defmodule LeakyModule do
  # 問題: spawn したプロセスが誰にも管理されない
  def process_batch(items) do
    Enum.each(items, fn item ->
      spawn(fn ->
        # 重い処理
        result = heavy_computation(item)
        # 結果を使いたいが、呼び出し元に返す手段がない
        IO.puts("Done: #{result}")
      end)
    end)
    # 問題点:
    # 1. プロセスの完了を待てない
    # 2. エラーが発生しても検知できない
    # 3. プロセスが永遠に待機状態になる可能性
    # 4. メモリが徐々に消費される
  end
end

# 回避策: Task.Supervisor + タイムアウト管理
 
defmodule SafeModule do
  # Supervisor 配下で Task を管理する
  def process_batch(items) do
    # Task.Supervisor は Application の Supervisor Tree に登録済みとする
    tasks =
      Enum.map(items, fn item ->
        Task.Supervisor.async(
          MyApp.TaskSupervisor,
          fn -> heavy_computation(item) end,
          shutdown: :brutal_kill  # タイムアウト時の強制終了
        )
      end)
 
    # 全タスクの完了を待つ（タイムアウト付き）
    results =
      Task.yield_many(tasks, timeout: 30_000)  # 30秒タイムアウト
      |> Enum.map(fn
        {task, {:ok, result}} ->
          {:ok, result}
        {task, {:exit, reason}} ->
          Task.shutdown(task)
          {:error, reason}
        {task, nil} ->
          Task.shutdown(task)   # タイムアウトしたタスクを強制終了
          {:error, :timeout}
      end)
 
    results
  end
end
 
# Application の Supervisor Tree に TaskSupervisor を登録
# defmodule MyApp.Application do
#   def start(_type, _args) do
#     children = [
#       {Task.Supervisor, name: MyApp.TaskSupervisor}
#     ]
#     Supervisor.start_link(children, strategy: :one_for_one)
#   end
# end

-- アンチパターン: 過剰に抽象化された型
 
-- 単純な設定値の取得に、過剰な型クラス階層を導入
class (Monad m, MonadReader r m, HasConfig r,
       MonadError AppError m, MonadLogger m,
       MonadMetrics m, MonadCache m) =>
  AppMonad r m | m -> r where
    runApp :: m a -> IO (Either AppError a)
 
-- 問題点:
-- 1. 型エラーメッセージが数十行に及ぶ
-- 2. 新しいチームメンバーが理解するのに数週間かかる
-- 3. コンパイル時間が大幅に増加
-- 4. 実際のビジネスロジックが型の複雑さに埋もれる

data Shape
  = Circle Double
  | Rectangle Double Double
  | Triangle Double Double
  deriving (Show)
 
area :: Shape -> Double
area (Circle r)      = pi * r * r
area (Rectangle w h) = w * h
area (Triangle b h)  = 0.5 * b * h
 
sortByAreaDesc :: [Shape] -> [Shape]
sortByAreaDesc = sortBy (flip compare `on` area)
 
filterByMinArea :: Double -> [Shape] -> [Shape]
filterByMinArea minArea = filter (\s -> area s >= minArea)
 
-- 使用例
-- let shapes = [Circle 5, Rectangle 3 4, Triangle 6 8, Circle 2]
-- sortByAreaDesc shapes
-- → [Circle 5.0, Triangle 6.0 8.0, Rectangle 3.0 4.0, Circle 2.0]
-- filterByMinArea 20.0 shapes
-- → [Circle 5.0, Triangle 6.0 8.0]

type ValidationError =
    | NameTooShort
    | NameTooLong
    | InvalidEmail
    | InvalidAge of int
 
type User = {
    Name: string
    Email: string
    Age: int
}
 
let validateName name =
    if String.length name < 2 then Error NameTooShort
    elif String.length name > 50 then Error NameTooLong
    else Ok name
 
let validateEmail email =
    if String.exists ((=) '@') email then Ok email
    else Error InvalidEmail
 
let validateAge age =
    if age >= 0 && age <= 150 then Ok age
    else Error (InvalidAge age)
 
// Railway Oriented Programming: bind で連鎖
let createUser name email age =
    validateName name
    |> Result.bind (fun validName ->
        validateEmail email
        |> Result.bind (fun validEmail ->
            validateAge age
            |> Result.map (fun validAge ->
                { Name = validName
                  Email = validEmail
                  Age = validAge })))
 
// createUser "Alice" "alice@example.com" 30 → Ok { Name="Alice"; ... }
// createUser "A" "alice@example.com" 30     → Error NameTooShort
// createUser "Alice" "invalid" 30           → Error InvalidEmail