উচ্চতর ধরণেরগুলি কখন কার্যকর হয়?

Question 1

আমি কিছুক্ষণের জন্য F # তে ডিভ করে যাচ্ছি এবং আমি এটি পছন্দ করি। তবে আমি জানি যে একটি বাজওয়ার্ড F # তে বিদ্যমান নেই এটি হ'ল ধরণের ধরণের। আমি উচ্চ-ধরণের ধরণের উপাদানগুলি পড়েছি এবং আমি মনে করি যে আমি তাদের সংজ্ঞাটি বুঝি। কেন তারা দরকারী তা আমি নিশ্চিত নই। স্কেল বা হাস্কেল, যাতে এফ # তে কাজের ক্ষেত্র প্রয়োজন, উচ্চতর ধরণের কী কী সহজ করে তোলে তার কোনও উদাহরণ কি কেউ সরবরাহ করতে পারেন? এছাড়াও এই উদাহরণগুলির জন্য, উচ্চ ধরণের ধরণের (বা এফ # তে তদ্বিপরীত) ব্যতিরেকে কাজগুলি কী হবে? সম্ভবত আমি এটির চারপাশে কাজ করার জন্য এতটাই অভ্যস্ত হয়ে পড়েছি যে সেই বৈশিষ্ট্যের অনুপস্থিতি আমি লক্ষ্য করি না।

(আমি মনে করি) আমি পেয়েছি যে পরিবর্তে myList |> List.map fবা myList |> Seq.map f |> Seq.toListউচ্চতর ধরণের আপনাকে কেবল লেখার অনুমতি দেয় myList |> map fএবং এটি একটি ফিরে আসবে List। এটি দুর্দান্ত (এটি সঠিক বলে ধরে নিচ্ছেন), তবে কি একরকম ছোটখাটো বলে মনে হচ্ছে? (এবং কেবল ফাংশন ওভারলোডিংকে অনুমতি দিয়ে এটি করা যায়নি?) আমি সাধারণত Seqযেভাবেই রূপান্তর করি এবং তারপরে আমি যা চাই তা রূপান্তর করতে পারি। আবার, সম্ভবত আমি এটি প্রায় কাজ করতে অভ্যস্ত। তবে এমন কোনও উদাহরণ রয়েছে যেখানে উচ্চতর ধরণের ধরণের প্রকৃতপক্ষে কীট্রোকগুলিতে বা প্রকার সুরক্ষায় আপনাকে বাঁচায়?

Question 2

সুতরাং একটি ধরণের ধরণ এটি এর সহজ প্রকার। উদাহরণস্বরূপ Intধরণের রয়েছে *যার অর্থ এটি একটি বেস টাইপ এবং মানগুলির মাধ্যমে তা ইনস্ট্যান্ট করা যায়। উচ্চ kinded ধরনের কিছু আলগা সংজ্ঞা দ্বারা (এবং আমি নিশ্চিত যেখানে এফ # লাইন স্বপক্ষে নই, তাই আসুন শুধু তা অন্তর্ভুক্ত দিন) বহুরুপী পাত্রে একটি উচ্চ-kinded ধরনের একটি বড় উদাহরণ আছে।

data List a = Cons a (List a) | Nil

টাইপ কন্সট্রাক্টরের টাইপ Listরয়েছে * -> *যার অর্থ একটি কংক্রিট টাইপের ফলস্বরূপ এটি একটি কংক্রিট টাইপ পাস করতে হবে: এর List Intমতো বাসিন্দা থাকতে পারে [1,2,3]তবে Listনিজেই পারে না।

আমি ধরে নিচ্ছি যে পলিমারফিক পাত্রে সুবিধাগুলি সুস্পষ্ট, তবে * -> *কেবল ধারকগুলির চেয়ে আরও দরকারী ধরণের প্রকারের উপস্থিতি রয়েছে। উদাহরণস্বরূপ, সম্পর্ক

data Rel a = Rel (a -> a -> Bool)

বা পার্সার্স

data Parser a = Parser (String -> [(a, String)])

উভয়েরও সদয় হয় * -> *।

আমরা এটি আরও উচ্চতর ক্রমযুক্ত ধরণের ধরণের মাধ্যমে, হাস্কেলগুলিতে আরও এগিয়ে নিতে পারি। উদাহরণস্বরূপ আমরা ধরনের সঙ্গে একটি টাইপ জন্য সন্ধান করতে পারে (* -> *) -> *। এটির একটি সাধারণ উদাহরণ হতে পারে Shapeযা কোনও ধরণের পাত্রে ভরাট করার চেষ্টা করে * -> *।

data Shape f = Shape (f ())

[(), (), ()] :: Shape List

এটি Traversableহাস্কেল-এর বৈশিষ্ট্যগুলির জন্য দরকারী , উদাহরণস্বরূপ, কারণ তারা সর্বদা তাদের আকার এবং বিষয়বস্তুগুলিতে বিভক্ত হতে পারে।

split :: Traversable t => t a -> (Shape t, [a])

অন্য উদাহরণ হিসাবে, আসুন এমন একটি গাছ বিবেচনা করুন যা এটির শাখাটির পরামিতি রয়েছে। উদাহরণস্বরূপ, একটি সাধারণ গাছ হতে পারে

data Tree a = Branch (Tree a) a (Tree a) | Leaf

কিন্তু আমরা দেখতে পাচ্ছি শাখা ধরনের একটি রয়েছে Pairএর Tree as এবং তাই আমরা parametrically ধরনের আউট যে টুকরা নিষ্কাশন করতে পারেন

data TreeG f a = Branch a (f (TreeG f a)) | Leaf

data Pair a = Pair a a
type Tree a = TreeG Pair a

এই TreeGধরণের কন্সট্রাক্টর ধরনের আছে (* -> *) -> * -> *। আমরা এটির মতো আকর্ষণীয় অন্যান্য রূপগুলি তৈরি করতে এটি ব্যবহার করতে পারিRoseTree

type RoseTree a = TreeG [] a

rose :: RoseTree Int
rose = Branch 3 [Branch 2 [Leaf, Leaf], Leaf, Branch 4 [Branch 4 []]]

বা প্যাথলজিকাল একটি যেমন MaybeTree

data Empty a = Empty
type MaybeTree a = TreeG Empty a

nothing :: MaybeTree a
nothing = Leaf

just :: a -> MaybeTree a
just a = Branch a Empty

বা ক TreeTree

type TreeTree a = TreeG Tree a

treetree :: TreeTree Int
treetree = Branch 3 (Branch Leaf (Pair Leaf Leaf))

এটি প্রদর্শিত অন্য একটি জায়গা হ'ল "ফান্টারের বীজগণিত"। যদি আমরা বিমূর্ততার কয়েকটি স্তর ফেলে রাখি তবে এটিকে আরও ভাল ভাঁজ হিসাবে বিবেচনা করা যেতে পারে sum :: [Int] -> Int। বীজগণিতগুলি ফান্টেক্টর এবং ক্যারিয়ারের উপরে প্যারামিটারাইজড হয় । Functor ধরনের রয়েছে * -> *এবং ক্যারিয়ার ধরনের *তাই পুরাপুরি

data Alg f a = Alg (f a -> a)

দয়ালু আছে (* -> *) -> * -> *। Algডেটাটাইপগুলির সাথে সম্পর্কিত এবং তাদের উপরে নির্মিত পুনরাবৃত্তি স্কিমগুলির কারণে দরকারী।

-- | The "single-layer of an expression" functor has kind `(* -> *)`
data ExpF x = Lit Int
            | Add x x
            | Sub x x
            | Mult x x

-- | The fixed point of a functor has kind `(* -> *) -> *`
data Fix f = Fix (f (Fix f))

type Exp = Fix ExpF

exp :: Exp
exp = Fix (Add (Fix (Lit 3)) (Fix (Lit 4))) -- 3 + 4

fold :: Functor f => Alg f a -> Fix f -> a
fold (Alg phi) (Fix f) = phi (fmap (fold (Alg phi)) f)

পরিশেষে, যদিও তারা তাত্ত্বিকভাবে সম্ভব, আমি এর চেয়েও উচ্চতর ধরণের নির্মাণকারী কখনও দেখিনি । আমরা কখনও কখনও সেই ধরণের ফাংশন দেখতে পাই mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b, তবে আমি মনে করি যে প্রকার জটিলতার সেই স্তরটি দেখতে আপনাকে প্রলোগ টাইপ করুন বা নির্ভরশীল টাইপ করা সাহিত্যের মধ্যে খনন করতে হবে।

Question 3

Functorহাস্কেলের ধরণের শ্রেণি বিবেচনা করুন , যেখানে fউচ্চতর ধরণের ধরণের পরিবর্তনশীল:

class Functor f where
    fmap :: (a -> b) -> f a -> f b

কি এই ধরনের স্বাক্ষর বলছেন যে fmap একটি ধরণ প্যারামিটার পরিবর্তন হয় fথেকে aথেকে b, কিন্তু পাতার fযেমন ছিল। সুতরাং আপনি যদি fmapকোনও তালিকার উপরে ব্যবহার করেন তবে আপনি একটি তালিকা পান, আপনি যদি এটি কোনও পার্সারের সাহায্যে ব্যবহার করেন তবে আপনি পার্সার পাবেন এবং আরও কিছু। এবং এগুলি স্থির , সংকলন-সময়ের গ্যারান্টি।

আমি এফ # জানি না, তবে আসুন আমরা যদি Functorজাভা বা সি # এর মতো ভাষাতে উত্তরাধিকার এবং জেনেরিক সহ, তবে উচ্চতর ধরণের জেনেরিকগুলি প্রকাশ করার চেষ্টা না করি তবে কী ঘটে তা বিবেচনা করা যাক । প্রথম চেষ্টা:

interface Functor<A> {
    Functor<B> map(Function<A, B> f);
}

এই প্রথম চেষ্টাটির সাথে সমস্যাটি হ'ল ইন্টারফেসের প্রয়োগের ফলে প্রয়োগ করা কোনও শ্রেণি ফেরত দেওয়া যায় Functor। এমন কেউ লিখতে পারেন FunnyList<A> implements Functor<A>যার mapপদ্ধতিতে ভিন্ন ধরণের সংগ্রহ পাওয়া যায়, বা এমন কোনও কিছু যা কোনও সংগ্রহ নয় তবে এটি এখনও একটি Functor। এছাড়াও, আপনি যখন mapপদ্ধতিটি ব্যবহার করেন আপনি ফলাফলের উপর কোনও ধরণের টাইপ-নির্দিষ্ট পদ্ধতিতে আবেদন করতে পারবেন না যদি না আপনি এটি যে ধরণের প্রত্যাশা করছেন তার সাথে এটি বাদ দেন। সুতরাং আমাদের দুটি সমস্যা আছে:

প্রকারের ব্যবস্থাটি আমাদের আক্রমণকারীটিকে প্রকাশ করতে দেয় না যে mapপদ্ধতিটি সর্বদা Functorরিসিভারের মতো একই সাবক্লাসটি দেয় returns
অতএব, Functorফলাফলের জন্য কোনও অ-পদ্ধতিতে প্রার্থনা করার জন্য কোনও স্ট্যাটিকালি টাইপ-নিরাপদ উপায় নেই map।

আপনি চেষ্টা করতে পারেন এমন আরও অনেক জটিল পদ্ধতি রয়েছে তবে সেগুলির কোনওটিই বাস্তবে কার্যকর হয় না। উদাহরণস্বরূপ, আপনি Functorফলাফলের প্রকারকে সীমাবদ্ধ করে উপ-প্রকারের সংজ্ঞা দিয়ে প্রথম চেষ্টাটিকে বাড়িয়ে তোলার চেষ্টা করতে পারেন :

interface Collection<A> extends Functor<A> {
    Collection<B> map(Function<A, B> f);
}

interface List<A> extends Collection<A> {
    List<B> map(Function<A, B> f);
}

interface Set<A> extends Collection<A> {
    Set<B> map(Function<A, B> f);
}

interface Parser<A> extends Functor<A> {
    Parser<B> map(Function<A, B> f);
}

// …

এটি সেই সংকীর্ণ ইন্টারফেসগুলির প্রয়োগকারীদের পদ্ধতি Functorথেকে ভুল ধরণের প্রত্যাবর্তন করতে নিষেধ করতে সহায়তা করে map, তবে যেহেতু Functorআপনার কতগুলি বাস্তবায়ন হতে পারে তার সীমাবদ্ধতা নেই, আপনার কত সংকীর্ণ ইন্টারফেসের প্রয়োজন হবে তার সীমা নেই is

( সম্পাদনা করুন: এবং মনে রাখবেন এই শুধুমাত্র কাজ করে কারণ Functor<B>প্রদর্শিত হয় ফলাফলের প্রকার, এবং তাই সন্তানের ইন্টারফেসগুলি এটা সংকীর্ণ পারেন তাই আমি যতদূর জানি আমরা উভয় ব্যবহারসমূহ সংকীর্ণ করতে পারবে না। Monad<B>নিম্নলিখিত ইন্টারফেসে:

interface Monad<A> {
    <B> Monad<B> flatMap(Function<? super A, ? extends Monad<? extends B>> f);
}

মধ্যে Haskell, উচ্চ-সারির টাইপ ভেরিয়েবল সঙ্গে, এই হল (>>=) :: Monad m => m a -> (a -> m b) -> m b।)

তবুও আরেকটি চেষ্টা হ'ল পুনরাবৃত্ত জেনারিকগুলি ব্যবহার করার চেষ্টা করার জন্য এবং ইন্টারফেসটি সাব টাইপের ফলাফলের ধরণটি কেবল সাব টাইপের মধ্যে সীমাবদ্ধ করে রাখে। খেলনা উদাহরণ:

/**
 * A semigroup is a type with a binary associative operation.  Law:
 *
 * > x.append(y).append(z) = x.append(y.append(z))
 */
interface Semigroup<T extends Semigroup<T>> {
    T append(T arg);
}

class Foo implements Semigroup<Foo> {
    // Since this implements Semigroup<Foo>, now this method must accept 
    // a Foo argument and return a Foo result. 
    Foo append(Foo arg);
}

class Bar implements Semigroup<Bar> {
    // Any of these is a compilation error:

    Semigroup<Bar> append(Semigroup<Bar> arg);

    Semigroup<Foo> append(Bar arg);

    Semigroup append(Bar arg);

    Foo append(Bar arg);

}

তবে এই ধরণের কৌশল (যা আপনার ওপেন-মিল-র ওওপি বিকাশকারীর কাছে বরং তীরযুক্ত, আপনার রান-অফ-দ্য মিল-র কার্যকারিতা বিকাশকারীকেও হ্যাক করুন) এখনও কাঙ্ক্ষিত Functorবাধা প্রকাশ করতে পারে না :

interface Functor<FA extends Functor<FA, A>, A> {
    <FB extends Functor<FB, B>, B> FB map(Function<A, B> f);
}

সমস্যা এখানে এই সীমিত নয় FBএকই আছে Fহিসাবে FA-so যখন আপনি একটি টাইপ ঘোষণা করছি যে List<A> implements Functor<List<A>, A>, mapপদ্ধতি করতে এখনো একটি ফিরতি NotAList<B> implements Functor<NotAList<B>, B>।

জাভাতে কাঁচা ধরণের (অপরিশোধিত পাত্রে) ব্যবহার করে চূড়ান্ত চেষ্টা করুন:

interface FunctorStrategy<F> {
    F map(Function f, F arg);
}

এখানে Fকেবল Listবা এর মতো অপরিশোধিত প্রকারভেদে তাত্ক্ষণিকভাবে আসবে Map। এটি গ্যারান্টি দেয় যে একজন FunctorStrategy<List>কেবলমাত্র ফিরিয়ে দিতে পারে List- তবে আপনি তালিকার উপাদানগুলির ধরনগুলি ট্র্যাক করতে টাইপ ভেরিয়েবলের ব্যবহার পরিত্যাগ করেছেন।

এখানে সমস্যার কেন্দ্রস্থল হ'ল জাভা এবং সি # এর মতো ভাষা টাইপ পরামিতিগুলিকে পরামিতি রাখতে দেয় না। জাভা, যদি Tএকটি টাইপ পরিবর্তনশীল, আপনি লিখতে পারেন Tএবং List<T>, কিন্তু না T<String>। উচ্চ-ধরণের ধরণের ধরণগুলি এই বিধিনিষেধটি সরিয়ে দেয়, যাতে আপনার এমন কিছু থাকতে পারে (পুরোপুরি ভাবেননি):

interface Functor<F, A> {
    <B> F<B> map(Function<A, B> f);
}

class List<A> implements Functor<List, A> {

    // Since F := List, F<B> := List<B>
    <B> List<B> map(Function<A, B> f) {
        // ...
    }

}

এবং এই বিট বিশেষভাবে সম্বোধন:

(আমি মনে করি) আমি পেয়েছি যে পরিবর্তে myList |> List.map fবা myList |> Seq.map f |> Seq.toListউচ্চতর ধরণের আপনাকে কেবল লেখার অনুমতি দেয় myList |> map fএবং এটি একটি ফিরে আসবে List। এটি দুর্দান্ত (এটি সঠিক বলে ধরে নিচ্ছেন), তবে কি একরকম ছোটখাটো বলে মনে হচ্ছে? (এবং কেবল ফাংশন ওভারলোডিংকে অনুমতি দিয়ে এটি করা যায়নি?) আমি সাধারণত Seqযেভাবেই রূপান্তর করি এবং তারপরে আমি যা চাই তা রূপান্তর করতে পারি।

এমন অনেকগুলি ভাষা রয়েছে যা এইভাবে mapফাংশনটির ধারণাটিকে সাধারণীকরণ করে , একে মডেলিং করে যেমন হৃদয়ে, ম্যাপিংটি সিকোয়েন্সগুলি সম্পর্কে। পুলিশের এই মন্তব্য যে আত্মা রয়েছে: যদি আপনি একটি যে ধরনের এবং থেকে সমর্থন রূপান্তর আছে Seq, আপনি পুনঃব্যবহার দ্বারা "বিনামূল্যে জন্য" মানচিত্র অপারেশন পেতে Seq.map।

হাসকেলে অবশ্য Functorক্লাসটি তার চেয়ে বেশি সাধারণ; এটি অনুক্রমের ধারণার সাথে আবদ্ধ নয়। fmapক্রম IO, পার্সার সংযুক্তকারী, ফাংশন ইত্যাদির মতো সিকোয়েন্সগুলিতে ভাল ম্যাপিং নেই এমন প্রকারের জন্য আপনি প্রয়োগ করতে পারেন . :

instance Functor IO where
    fmap f action =
        do x <- action
           return (f x)

 -- This declaration is just to make things easier to read for non-Haskellers 
newtype Function a b = Function (a -> b)

instance Functor (Function a) where
    fmap f (Function g) = Function (f . g)  -- `.` is function composition

"ম্যাপিং" ধারণাটি আসলেই অনুক্রমের সাথে আবদ্ধ নয়। ফান্টারের আইনগুলি বোঝা ভাল:

(1) fmap id xs == xs
(2) fmap f (fmap g xs) = fmap (f . g) xs

খুব অনানুষ্ঠানিকভাবে:

প্রথম আইনটি বলে যে কোনও পরিচয় / নূপুর ফাংশন সহ ম্যাপিং কিছুই না করার মতো।
দ্বিতীয় আইন বলছে যে আপনি দুবার ম্যাপিংয়ের মাধ্যমে যে কোনও ফলাফল তৈরি করতে পারেন, আপনি একবার ম্যাপিংয়ের মাধ্যমেও উত্পাদন করতে পারেন।

এ কারণেই আপনি fmapটাইপটি সংরক্ষণ করতে চান — কারণ আপনি যেমন mapকোনও ভিন্ন ফলাফলের প্রকার উত্পাদন করে এমন অপারেশনগুলি পাওয়ার সাথে সাথে এটির গ্যারান্টি দেওয়া অনেক বেশি শক্ত হয়ে যায়।

Question 4

আমি ইতিমধ্যে এখানে কিছু দুর্দান্ত উত্তরে তথ্য পুনরাবৃত্তি করতে চাই না, তবে একটি মূল পয়েন্ট আমি যুক্ত করতে চাই।

নির্দিষ্ট কোনও মোনাড, বা ফান্টেক্টর (বা প্রয়োগমূলক ফান্টেক্টর, বা তীর, বা ...) বাস্তবায়নের জন্য আপনার সাধারণত উচ্চ ধরণের ধরণের প্রয়োজন হয় না। তবে এটি করার বিষয়টি বেশিরভাগ ক্ষেত্রেই অনুপস্থিত।

সাধারণভাবে আমি দেখতে পেয়েছি যে লোকেরা যখন ফান্ট্যাকার / মনড / তড়িঘড়িগুলির কার্যকারিতা দেখতে পায় না তখন এটি প্রায়শই হয় কারণ তারা একবারে এই জিনিসগুলি নিয়ে ভাবছে । ফান্টেক্টর / মোনাড / ইত্যাদি ক্রিয়াকলাপগুলি সত্যিই কোনও উদাহরণে কিছু যোগ করে না (বাঁধাই, এফএমএপি ইত্যাদি কল করার পরিবর্তে আমি কেবল বাইন্ড, এফএমএপি, ইত্যাদি প্রয়োগ করতে যা কিছু অপারেশন কল করতে পারি )। আপনি এই বিমূর্ততাগুলির জন্য যা চান তা হ'ল যাতে আপনার কোনও কোড থাকতে পারে যা কোনও ফান্টার / মোনাড / ইত্যাদির সাথে সাধারণভাবে কাজ করে ।

এমন প্রসঙ্গে যেখানে এই জাতীয় জেনারিক কোডটি ব্যাপকভাবে ব্যবহৃত হয়, এর অর্থ আপনি যখনই কোনও নতুন মোনাড লিখেন তখন আপনার ধরণটি তত্ক্ষণাত আপনার জন্য ইতিমধ্যে লেখা রয়েছে এমন বিশাল সংখ্যক দরকারী অপারেশনে অ্যাক্সেস অর্জন করে । এটি সর্বত্র monads (এবং ফান্টেক্টর, এবং ...) দেখার বিষয়; আমি এর bindপরিবর্তে concatএবং mapপ্রয়োগ করতে myFunkyListOperation(যা আমাকে নিজের মধ্যে কিছুই লাভ করে না) ব্যবহার করতে পারি না , বরং যাতে যখন আমার প্রয়োজন হয় myFunkyParserOperationএবং myFunkyIOOperationতালিকার সাথে আমি যে কোডটি দেখেছিলাম সেগুলি পুনরায় ব্যবহার করতে পারি কারণ এটি আসলে মোনাড-জেনেরিক ।

তবে টাইপ সুরক্ষার সাথে একটি প্যারামিতি টাইপের মতো মনোডের মতো বিমূর্তকরণের জন্য আপনার উচ্চতর ধরণের (যেমন অন্যান্য উত্তরগুলিতে এখানেও ব্যাখ্যা করেছেন) প্রয়োজন।

Question 5

আরও। নেট-নির্দিষ্ট দৃষ্টিকোণের জন্য, আমি এই সম্পর্কে কিছুক্ষণ আগে একটি ব্লগ পোস্ট লিখেছিলাম । এটির মূল বিষয়টি হ'ল উচ্চ-ধরণের প্রকারের সাথে, আপনি সম্ভবত IEnumerablesএবং এর মধ্যে একই লিনকুই ব্লকগুলি পুনরায় ব্যবহার করতে পারেন IObservablesতবে উচ্চতর ধরনের ছাড়া এটি অসম্ভব।

আপনি যে নিকটতম পেলেন (ব্লগ পোস্ট করার পরে আমি বুঝতে পেরেছি) তা হ'ল নিজের তৈরি করা IEnumerable<T>এবং এটি IObservable<T>দুটি থেকে প্রসারিত করা IMonad<T>। এটি আপনাকে আপনার লিনকিউ ব্লকগুলি চিহ্নিত করা থাকলে পুনরায় ব্যবহার করার অনুমতি দেয় IMonad<T>, তবে এটি আর টাইপসেফ নেই কারণ এটি আপনাকে মেশানো এবং মিল করতে দেয় IObservablesএবং IEnumerablesএকই ব্লকের মধ্যে যা এটি সক্ষম করতে আগ্রহী মনে হতে পারে, আপনি চাইতেন মূলত কিছু অপরিজ্ঞাত আচরণ পান।

হাস্কেল কীভাবে এটিকে সহজ করে তোলে আমি তার পরে একটি পোস্ট লিখেছিলাম । (কোনও অনিঃপত্তি, সত্যই - নির্দিষ্ট ধরণের মোনাডে একটি ব্লককে সীমাবদ্ধ করার জন্য কোড প্রয়োজন; পুনরায় ব্যবহার সক্রিয় করা ডিফল্ট)

Question 6

হাস্কেলের মধ্যে উচ্চ-ধরণের টাইপ পলিমারফিজমের সর্বাধিক ব্যবহৃত উদাহরণ হ'ল Monadইন্টারফেস। Functorএবং Applicativeএকইভাবে উচ্চ-দয়ালু, তাই আমি Functorসংক্ষিপ্ত কিছু দেখানোর জন্য প্রদর্শন করব ।

class Functor f where
    fmap :: (a -> b) -> f a -> f b

এখন, সংজ্ঞাটি পরীক্ষা করে দেখুন কীভাবে ভেরিয়েবল টাইপ fব্যবহৃত হয় তা দেখে। আপনি দেখতে পাবেন এর fঅর্থ এমন কোনও প্রকারের অর্থ হতে পারে না। আপনি সেই ধরণের স্বাক্ষরে মানগুলি সনাক্ত করতে পারেন কারণ তারা কোনও ফাংশনের যুক্তি এবং ফলাফল। সুতরাং ভেরিয়েবল টাইপ করুন aএবং bএমন ধরণ যা মান থাকতে পারে। টাইপ এক্সপ্রেশন f aএবং হয় f b। তবে fনিজেই নয়। fএকটি উচ্চ ধরণের ধরণের পরিবর্তনশীল একটি উদাহরণ। প্রদত্ত যে *মান করতে পারে ধরনের ধরনের, fধরনের থাকতে হবে * -> *। অর্থাৎ এটি একটি টাইপ মান করতে পারে, কারণ আমরা পূর্ববর্তী পরীক্ষার থেকে জানি যে সময় লাগে aএবং bমান থাকা আবশ্যক। এবং আমরা জানি যে f aএবংf b মান থাকতে হবে, সুতরাং এটি এমন একটি টাইপ দেয় যা মান থাকতে হবে।

এটি উচ্চতর ধরণের ধরণের পরিবর্তনশীল সংজ্ঞাতে fব্যবহৃত হয় Functor।

Applicativeএবং Monadইন্টারফেস আরো যোগ, কিন্তু তারা সামঞ্জস্যপূর্ণ। এর অর্থ তারা প্রকারের সাথে টাইপ ভেরিয়েবলগুলিতেও কাজ করে * -> *।

উচ্চতর ধরণের ধরণের উপর কাজ করা বিমূর্ততার একটি অতিরিক্ত স্তরের পরিচয় দেয় - আপনি কেবলমাত্র প্রাথমিক ধরণের উপর বিমূর্ততা তৈরি করতে সীমাবদ্ধ নন। আপনি অন্যান্য ধরণের পরিবর্তনকারী প্রকারের উপর বিমূর্ততাও তৈরি করতে পারেন।