如何解决如何定义Lisp在Haskell中的应用？
| 难道不应该在像Haskell这样的懒惰的语言中使用该定义来定义函数吗？apply f [] = f
apply f (x:xs) = apply (f x) xs
解决方法
很难将静态类型赋予
apply
import Data.Dynamic
import Data.Typeable
apply :: Dynamic -> [Dynamic] -> Dynamic
apply f [] = f
apply f (x:xs) = apply (f `dynApp` x) xs
Text.Printf
IncoherentInstances
b
data ListF a b = Cons b (ListF a (a -> b))
F
headF :: ListF a b -> b
headF (Cons b _) = b
mapF :: (b -> c) -> ListF a b -> ListF a c
mapF f (Cons v fs) = Cons (f v) (mapF (f.) fs)
partialApply :: ListF a b -> [a] -> ListF a b
partialApply fs [] = fs
partialApply (Cons f fs) (x:xs) = partialApply (mapF ($x) fs) xs
apply :: ListF a b -> [a] -> b
apply f xs = headF (partialApply f xs)
sum
sumF :: Num a => ListF a a
sumF = Cons 0 (mapF (+) sumF)
sumExample = apply sumF [3,4,5]
f True True True = 32
f True True False = 67
f _ _ _ = 9
tooMany = error \"too many arguments\"
tooFew = error \"too few arguments\"
lift0 v = Cons v tooMany
lift1 f = Cons tooFew (lift0 f)
lift2 f = Cons tooFew (lift1 f)
lift3 f = Cons tooFew (lift2 f)
fF1 = lift3 f
fExample1 = apply fF1 [True,True,True]
fExample2 = apply fF1 [True,False]
fExample3 = apply (partialApply fF1 [True,False]) [False]
lift0
lift1
lift2
lift3
lift
{-# LANGUAGE MultiParamTypeClasses,FlexibleInstances,FlexibleContexts,TypeFamilies,UndecidableInstances #-}
data Z = Z
newtype S n = S n
I n a b
a
n
class Lift n a b where
type I n a b :: *
lift :: n -> I n a b -> ListF a b
instance Lift Z a b where
type I Z a b = b
lift _ b = Cons b tooMany
instance (Lift n a (a -> b),I n a (a -> b) ~ (a -> I n a b)) => Lift (S n) a b where
type I (S n) a b = a -> I n a b
lift (S n) f = Cons tooFew (lift n f)
fF2 = lift (S (S (S Z))) f
fExample4 = apply fF2 [True,True]
fExample5 = apply fF2 [True,False]
fExample6 = apply (partialApply fF2 [True,False]) [False]
f
f x
a -> b -> c
f
f x
b -> c
a -> b -> c
a -> b
a -> (b -> c)
a -> b
b
b -> c
b -> b -> b -> ... -> c
b -> c
b
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE IncoherentInstances #-}
class Apply f a r | f -> a r where
apply :: f -> [a] -> r
instance Apply f a r => Apply (a -> f) a r where
apply f (a:as) = apply (f a) as
instance Apply r a r where
apply r _ = r
test = apply ((+) :: Int -> Int -> Int) [1::Int,2]
apply\' :: (a -> a -> a) -> [a] -> a
apply\' = apply
test\' = apply\' (+) [1,2]
apply f
f
type \'a RecFunction = RecFunction of (\'a -> \'a RecFunction)
let rec apply (f: \'a RecFunction) (lst: \'a list) =
match (lst,f) with
| ([],_) -> f
| ((x::xs),RecFunction z) -> apply (z x) xs
{-# LANGUAGE GADTs #-}
-- n represents function type,o represents output type
data LApp n o where
-- no arguments applied (function and output type are the same)
End :: LApp o o
-- intentional similarity to ($)
(:$) :: a -> LApp m o -> LApp (a -> m) o
infixr 5 :$ -- same as :
n
n
listApply
o
-- the apply function
listApply :: n -> LApp n o -> o
listApply fun End = fun
listApply fun (p :$ l) = listApply (fun p) l
-- showing off the power of AppL
main = do print . listApply reverse $ \"yrruC .B lleksaH\" :$ End
print . listApply (*) $ 1/2 :$ pi :$ End
print . listApply ($) $ head :$ [1..] :$ End
print $ listApply True End
listApply
-- Can\'t do this :(
-- listApply (**) $ foldr (:$) End [2,32]
LApp
-- Alternative definition
-- data FList n o a where
-- Nil :: FList o o a
-- Cons :: a -> FList f o a -> FList (a -> f) o a
pure f <*> [arg] <*> [arg2] ...
-- example
λ>pure (\\a b c -> (a*b)+c) <*> [2,4] <*> [3] <*> [1]
[7,13]
λ>pure (+) <*> [1] <*> [2]
[3]
λ>pure (+1) <*> [1..10]
[2,3,5,6,7,8,9,10,11]
-- Or,apply (+1) to items 1 through 10 and collect the results in a list
λ>pure (+) <*> [1..5] <*> [1..5]
[2,10]
{- The applicative instance of list gives you every possible combination of
elements from the lists provided,so that is every possible sum of pairs
between one and five -}
λ>pure (\\a b c -> (a*b)+c) <*> [2,4] <*> [4,3] <*> [1]
[9,17,13]
{- that\'s - 2*4+1,2*3+1,4*4+1,4*3+1
Or,I am repeating argC when I call this function twice,but a and b are
different -}
λ>pure (\\a b c -> show (a*b) ++ c) <*> [1,2] <*> [3,4] <*> [\" look mah,other types\"]
[\"3 look mah,other types\",\"4 look mah,\"6 look mah,\"8 look mah,other types\"]
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。