จะให้ฉันใช้ Constraint ครอบครัวที่อยู่ในขอบเขตเพื่อพิสูจน์โหภายในร่างของการแสดง?

Question 1

นี่คือตามต้อง ของฉันก่อนหน้านี้คำถาม. ฉัน recieved ดีบางอย่างคำตอบนั้นแต่เพราะฉันประยุกต์@item text character set ที่แท้จริงของผมปัญหาคือฉันคิดว่าฉันเข้าใจผิดที่ answerers และฉันหวังว่าจะแก้ไขเรื่องนั้นอยู่ที่นี่

TL;ด็อกเตอร์ ฉันมี typeclass Category จาก constrained-categories ซึ่ง constrains งโดเมน/codomain ของมัน Categorys ใช้ TypeFamily("constraint ครอบครัว")เรียกว่า Object. ฉันต้องการจะทำให้เป็นอิสระ Categoryแต่ฉันต้องดิ้นรนเพื่อหาลักฐานนั่น/n พอใจคน Object constraint.

พิจารณาของฉัน Free ข้อมูลประเภทและของมัน constrained-categories.Category ตัวอย่าง:

data Free p a b where
  Id :: Object p a => Free p a a
  Comp :: Object p b => Free p b c -> Free p a b -> Free p a c

instance Category (Free p) where
  type Object (Free p) a = Object p a -- passes through the constraints from instantiated `p`
  id = Id
  (.) = Comp

จะอธิบายเรื่องอีกหน่อยได้มัยกลับมามายังถือว่าเป็นคนที่ไม่ใช่อิสระ Category ฉันอาจชอบ eval ไปยัง:

newtype MyArr a b = MyArr (a -> b)

instance Category MyArr where
  type Object MyArr a = () -- trivial, no constraints needed
  id = MyArr P.id
  MyArr g . MyArr f = MyArr (g . f)

ฉันต้องการจะเขียนการแสดงเหมือนนี้(ซึ่งมันเห็นได้ชัดว่าไกลที่ง่ายกว่า/n ฉันจะเขียนอยู่ซ้อม):

-- error: Could not deduce: Object p Int arising from a use of ‘Id’
e0 :: Free p Int Int
e0 = Id

ฉันสามารถแก้ไขเรื่องนี้ที่เห็นได้ชัดแต่มันจะกลายเป็น verbose สำหรับที่ยิ่งใหญ่แสดง. นึกถึงการเขียนจดหมายฟังก์ชันของ tuples และต้องใช้ไปในข้อบังคับให้เป็น Object p _ ตัวอย่างสำหรับทุกชั่วคราวอยู่ในขั้นตองค์ประกอบ:

e1 :: Object p Int => Free p Int Int
e1 = Id

ฉันจะเลือกที่จะ ไม่ใช่ คนแบบนามปธรรม Category pและนั่นทำงาน:

e2 :: Free MyArr Int Int
e2 = Id

แต่ฉันอยากจะจับมัน ฉันควรจะคิดว่าการเพิ่มเป็น constraint Category p ควรจะทำงาน,และนำไปสู่ขอบเขตของมัน constraint นั้น type Object (Free p) a = Object p aและให้ฉันมี Object p _ ตัวอย่างผมต้องการแต่อนิจจามันไม่ทำงาน

-- error: Could not deduce: Object p Int arising from a use of ‘Id’
e3 :: Category p => Free p Int Int
e3 = Id

มันดูเหมือนว่า QuantifiedConstraints อาจจะช่วย,eg forall a. Object (Free p) a => Object p aแต่คุณไม่สามารถมี TypeFamily ในหัวของ predicate.

ฉันยังถูกพิจารณาโดยใช้ type Object p :: * -> Constraint เหมือนอยู่ใน Conal เอลเลียตเป็น concat องสมุด,แต่นั่นมันต้องการ\n ที่จะแตกต่างห้องสมุดคนละ Category ชั้นเรียนและครั้งสุดท้ายที่ฉันเคยใช้หมวดหมู่ constrained ทางนั้นมันดูเหมืออีกหน่อยได้มัยกลับมา cumbersome และฉันไม่ค่อยแน่ใจว่า นั่น จะแก้ปัญหาของฉัน boilerplate เหมือนไม่มีปัญหาอยู่เลยสินะ เป็น ความคิดเห็น อยู่ในห้องสมุดบ่งบอกคนของ usefulness QuantifiedConstraintsแต่ฉันค่อนข้างบิดเบือนตอนนี้และไม่รู้จักซึ่งในทางที่จะ trudge ไปข้างหน้า

Runnable

{-# LANGUAGE GADTs #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE TypeFamilies #-}

module ConstrainedCategoryFreeArrow3 where

import Prelude hiding (id, (.))
import qualified Prelude as P
import Control.Category.Constrained


-- * A Free 'Category'

data Free p a b where
  Id :: Object p a => Free p a a
  Comp :: Object p b => Free p b c -> Free p a b -> Free p a c

instance Category (Free p) where
  type Object (Free p) a = Object p a -- passes through the constraints from instantiated `p`
  id = Id
  (.) = Comp

eval :: (Category p, Object p a, Object p b) => Free p a b -> p a b
eval Id = id
eval (Comp g f) = eval g . eval f


-- * A specific (trivial) 'Category'

newtype MyArr a b = MyArr (a -> b)

instance Category MyArr where
  type Object MyArr a = () -- trivial, no constraints needed
  id = MyArr P.id
  MyArr g . MyArr f = MyArr (g . f)


-- * A generic expression

-- -- error: Could not deduce: Object p Int arising from a use of ‘Id’
-- e0 :: Free p Int Int
-- e0 = Id


-- works, but becomes verbose. Imagine for instance building an expression with
-- functions of tuples; you would need to provide an incredible amount of
-- boilerplate constraints for each permutation of types in tuples used anywhere
-- in the body. The problem is a little worse than this once you account for
-- `Cartesian` which has a Constraint Family called `PairObjects` where you need
-- to prove that each tuple is an allowed product in the current constrained
-- category.
e1 :: Object p Int => Free p Int Int
e1 = Id


-- works, but is no longer abstract in the category `p`
e2 :: Free MyArr Int Int
e2 = Id


-- -- ideal solution, but alas
-- -- error: Could not deduce: Object p Int arising from a use of ‘Id’
-- e3 :: Category p => Free p Int Int
-- e3 = Id

Question 2

{-# LANGUAGE GADTs, RankNTypes, TypeApplications, AllowAmbiguousTypes #-}

ฉันเกรงว่าจะเก็บของโครงสรางทุกอย่าง"ปรับเทียบข้อมูลกับคน p หมวดหมู่แต่ในเวลาเดียวกันเป็นแบบนามปธรรมในหมวดหมู่จะเลี่ยงได้มาก cumbersome.

ฉันจะแนะนำให้คุณหลีกเลี่ยงมันโดยการใช้ของตัวเองสิ่งลำดับชั้นในผังต้นไม้ซึ่งจะแข็งแกร่งมากกว่า p ลำดับชั้นในผังต้นไม้. คุณต้องการชั้นเรียนต้องไปด้วยอะไรซักอย่างที่แปล/อ่อนแรงลงจากของตัวเองลำดับชั้นในผังต้นไม้เข้าไปในเป้าหมายหมวดหมู่ย

คนงานง่ายสุดนี้จะนั่น p จริงๆไม่มี constraint,i.e. อะไรจะยังเป็นแสดงโดย ∀ a. Object (Free p) a. นี่มันจะเป็นคนเรียน

class UnconstrainedCat p where
  proveUnconstrained :: ∀ a r . (Object p a => r) -> r

...แต่นี่มันค่อนข้า unrealistic;ถ้านั่นเป็นสถานการณ์นั้นคุณก็คงไม่ต้องการใช้ constrained-categories ในตอนแรก

เอาเป็นว่าวัตถุคุณต้องการอยู่ของคุณแสดงอยู่ Intเอส ()s และรอบการ tuples ของพวกนั้นด้วย (จะได้ส่วนขยายเพิ่มเติมเพื่ออีกประเภทหรือรายชื่อของอะตอมประเภท.) จากนั้นเราจะสามารถตามแกะรอยอยู่ที่ค่าระดับอะไรประเภทมันเป็นจริงๆแล้วพวกเราก็กำลังรับมือกับ:

data IntTupleFlavour t where
  UnitCase :: IntTupleFlavour ()
  IntCase :: IntTupleFlavour Int
  TupleCase :: IntTupleFlavour a -> IntTupleFlavour b -> IntTupleFlavour (a,b)

class IntTuple t where
  intTupleFlavour :: IntTupleFlavour t
instance IntTuple () where
  intTupleFlavour = UnitCase
instance IntTuple Int where
  intTupleFlavour = IntCase
instance (IntTuple a, IntTuple b) => IntTuple (a,b) where
  intTupleFlavour = TupleCase intTupleFlavour intTupleFlavour

data IntFree a b where
  IntId :: IntTupleFlavour a -> IntFree a a
  IntCompo :: IntTupleFlavour b -> IntFree b c -> IntFree a b -> IntFree a c

instance Category IntFree where
  type Object IntFree a = IntTuple a
  id = IntId intTupleFlavour
  (.) = IntCompo intTupleFlavour

ตอนนี้มันง่ายที่จะเขียนแสดงของฟรีหมวดหมู่ที่คอมไพเลอร์ รู้ว่า อะไรเป็นวัตถุอยู่ที่นี่และ p ไม่แม้แต่จะพูดถึงเลย

e4 :: IntFree Int Int
e4 = id

p เดียวที่เข้ามาเมื่อคุณในที่สุดแปลเพื่อนประเภทนั้น..

class IntMonoiCat p where
  proveIntTupleInstance :: IntTupleFlavour t -> (Object p t => r) -> r

instance IntMonoiCat MyArr where
  proveIntTupleInstance _ q = q
    -- trivial, because `MyArr` doesn't even have a constraint! In general,
    -- you would need to pattern-match on the `IntTupleFlavour` here.

แล้ว

instance EnhancedCat MyArr IntFree where
  arr (IntId itf) = proveIntTupleInstance itf id
  arr (IntCompo f g) = ...
        -- here you still need to extract the `IntTupleFlavours`
        -- for the `a` and `c` types. That requires digging into
        -- the free-category structure with a helper function.

leftaroundabout · Answer 1 · 2021-11-23T23:48:38

{-# LANGUAGE GADTs, RankNTypes, TypeApplications, AllowAmbiguousTypes #-}

ฉันเกรงว่าจะเก็บของโครงสรางทุกอย่าง"ปรับเทียบข้อมูลกับคน p หมวดหมู่แต่ในเวลาเดียวกันเป็นแบบนามปธรรมในหมวดหมู่จะเลี่ยงได้มาก cumbersome.

ฉันจะแนะนำให้คุณหลีกเลี่ยงมันโดยการใช้ของตัวเองสิ่งลำดับชั้นในผังต้นไม้ซึ่งจะแข็งแกร่งมากกว่า p ลำดับชั้นในผังต้นไม้. คุณต้องการชั้นเรียนต้องไปด้วยอะไรซักอย่างที่แปล/อ่อนแรงลงจากของตัวเองลำดับชั้นในผังต้นไม้เข้าไปในเป้าหมายหมวดหมู่ย

คนงานง่ายสุดนี้จะนั่น p จริงๆไม่มี constraint,i.e. อะไรจะยังเป็นแสดงโดย ∀ a. Object (Free p) a. นี่มันจะเป็นคนเรียน

class UnconstrainedCat p where
  proveUnconstrained :: ∀ a r . (Object p a => r) -> r

...แต่นี่มันค่อนข้า unrealistic;ถ้านั่นเป็นสถานการณ์นั้นคุณก็คงไม่ต้องการใช้ constrained-categories ในตอนแรก

เอาเป็นว่าวัตถุคุณต้องการอยู่ของคุณแสดงอยู่ Intเอส ()s และรอบการ tuples ของพวกนั้นด้วย (จะได้ส่วนขยายเพิ่มเติมเพื่ออีกประเภทหรือรายชื่อของอะตอมประเภท.) จากนั้นเราจะสามารถตามแกะรอยอยู่ที่ค่าระดับอะไรประเภทมันเป็นจริงๆแล้วพวกเราก็กำลังรับมือกับ:

data IntTupleFlavour t where
  UnitCase :: IntTupleFlavour ()
  IntCase :: IntTupleFlavour Int
  TupleCase :: IntTupleFlavour a -> IntTupleFlavour b -> IntTupleFlavour (a,b)

class IntTuple t where
  intTupleFlavour :: IntTupleFlavour t
instance IntTuple () where
  intTupleFlavour = UnitCase
instance IntTuple Int where
  intTupleFlavour = IntCase
instance (IntTuple a, IntTuple b) => IntTuple (a,b) where
  intTupleFlavour = TupleCase intTupleFlavour intTupleFlavour

data IntFree a b where
  IntId :: IntTupleFlavour a -> IntFree a a
  IntCompo :: IntTupleFlavour b -> IntFree b c -> IntFree a b -> IntFree a c

instance Category IntFree where
  type Object IntFree a = IntTuple a
  id = IntId intTupleFlavour
  (.) = IntCompo intTupleFlavour

ตอนนี้มันง่ายที่จะเขียนแสดงของฟรีหมวดหมู่ที่คอมไพเลอร์ รู้ว่า อะไรเป็นวัตถุอยู่ที่นี่และ p ไม่แม้แต่จะพูดถึงเลย

e4 :: IntFree Int Int
e4 = id

p เดียวที่เข้ามาเมื่อคุณในที่สุดแปลเพื่อนประเภทนั้น..

class IntMonoiCat p where
  proveIntTupleInstance :: IntTupleFlavour t -> (Object p t => r) -> r

instance IntMonoiCat MyArr where
  proveIntTupleInstance _ q = q
    -- trivial, because `MyArr` doesn't even have a constraint! In general,
    -- you would need to pattern-match on the `IntTupleFlavour` here.

แล้ว

instance EnhancedCat MyArr IntFree where
  arr (IntId itf) = proveIntTupleInstance itf id
  arr (IntCompo f g) = ...
        -- here you still need to extract the `IntTupleFlavours`
        -- for the `a` and `c` types. That requires digging into
        -- the free-category structure with a helper function.

ฉันกำลังมองหาตอนนี้คำตอบอีกครั้งและฉันคิดว่าของคุณ IntTupleFlavor คือสิ่งที่เป็น singleton และ IntTuple ชั้นเรียนก็คือโดยปรกติจะถูกเรียกว่า"ที่แยกกำหนด singleton"หรือ SingIฉันคิดว่านะ แล้วแต่ละ constructor องเราก็เก็บเอาพฤติกรรมแบเป็น singleton หลักฐานของมันเป็นพารามิเตอร์เป็นประเภท. น่าสนใจมาก,ขอบคุณผมจะปล่อยให้คุณรู้ว่าพวกมันทำงาน!
ใช่,หลังจากรักษาความคิดของคุณเป็น singletons มันก็ทำงานค่อนข้างโอเค มันยังเกี่ยวข้องกับเล็กน้อย boilerplate แต่อย่างแน่นน้อยลง!
เจ๋ง!ฉันมีปืนรึเปล่า? ใช่ singletons เป็นหนึ่งในสิ่งที่ฉันไม่เคยได้อยู่ที่นั่นเพื่อเรียนรู้,แต่อาจจะเรื่องนี้มันแน่ชัดจะตายคืออะไรต้องการอยู่ที่นี่

จะให้ฉันใช้ Constraint ครอบครัวที่อยู่ในขอบเขตเพื่อพิสูจน์โหภายในร่างของการแสดง?

คำถาม

คำตอบที่ดีที่สุด

ในภาษาอื่นๆ

หน้านี้อยู่ในภาษาอื่นๆ

ดังอยู่ในนี้หมวดหมู่

ดังคำถามอยู่ในนี้หมวดหมู่