- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] closed classes
by MR K P SCHUPKE 06 Aug '04

06 Aug '04

Closed t => ???? You want a closed type? The parameter to a class is a type... Actually if you allow undecidable instances you can use the generic instance to close the class class OnlyInt a instance OnlyInt Int instance Fail () => OnlyInt x Where Fail is a class with no instances, that is not exported! If you try and add an instance to OnlyInt the program will fail with overlapping instances. Keean.

2 1

Re: [Haskell-cafe] Re: exceptions vs. Either
by MR K P SCHUPKE 06 Aug '04

06 Aug '04

>class HLe n n' >instance HLe HZero HZero >instance HLe x y => HLe (HSucc x) (HSucc y) Erm of course this was the definition for Equals, not less than or equals! class HLe n n' instance HLe HZero x instance HLe x y => HLe (HSucc x) (HSucc y) Is the definition for less than or equals... but it took me all of 5 seconds to realise the first definition I gave was wrong - because it is so simple... Keean.

1 0

Re: [Haskell-cafe] Re: exceptions vs. Either
by MR K P SCHUPKE 06 Aug '04

06 Aug '04

>>Static guarantees are great, but if you have to explicitly change your >>style of coding to cope with those extra constraints, it can become (very) >>cumbersome. I had to change coding style moving from imperative to declarative languages, but I think it was worth it... Likewise I think having the ability to make strong static guaranees is worth it - you may not, which is why it is important not to break any existing programs with language extensions (if any are necessary). My programs will have less bugs though! >"worse-is-better, even in its strawman form, has better survival I fully subscribe to the 'worse is better' approach, but I don't see how it contradicts the principle of static guarantees - you can have both. Simplicity is about algorithmic complexity not about whether type signatures are provided by the programmer. Infact type signatures are in themselves an embodyment of the simple is better principle. A type signature expresses certain static guarantees about the function in a vary compact way. Consider the sort example... being able to declare a type signature on a sort algorith that enforces ordering of the output would prove the sort algorithm can _only_ output correctly sorted lists under _all_ circunstances. This type signature is much simpler than the actual sort - hence is useful. sort :: (HList l,HOrderedList l') => l -> l' Nice and readable, and much simpler than the actual algorithm (be it bubble sort, or a quick sort) Keean.

2 1

Re: exceptions vs. Either
by MR K P SCHUPKE 06 Aug '04

06 Aug '04

What can I say... Static typing guarantees is what made me switch from object oriented languages like C++/ObjectiveC/Java (that and the availability of a good compiler) - So I am obviously in favour of more static guarantees - I believe programming by contract is the way to reliable _engineered_ software, so the more contractual obligations that can be concisely and clearly expressed in the type system the better. I think Haskell should support dependant types, after all if you don't want to use them you don't have to... (backwards compatability and all that) although it would be useful to have a replacement prelude that used dependant types versions of head etc... I have a hard time understanding why functional programmers would not want more static typing guarantees, after all they can always use C if they dont like type systems! Keean.

5 4

Re: [Haskell-cafe] Re: exceptions vs. Either
by MR K P SCHUPKE 06 Aug '04

06 Aug '04

>Not so. In Java, the programmer is forced to handle most exceptions I forgot you had to do that... Exceptions are explicit in the type signatures. I think Oleg posted a message a while back about how to make exceptions explicit in haskell type signatures... But I would rather use static guarantees where possible, and exceptions where necessary. I haven't really tried using the techniques for explicit exceptions, but on consideration I might see if it is practical to code in that style... Keean.

1 0

Re: [Haskell-cafe] introspection | meta data
by Crypt Master 05 Aug '04

05 Aug '04

>Can you name these fields? If so, haskell has (sorta clumsy) named >records, >and you can select and update fields by name, and you can replace >'setSFField 3 sf x' with 'sf {somefield=x}' I did think of this, but unfortunatly my algorithm cant use names (without hard coding all possible combinations ) > > So what is the general haskell approach to this type of >introspection/meta > > data problem... ? >A C array of pointers maps closest to a MutableArray, which is mostly a >list >with different performance. Unless you're casting pointers, in which case >Dynamic types or the Generic stuff is maybe what you want. Or a redesign >;) I looked at haskell arrays, but since I cant point to an element in my tuple it wont work out. The ANSI C use of arrays is a really simple (but nasty) way to provide a means for me to loop over a fixed struct record. The Generic library looks super, only had time to browse some slides thus far, but will defiantly try understand that. As for a redesign and >Others have given good answers for this, but I suspect you may have chosen >the >wrong data structure... I would be keen on any ideas you have on how to design this in haskell. Learning to think in haskell is after all the goal :-) The example below is trivial and real world, both reasons why I chose to use it. Any comments welcome, none expected :-) Thanks, -- I idea is to perform a search over a number fields in a hierachical fashion where each field can have a wild card. The real world example is printer selection. In a multi-national company all users tend to be on one (or a few) central servers, but require there printouts to come to them locally whereever they are. Users typically range in 1000s and so "by user" defintions are out. Simplified Search fields: Environemnt, Users, Report, Version, Host Printer ---------------------------------------------------------- ---------- The "most" speicific field is host on the right with it becomming more general moving to towards the left. Setup data could choose to override all of report "RPT1" version "Ver1" to Printer "Bobs Printer" *ALL, *ALL, "RPT1", "Ver1", "*ALL", "Bobs Printer" but Simon may be an exception, then a record could be added like so: *ALL, "SIMON", "RPT1", "Ver1", *ALL, "Simons Printer" This record would be found first for simon, but former found found for everyone else. A search starts from fully specific data i.e no wild cards. The basic algortihm I worked out is: 1. Search setup data 2. If no record found 2a: Set current field to most specific field (host in this case) 2b: Toggle current field ( if Wildcard then make it value, if value make it wildcard ) 2c: if current field is *ALL goto 1 above (we stop here to perform a search on the current permutation) 2d: Loop to 2b until no more fields And my haskell working proto type is this: module Main where -- Env User Report Version Host Printer egdata1 = [(("PD7334EU", "*ALL", "*ALL", "*ALL", "*ALL"), "Default Printer"), (("PD7334EU", "USER1", "*ALL", "*ALL", "*ALL"), "User1Printer"), (("PD7334EU", "USER2", "Report1", "Version1", "*ALL"), "User1Report1Printer"), (("PD7334EU", "*ALL", "Report2", "*ALL", "*ALL"), "Report2Printer")] type SearchFilter = (String, String, String, String, String) type Record = (SearchFilter, String) findPrinter :: String -> String -> String -> String -> String -> [Record] -> String findPrinter env user report version host printerdata = findPrinter' sf sf printerdata where sf = (env, user, report, version, host) findPrinter' :: SearchFilter -> SearchFilter -> [Record] -> String findPrinter' ("*ALL", "*ALL", "*ALL", "*ALL", "*ALL") _ _ = "" findPrinter' sf origsf printerdata | printer == "" = findPrinter' (toggle sf origsf 5) origsf printerdata | otherwise = printer where printer = searchPrinter sf printerdata searchPrinter :: SearchFilter -> [Record] -> String searchPrinter _ [] = "" searchPrinter sf ((x,p):xa) | sf == x = p | otherwise = searchPrinter sf xa toggle :: SearchFilter -> SearchFilter -> Int -> SearchFilter toggle sf origsf 0 = sf toggle sf origsf n | newValue == "*ALL" = newSF | otherwise = toggle newSF origsf (n-1) where newValue = toggleField (getSFField n sf) (getSFField n origsf) newSF = setSFField n sf newValue toggleField :: String -> String -> String toggleField "*ALL" x = x toggleField _ _ = "*ALL" getSFField :: Int -> SearchFilter -> String getSFField 1 (x,_,_,_,_) = x getSFField 2 (_,x,_,_,_) = x getSFField 3 (_,_,x,_,_) = x getSFField 4 (_,_,_,x,_) = x getSFField 5 (_,_,_,_,x) = x setSFField :: Int -> SearchFilter -> String -> SearchFilter setSFField 1 (a,b,c,d,e) f = (f,b,c,d,e) setSFField 2 (a,b,c,d,e) f = (a,f,c,d,e) setSFField 3 (a,b,c,d,e) f = (a,b,f,d,e) setSFField 4 (a,b,c,d,e) f = (a,b,c,f,e) setSFField 5 (a,b,c,d,e) f = (a,b,c,d,f) main = putStrLn (findPrinter "PD7334EU" "USER2" "Report2" "Version3" "SomeHost" egdata1) _________________________________________________________________ Add photos to your messages with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

1 0

introspection | meta data
by Crypt Master 05 Aug '04

05 Aug '04

Hi I recently had to implement an algorthm in C, and found the time to give it a go in Haskell to aid in learning haskell. I found myself "needing" runtime meta information on data types (well tuples which are data (a,b) = (a,b)). Does haskell allow this ? Basically I need to loop over the fields in my record. I came up with functions like this: -- Toggle fields to/from generic value toggle sf origsf 0 = sf toggle sf origsf n | newValue == "*ALL" = newSF | otherwise = toggle newSF origsf (n-1) -- <--------- Loop through fields by No where newValue = toggleField (getSFField n sf) (getSFField n origsf) -- <---- accessor functions newSF = setSFField n sf newValue .... getSFField :: Int -> SearchFilter -> String getSFField 1 (x,_,_,_,_) = x getSFField 2 (_,x,_,_,_) = x .... setSFField :: Int -> SearchFilter -> String -> SearchFilter setSFField 1 (a,b,c,d,e) f = (f,b,c,d,e) setSFField 2 (a,b,c,d,e) f = (a,f,c,d,e) .... The only problem with this is that if I want to add or remove a field, I need to change a lot of code. In most OO lanaguages I could use "reflection" to loop through my fields. In C (which also doesnt have meta data) I got round it by using pointers in an array. To add or remove a field just requires adding or removing a pointer to my array which is one line of code. The only thought I had was of using lists, but the this would mean I loose pattern matching against all values at once which is appealing for calrify of code. So what is the general haskell approach to this type of introspection/meta data problem... ? Thanks, _________________________________________________________________ Protect your PC - get McAfee.com VirusScan Online http://clinic.mcafee.com/clinic/ibuy/campaign.asp?cid=3963

2 1

Re: [Haskell-cafe] introspection | meta data
by MR K P SCHUPKE 05 Aug '04

05 Aug '04

>Introspection in Haskell is provided by the Data.Generics module. The difference between the Data.Typeable and HList approach is that Generics use run-time information to make choises, HLists use the type system to make static guarantes. You can actually combine the two quite nicely and end up with statically constrained dynamics (or Stanamics as Ralf calls them) ... That is a dynamic opaque container constrained to contain only a certain group of types statically! Keean.

1 0

Re: [Haskell-cafe] introspection | meta data
by Jon Cast 05 Aug '04

05 Aug '04

Crypt Master <cryptmaster(a)hotmail.com> wrote: > I recently had to implement an algorthm in C, and found the time to > give it a go in Haskell to aid in learning haskell. > > I found myself "needing" runtime meta information on data types (well > tuples which are data (a,b) = (a,b)). Does haskell allow this ? <snip absolutely normal example> > So what is the general haskell approach to this type of > introspection/meta data problem... ? Introspection in Haskell is provided by the Data.Generics module. Try `deriving Data' and go wild (everybody else has). Jon Cast

1 0

Re: [Haskell-cafe] introspection | meta data
by MR K P SCHUPKE 05 Aug '04

05 Aug '04

>In most OO lanaguages I could use "reflection" to loop through my fields. You could try a heterogeneous list, see: http://homepages.cwi.nl/~ralf/HList/ Keean/ ,.

1 0