Curry: An Integrated Functional Logic Language

More documents

Recommendations

Info

A.2 Higher-Order Functions Here are some “traditional” higher-order functions to show that the familiar functional programming techniques can be applied in Curry. Note that the functions map, foldr, and filter are predefined in Curry (see Appendix B). -- Map a function on a list (predefined): map :: (t1->t2) -> [t1] -> [t2] map f [] = [] map f (x:xs) = f x:map f xs -- Fold a list (predefined): foldr :: (t1->t2->t2) -> t2 -> [t1] -> t2 foldr f a [] = a foldr f a (x:xs) = f x (foldr f a xs) -- Filter elements in a list (predefined): filter :: (t -> Bool) -> [t] -> [t] filter p [] = [] filter p (x:xs) = if p x then x:filter p xs else filter p xs -- Quicksort function: quicksort :: [Int] -> [Int] quicksort [] = [] quicksort (x:xs) = quicksort (filter ( x) xs) 39
A.3 Relational Programming Here is a traditional example from logic programming: a simple deductive database with family relationships. We use a relational programming style, i.e., all relationships are represented as constraints (i.e., functions with result type Success). -- Declaration of an enumeration type for persons: -- (as an alternative, one could consider persons as strings) data Person = Christine | Maria | Monica | Alice | Susan | Antony | Bill | John | Frank | Peter | Andrew -- Two basic relationships: married :: Person -> Person -> Success married Christine Antony = success married Maria Bill = success married Monica John = success married Alice Frank = success mother :: Person -> Person -> Success mother Christine John = success mother Christine Alice = success mother Maria Frank = success mother Monica Susan = success mother Monica Peter = success mother Alice Andrew = success -- and here are the deduced relationships: father :: Person -> Person -> Success father f c = let m free in married m f & mother m c grandfather :: Person -> Person -> Success grandfather g c = let f free in father g f & father f c grandfather g c = let m free in father g m & mother m c Expressions and their evaluated results: father John child ❀ {child=Susan} | {child=Peter} grandfather g c ❀ {g=Antony,c=Susan} | {g=Antony,c=Peter} | {g=Bill,c=Andrew} | {g=Antony,c=Andrew} 40
Page 1 and 2: Curry An Integrated Functional Logi
Page 3 and 4: 9 Interface to External Functions a
Page 5 and 6: and introduces a new n-ary type con
Page 7 and 8: tion 3 with σ(t1 . . . tn) = σ(t
Page 9 and 10: since the variables occurring in pa
Page 11 and 12: tified variable (and, thus, it can
Page 13 and 14: such cases, anonymous functions (λ
Page 15 and 16: ❀ {x=1,y=3} (The empty constraint
Page 17 and 18: 4.1.3 Functions The type t1 -> t2 i
Page 19 and 20: 4.1.8 Strings The type String is an
Page 21 and 22: g :: [a] -> [b] -> ([a],[b]) g x y
Page 23 and 24: In the last translation rule, conca
Page 25 and 26: to the module head. For instance, a
Page 27 and 28: module main where import m1 hiding
Page 29 and 30: take a character (string) and produ
Page 31 and 32: which takes a search goal and produ
Page 33 and 34: instance, if we want to compute the
Page 35 and 36: Intuitively, a function f declared
Page 37 and 38: 10 Literate Programming To encourag
Page 39: A Example Programs This section con
Page 43 and 44: A.5 Constraint Solving and Concurre
Page 45 and 46: A.6 Concurrent Object-Oriented Prog
Page 47 and 48: B Standard Prelude This section con
Page 49 and 50: not :: Bool -> Bool not True = Fals
Page 51 and 52: foldr1 _ [x] = x foldr1 f (x1:x2:xs
Page 53 and 54: takeWhile _ [] = [] takeWhile p (x:
Page 55 and 56: enumFromThen n1 n2 = iterate ((n2-n
Page 57 and 58: putStr [] = done putStr (c:cs) = pu
Page 59 and 60: owseList (g:gs) = browse g >> putCh
Page 61 and 62: C.2 Layout Similarly to Haskell, a
Page 63 and 64: SimplePattern ::= VariableID | _ |
Page 65 and 66: D Operational Semantics of Curry Th
Page 67 and 68: Computation step for a single expre
Page 69 and 70: Eval [e; rule(l | c = r)] ⇒ {id
Page 71 and 72: to an expression): Eval [ϕ(e1, . .
Page 73 and 74: Eval [try(g)] ⇒ ⎧ [] if Eval [c
Page 75 and 76: D.8 Eliminating Local Declarations
Page 77 and 78: f ′′ x1 . . . xk y1 . . . ym =
Page 79 and 80: References [1] H. Aït-Kaci. An Ove
Page 81 and 82: [29] T. Johnsson. Lambda Lifting: T
Page 83 and 84: Index !!, 49 Dom, 64 VRan, 64 (), 1
Page 85 and 86: higher-order equation, 6 id, 46 if_

Curry: An Integrated Functional Logic Language

Create successful ePaper yourself

Delete template?

Save as template?