Question

I would like to create a structure datatype called Structured that can be used to represent String, Int and List. For example, structure is like: [Int, String, Int,[Int]].

Question 1: how to create this datatype?

data Structured = ...

Question 2: A function called Confirm that confirms the input satisfies a restriction, and has the signature type of confirm:: Restriction -> Structure ->Maybe Bool

Answer 1

data Structured = Structured Int String Int [Int]

would work.

confirm :: (Structured -> Bool) -> Structured -> Bool

seems a more sensible type, but has a trivial implementation as id.

I don’t think you would need to return Maybe Bool from a valudation function – Maybe a is good for when you usually resturn an a, but sometimes don’t. (It’s good for very simple error handling, for example – give Nothing if there was an error.) In this case, you can always make a conclusion as to whether your input was valid, so you can always give back True or False – no need for the Maybe.

Perhaps you could have something like

confirm :: (String -> Bool) -> (Int -> Bool) -> Structured -> Bool
confirm okString okInt (Structured int1 string int2 ints) =
       all okInt (int1:int2:ints) && okString string

Here int1:int2:ints is the list that has int1 in front of int2 in front of ints.

A slightly nicer way of defining Structured would be:

data Structured = Structured {
           length ::Int,
           name   ::String,
           width  ::Int,
           somenumbers :: [Int]}

then you’d have

confirm :: (String -> Bool) -> (Int -> Bool) -> Structured -> Bool
confirm okString okInt s =
       all okInt (length s:width s:somenumbers s) && okString (name s)

It does the same job as the first data declaration, but gives you functions for getting at the internals.