Haskell'deki Okları Deşifre Etme

Question

Haskell’de yeniyim ve Oklarla oynuyorum. Önceden oluşturulmuş bir Okun programsal olarak "sökülmesini" sağlayan bir araç yazmak istiyorum. potansiyel bir uygulama olarak, vs. gibi Arrow alır ve tüm concatenations, bölmelerini fan çıkışları temsil eden bir çizge döndüren bir işlev, hayal

Örneğin, >>> (& & & g, f) h verimler

----- f ---- 
---|   |--- h ----- 
    ----- g ---- 

gibi bir şey başlangıçta ben (haskell.org Ok öğretici uyarlanan) aşağıdaki basit olduğu gibi, desen eşleştirme yoluyla bunu yapmak mümkün olabileceğini düşündüm, ama işe yaramadı. (Yani, hem kurucu çocukların türlerini içeren bir parametreli tip) da başarısız kendi türlerini tanımlayarak bunu

module Main(main) where 

import Control.Arrow 
import Control.Category 
import Prelude hiding (id, (.)) 

newtype SimpleFunc a b = SimpleFunc {runF :: (a -> b)} 

instance Arrow SimpleFunc where 
    arr f = SimpleFunc f 
    first (SimpleFunc f) = SimpleFunc (mapFst f) where 
     mapFst g (a,b) = (g a, b) 
    second (SimpleFunc f) = SimpleFunc (mapSnd f) where 
     mapSnd g (a,b) = (a, g b) 

instance Category SimpleFunc where 
    (SimpleFunc g) . (SimpleFunc f) = SimpleFunc (g . f) 
    id = arr id 


f,g :: SimpleFunc Int Int 
f = arr (\x -> x - 5) 
g = arr (\x -> 3*x + 1) 

h1 :: SimpleFunc Int Int 
h1 = f >>> g 

h2 :: SimpleFunc Int (Int, Int) 
h2 = f &&& g 

# It would be great if I something like this worked 
is_split :: SimpleFunc a b -> Bool 
is_split (a1 >>> a2) = False 
is_split (a1 &&& a2) = True 
.... 

is_split h2 -- evaluates to True 
is_split h1 -- evaluates to False 

Bütün girişimleri.

Oluşturulduktan sonra bir okun bileşenlerini "ayırmak" için bir yol var mı?

Answer 1

Ağaç gibi serbest bir ok oluşturabilirsiniz, böylece yapısını denetleyebilirsiniz. Ya da altta yatan oka indirin. Bir örnek diğer SO sorusunda: Useful operations on free arrows

Answer 2

Yanıt genel olarak olmayacaktır, çünkü fanout ve kompozisyon ve diğer ok operatörleri, kurucu değil, fonksiyonlardır. Ağaçları diğer ağaçlardan oluşturdukları için "ağaçtan çekerek" diyebilirsiniz, çünkü kompozisyonu yapmak için kullanılan yapıcıları korur, ve Haskell onları onlarla eşleştirebilir. Ancak, oklar oluşturmanın, kompozisyonu gerçekleştirmek için kullanılan fanoutları ve bileşimleri koruyacağının bir garantisi yoktur. 2 + 3 eklemek ve sonra 5'i daha sonra çekmeye çalışmak gibi.