## [REBOL] Re: Updates to hof script

### From: jan::skibinski::sympatico::ca at: 16-Nov-2002 7:26

Hi Gabriele,> I think the problem here is with the notation. Most people is not > familiar with it, and it is not intuitive enough to be able to > guess what it means without someone telling you. > > >> Mapping two series via binary function: > >> ((a -+ b -+ c) -+ [a] -+ [b] -+ [c]) > > Would a notation such as: > > ((a b -> c) [a] [b] -> [c]) > > be more easy to understand by a casual reader? >I hope you don't mean: using -> instead of the -+. That was the intention to start with but Rebol would not let me use it. So the latter is just a poor imitation of the former. This cosmetic change aside, there is a problem with your suggestion. More complex types, which I hope to avoid at least at this stage, need so-called type constructors, such as 'Ket, as in: Scalar -> Ket a -> Ket a Abusing the definition: the type constructor is sort of a container with a generic type 'a inside. There could be therefore: Ket integer, Ket logic or even Ket (Ket tuple) Some other type constructors would need more than one type variables, such as Tree a b To be frank, when representing series I should have used such notation perhaps to be more specific about kind of series I have in mind, such as: Block a, Paren a, etc. Instead, I simplified everything to [a]. Not very strict, but at least showing the structure: [a] for vectors, [[a]] for vectors of vectors, etc. So we need some kind of separators, that would tell us where the types start and stop. Parens will not do, because they are needed for separating embedded functions. Generally accepted separator is ->, because it shows the direction "from to", as in length? :: [a] -> integer which reads: 'Length? has a type from a series 'a to integer. You feed it a series of any generic type and it responds with an integer. Whenever you see an arrow, this tells you that you deal with a function. If there is no arrow this mean just a simple data. A function can be completely unapplied, partially applied and completely applied, as in: :+ :+ 2 :+ 2 3 The corresponding types would be :+ :: integer -> integer -> integer "+ has type from integer to integer to integer" :+ 2 :: integer -> integer "+ 2 is a function that has type from integer to integer" :+ 2 3 :: integer "+ 2 3 has type integer" During this process you just remove one type and one arrow at each step, whenever you add one more argument. Oh boy, I should go back to bed for another hour or so. Did not have much sleep last night. Best wishes, Jan